@statelyai/layout 0.4.0 → 0.4.2

package/dist/{layered-C7ERzZjR.mjs → layered-BsAdm_u8.mjs}

@@ -311,6 +311,12 @@ const restoreInitialModelOrder = (input, graph) => {
 //#endregion
 //#region src/layered/port-distributor.ts
 /** Stateful clockwise port distribution across successive layer sweeps. */
+const sideRank = {
+	NORTH: 0,
+	EAST: 1,
+	SOUTH: 2,
+	WEST: 3
+};
 var CanonicalPortDistributor = class {
 	state;
 	topologyGraph;
@@ -359,25 +365,33 @@ var CanonicalPortDistributor = class {
 	calculatePortRanks(graph, layer, input, nodeRelative) {
 		this.prepareTopology(graph);
 		let consumed = 0;
+		const ends = input ? this.incoming : this.outgoing;
+		const ranked = (port) => ends.get(port.id).length > 0;
 		for (const node of layer) {
-			const ports = node.ports.filter((port) => (input ? this.incoming : this.outgoing).get(port.id).length > 0);
-			const increment = nodeRelative ? 1 / (ports.length + 1) : 1;
+			let count = 0, northCount = 0;
+			for (const port of node.ports) if (ranked(port)) {
+				count++;
+				if (port.side === "NORTH") northCount++;
+			}
+			const increment = nodeRelative ? 1 / (count + 1) : 1;
 			if (input) {
-				let north = consumed + ports.filter((port) => port.side === "NORTH").length * increment;
-				let rest = nodeRelative ? consumed + 1 - increment : consumed + ports.length;
-				for (const port of ports) {
+				let north = consumed + northCount * increment;
+				let rest = nodeRelative ? consumed + 1 - increment : consumed + count;
+				for (const port of node.ports) {
+					if (!ranked(port)) continue;
 					this.state.ranks[port.id] = port.side === "NORTH" ? north : rest;
 					if (port.side === "NORTH") north -= increment;
 					else rest -= increment;
 				}
 			} else {
 				let position = consumed + increment;
-				for (const port of ports) {
+				for (const port of node.ports) {
+					if (!ranked(port)) continue;
 					this.state.ranks[port.id] = position;
 					position += increment;
 				}
 			}
-			consumed += nodeRelative ? 1 : ports.length;
+			consumed += nodeRelative ? 1 : count;
 		}
 	}
 	distribute(graph, index, forward, options) {
@@ -386,7 +400,7 @@ var CanonicalPortDistributor = class {
 		const degree = (port) => incoming.get(port).length + outgoing.get(port).length;
 		const ranks = (layer, input) => this.calculatePortRanks(graph, layer, input, options.nodeRelative);
 		const distributeNode = (node, side$1) => {
-			if (options.fixedOrder.has(node.id)) return;
+			if (options.fixedOrder.has(node.id) || !node.ports.length) return;
 			const layerIndex = node.ports.length ? layerByPort.get(node.ports[0].id) : index;
 			const size$1 = graph.layers[layerIndex].length;
 			for (const face of [
@@ -396,7 +410,8 @@ var CanonicalPortDistributor = class {
 			]) {
 				let minimum = 0, maximum = 0;
 				const inLayer = [];
-				for (const port of node.ports.filter((port$1) => port$1.side === face)) {
+				for (const port of node.ports) {
+					if (port.side !== face) continue;
 					let sum = 0;
 					const cross = port.side === "NORTH" || port.side === "SOUTH";
 					if (cross) {
@@ -414,7 +429,8 @@ var CanonicalPortDistributor = class {
 						else if (output && !input) sum += position + 1;
 						else if (input && output) sum += port.side === "NORTH" ? 0 : large / 2;
 					} else {
-						if ([...outgoing.get(port.id), ...incoming.get(port.id)].some((peer) => layerByPort.get(peer) === layerIndex)) {
+						const sameLayer = (peer) => layerByPort.get(peer) === layerIndex;
+						if (outgoing.get(port.id).some(sameLayer) || incoming.get(port.id).some(sameLayer)) {
 							inLayer.push(port);
 							continue;
 						}
@@ -435,12 +451,7 @@ var CanonicalPortDistributor = class {
 					this.state.barycenters[port.id] = port.side === "EAST" ? above ? minimum - value : maximum + (size$1 + 1 - value) : above ? maximum + value : minimum - (size$1 + 1 - value);
 				}
 			}
-			const sideRank = {
-				NORTH: 0,
-				EAST: 1,
-				SOUTH: 2,
-				WEST: 3
-			};
+			if (node.ports.length < 2) return;
 			node.ports.sort((a, b) => {
 				const side$2 = sideRank[a.side] - sideRank[b.side];
 				if (side$2) return side$2;
@@ -506,10 +517,18 @@ function createOrthogonalHypersegments(ports, connections, listRank) {
 		segmentByPort
 	};
 }
-/** ELK's hyperedge crossing estimate; positions are distinct ordinal port ranks on each side. */
-function countOrthogonalHypersegmentCrossings(ports, connections) {
-	const { segments } = createOrthogonalHypersegments(ports, connections);
-	const spans = segments.map((s) => ({
+/**
+* {@link countOrthogonalHypersegmentCrossings}, optionally separating shared
+* tracks. ELK routes a hyperedge on one shared track. When it joins two or
+* more ports on each side, its edges would run opposite ways along that
+* track, which routing never allows; `separateShared` counts such a
+* hyperedge's edges one by one instead. `shared` reports whether one exists.
+*/
+function scoreOrthogonalHypersegments(ports, connections, separateShared = false) {
+	const { segments: merged, segmentByPort } = createOrthogonalHypersegments(ports, connections);
+	const sharedSegments = new Set(merged.flatMap((s, i) => s.incoming.length > 1 && s.outgoing.length > 1 ? [i] : []));
+	const separating = separateShared && sharedSegments.size > 0;
+	const spans = merged.filter((_, i) => !separating || !sharedSegments.has(i)).map((s) => ({
 		leftStart: Math.min(...s.incoming),
 		leftEnd: Math.max(...s.incoming),
 		rightStart: Math.min(...s.outgoing),
@@ -522,6 +541,43 @@ function countOrthogonalHypersegmentCrossings(ports, connections) {
 		if (a.leftStart < b.leftEnd && b.leftStart < a.leftEnd) count++;
 		if (a.rightStart < b.rightEnd && b.rightStart < a.rightEnd) count++;
 	}
+	if (separating) {
+		const position = new Map(ports.map((p) => [p.id, p.position]));
+		const edges = connections.filter((c$1) => sharedSegments.has(segmentByPort.get(c$1.source))).map((c$1) => [position.get(c$1.source), position.get(c$1.target)]);
+		for (const [left, right] of edges) for (const b of spans) {
+			if ((left - b.leftStart) * (right - b.rightStart) < 0) count++;
+			if (left < b.leftEnd && b.leftStart < left) count++;
+			if (right < b.rightEnd && b.rightStart < right) count++;
+		}
+		count += strictInversions(edges);
+	}
+	return {
+		count,
+		shared: sharedSegments.size > 0
+	};
+}
+/** Pairs whose ends are strictly inverted: two separated edges that cross, in O(n log n). */
+function strictInversions(pairs) {
+	const ranks = [...new Set(pairs.map(([, right]) => right))].sort((a, b) => a - b);
+	const rankOf = new Map(ranks.map((value, index) => [value, index + 1]));
+	const tree = new Array(ranks.length + 1).fill(0);
+	const atMost = (rank) => {
+		let sum = 0;
+		for (let i = rank; i > 0; i -= i & -i) sum += tree[i];
+		return sum;
+	};
+	const sorted = [...pairs].sort((a, b) => a[0] - b[0]);
+	let inserted = 0, count = 0;
+	for (let start = 0; start < sorted.length;) {
+		let end = start;
+		while (end < sorted.length && sorted[end][0] === sorted[start][0]) end++;
+		for (let i = start; i < end; i++) count += inserted - atMost(rankOf.get(sorted[i][1]));
+		for (let i = start; i < end; i++) {
+			for (let r = rankOf.get(sorted[i][1]); r <= ranks.length; r += r & -r) tree[r]++;
+			inserted++;
+		}
+		start = end;
+	}
 	return count;
 }
 
@@ -555,7 +611,7 @@ var IndexTree = class {
 };
 /** Score a canonical candidate without changing its node or port orders. */
 function countAllCrossings(graph, boundaryMode = "hyperedges") {
-	const nodes = new Map(graph.layers.flat().map((node) => [node.id, node]));
+	let nodes;
 	const layerByPort = /* @__PURE__ */ new Map();
 	const incoming = /* @__PURE__ */ new Map(), outgoing = /* @__PURE__ */ new Map();
 	for (const [layer, members] of graph.layers.entries()) for (const node of members) for (const port of node.ports) {
@@ -567,7 +623,6 @@ function countAllCrossings(graph, boundaryMode = "hyperedges") {
 		outgoing.get(edge.source).push(edge.target);
 		incoming.get(edge.target).push(edge.source);
 	}
-	const connected = (id) => [...incoming.get(id), ...outgoing.get(id)];
 	const degree = (id) => incoming.get(id).length + outgoing.get(id).length;
 	const face = (layer, side, topDown = true) => (topDown ? layer : [...layer].reverse()).flatMap((node) => {
 		const ports = node.ports.filter((port) => port.side === side);
@@ -580,7 +635,9 @@ function countAllCrossings(graph, boundaryMode = "hyperedges") {
 		for (const [position, port] of ports.entries()) {
 			tree.remove(position);
 			const pending = [];
-			for (const peer of connected(port.id)) {
+			const before = incoming.get(port.id), after = outgoing.get(port.id);
+			for (let index = 0; index < before.length + after.length; index++) {
+				const peer = index < before.length ? before[index] : after[index - before.length];
 				if (inLayerOnly && layerByPort.get(peer) !== layerByPort.get(port.id)) {
 					crossings$1 += tree.size;
 					continue;
@@ -624,7 +681,7 @@ function countAllCrossings(graph, boundaryMode = "hyperedges") {
 		for (const [position, port] of ports.entries()) {
 			tree.remove(position);
 			const node = ownerByPort.get(port.id);
-			const targets = node.type === "NORMAL" ? nodes.get(port.dummy).ports.map((peer) => ({
+			const targets = node.type === "NORMAL" ? (nodes ??= new Map(graph.layers.flat().map((node$1) => [node$1.id, node$1]))).get(port.dummy).ports.map((peer) => ({
 				id: peer.id,
 				degree: degree(peer.id)
 			})) : node.type === "LONG_EDGE" ? node.ports.filter((peer) => peer.id !== port.id).slice(0, 1).map((peer) => ({
@@ -650,21 +707,22 @@ function countAllCrossings(graph, boundaryMode = "hyperedges") {
 		betweenLayers: 0,
 		inLayer: 0,
 		northSouth: 0,
-		total: 0
+		total: 0,
+		sharedTracks: false
 	};
 	if (!graph.layers.length) return score;
 	score.inLayer += countPorts(face(graph.layers[0], "WEST"), true);
 	score.inLayer += countPorts(face(graph.layers.at(-1), "EAST"), true);
 	for (const [index, layer] of graph.layers.entries()) {
 		const next = graph.layers[index + 1];
-		if (next) if ((layer.some((node) => node.ports.some((port) => port.side === "EAST" && degree(port.id) > 1)) || next.some((node) => node.ports.some((port) => port.side === "WEST" && degree(port.id) > 1))) && boundaryMode === "hyperedges") {
+		if (next) if ((layer.some((node) => node.ports.some((port) => port.side === "EAST" && degree(port.id) > 1)) || next.some((node) => node.ports.some((port) => port.side === "WEST" && degree(port.id) > 1))) && boundaryMode !== "edges") {
 			const sourcePorts = layer.flatMap((node) => node.ports).filter((port) => outgoing.get(port.id).some((peer) => layerByPort.get(peer) !== index));
 			const targetPorts = next.flatMap((node) => {
 				const connectedPorts = node.ports.filter((port) => incoming.get(port.id).some((peer) => layerByPort.get(peer) !== index + 1));
 				return [...connectedPorts.filter((port) => port.side === "NORTH").reverse(), ...connectedPorts.filter((port) => port.side !== "NORTH").reverse()];
 			});
 			const sources = new Set(sourcePorts.map((port) => port.id)), targets = new Set(targetPorts.map((port) => port.id));
-			score.betweenLayers += countOrthogonalHypersegmentCrossings([...sourcePorts.map((port, position) => ({
+			const hyperedges = scoreOrthogonalHypersegments([...sourcePorts.map((port, position) => ({
 				id: port.id,
 				side: "source",
 				position
@@ -672,7 +730,9 @@ function countAllCrossings(graph, boundaryMode = "hyperedges") {
 				id: port.id,
 				side: "target",
 				position
-			}))], graph.edges.filter((edge) => sources.has(edge.source) && targets.has(edge.target)));
+			}))], graph.edges.filter((edge) => sources.has(edge.source) && targets.has(edge.target)), boundaryMode === "separated");
+			score.betweenLayers += hyperedges.count;
+			score.sharedTracks ||= hyperedges.shared;
 			score.inLayer += countPorts(face(layer, "EAST"), true) + countPorts(face(next, "WEST"), true);
 		} else score.betweenLayers += countPorts([...face(layer, "EAST"), ...face(next, "WEST", false)], false);
 		if (layer.some((node) => node.type === "NORTH_SOUTH_PORT")) score.northSouth += countNorthSouth(layer);
@@ -1054,7 +1114,7 @@ function buildCrossingGraph(plan, layers, incoming, outgoing) {
 			for (const member of ports.get(operation.northSouthDummy)?.values() ?? []) member.port.origin = operation.id;
 		}
 	}
-	const sideRank = {
+	const sideRank$1 = {
 		NORTH: 0,
 		EAST: 1,
 		SOUTH: 2,
@@ -1067,7 +1127,7 @@ function buildCrossingGraph(plan, layers, incoming, outgoing) {
 				id,
 				type: kind?.type ?? kindOf(id, plan.units),
 				unit: kind ? kind.unit : plan.units?.units.get(id),
-				ports: [...ports.get(id)?.values() ?? []].sort((a, b) => sideRank[a.port.side] - sideRank[b.port.side] || a.rank - b.rank).map((member) => member.port)
+				ports: [...ports.get(id)?.values() ?? []].sort((a, b) => sideRank$1[a.port.side] - sideRank$1[b.port.side] || a.rank - b.rank).map((member) => member.port)
 			};
 		})),
 		edges: plan.edges.map((edge) => ({
@@ -1087,7 +1147,8 @@ function splitMixedCrossingPorts(graph, reversed) {
 	const directions = /* @__PURE__ */ new Map();
 	graph.edges.forEach((edge, index) => {
 		const bit = reversed[index] ? 2 : 1;
-		for (const port of [edge.source, edge.target]) directions.set(port, (directions.get(port) ?? 0) | bit);
+		directions.set(edge.source, (directions.get(edge.source) ?? 0) | bit);
+		directions.set(edge.target, (directions.get(edge.target) ?? 0) | bit);
 	});
 	const mixed = /* @__PURE__ */ new Set();
 	for (const layer of graph.layers) for (const node of layer) for (const port of node.ports) if (directions.get(port.id) === 3 && (port.side === "EAST" || port.side === "WEST")) mixed.add(port.id);
@@ -1527,20 +1588,46 @@ function selfLoopTracks(loops) {
 	}));
 }
 
+//#endregion
+//#region src/layered/node-lookup.ts
+const indexByNodes = /* @__PURE__ */ new WeakMap();
+function indexNodes(nodes) {
+	const positions = /* @__PURE__ */ new Map();
+	for (const [index, node] of nodes.entries()) if (!positions.has(node.id)) positions.set(node.id, index);
+	indexByNodes.set(nodes, {
+		length: nodes.length,
+		positions
+	});
+	return positions;
+}
+/** Same as `nodes.find((node) => node.id === id)`, indexed per list. */
+function findNode(nodes, id) {
+	const cached = indexByNodes.get(nodes);
+	let position = (cached && cached.length === nodes.length ? cached.positions : indexNodes(nodes)).get(id);
+	if (position !== void 0 && nodes[position]?.id !== id) position = indexNodes(nodes).get(id);
+	return position !== void 0 && nodes[position]?.id === id ? nodes[position] : nodes.find((node) => node.id === id);
+}
+
 //#endregion
 //#region src/layered/loop-envelopes.ts
 /** Unconstrained implicit loop ports are restored on loop faces after the sweep. */
 function hasMovableLoopPorts(input, edge) {
 	if (edge.sourceId !== edge.targetId || edge.sourcePort !== void 0 || edge.targetPort !== void 0) return false;
-	const node = input.graph.nodes.find((candidate) => candidate.id === edge.sourceId);
+	const node = findNode(input.graph.nodes, edge.sourceId);
 	const constraints = node && input.nodeSettings?.(node)?.portConstraints;
 	return constraints === void 0 || constraints === "FREE" || constraints === "UNDEFINED";
 }
 function loopEnvelopes(input) {
 	const envelopes = /* @__PURE__ */ new Map();
 	if ((input.settings.edgeRouting ?? "ORTHOGONAL") !== "ORTHOGONAL") return envelopes;
+	const loopsByNodeId = /* @__PURE__ */ new Map();
+	for (const edge of input.graph.edges) if (edge.sourceId === edge.targetId) {
+		const loops = loopsByNodeId.get(edge.sourceId);
+		if (loops) loops.push(edge);
+		else loopsByNodeId.set(edge.sourceId, [edge]);
+	}
 	for (const node of input.graph.nodes) {
-		const allLoops = input.graph.edges.filter((edge) => edge.sourceId === node.id && edge.targetId === node.id);
+		const allLoops = loopsByNodeId.get(node.id)?.slice() ?? [];
 		const constraints = input.nodeSettings?.(node)?.portConstraints;
 		if (allLoops.length && constraints && constraints !== "FREE" && constraints !== "UNDEFINED" && allLoops.every((edge) => edge.sourcePort !== void 0 && edge.targetPort !== void 0 && input.edgeSettings?.(edge)?.["edgeLabels.inline"] !== true && ((edge.width ?? 0) === 0 && (edge.height ?? 0) === 0 || (input.edgeSettings?.(edge)?.["edgeLabels.placement"] ?? "CENTER") === "CENTER"))) {
 			const size$1 = input.sizes.get(node.id) ?? {
@@ -1653,7 +1740,7 @@ function preparedLoopEnvelopes(input) {
 //#region src/layered/port-edge-order.ts
 /** ELK traverses connected edges through the node's port list, preserving each port's edge order. */
 function connectedEdgesInPortOrder(input, nodeId) {
-	const node = input.graph.nodes.find((candidate) => candidate.id === nodeId);
+	const node = findNode(input.graph.nodes, nodeId);
 	const portRank = new Map(node?.ports?.map((port, index) => [port.name, index]));
 	const explicitCount = portRank.size;
 	return input.graph.edges.map((edge, index) => ({
@@ -2542,8 +2629,8 @@ function nodeNodeSpacing(input, firstId, secondId) {
 	const secondBreakingPoint = secondId.startsWith("__layout_breaking:");
 	const firstLabel = firstId.startsWith("__layout_dummy:label:");
 	const secondLabel = secondId.startsWith("__layout_dummy:label:");
-	const firstNode = input.graph.nodes.find((node) => node.id === firstId);
-	const secondNode = input.graph.nodes.find((node) => node.id === secondId);
+	const firstNode = findNode(input.graph.nodes, firstId);
+	const secondNode = findNode(input.graph.nodes, secondId);
 	const firstExternal = firstNode !== void 0 && externalPortDummyOf(firstNode) !== void 0;
 	const secondExternal = secondNode !== void 0 && externalPortDummyOf(secondNode) !== void 0;
 	const firstDummy = firstId.startsWith("__layout_dummy:") || firstBreakingPoint || firstExternal;
@@ -2551,7 +2638,7 @@ function nodeNodeSpacing(input, firstId, secondId) {
 	const spacingName = firstExternal && secondExternal ? "spacing.portPort" : firstExternal && secondLabel || secondExternal && firstLabel ? "spacing.labelPortVertical" : firstLabel && secondLabel ? "spacing.edgeEdge" : firstLabel && !secondDummy || secondLabel && !firstDummy ? "spacing.node" : firstLabel && secondDummy || secondLabel && firstDummy ? "spacing.edgeNode" : firstDummy && secondDummy && firstBreakingPoint === secondBreakingPoint ? "spacing.edgeEdge" : firstDummy || secondDummy ? "spacing.edgeNode" : "spacing.node";
 	let spacing = spacingName === "spacing.portPort" ? Number(input.settings["spacing.portPort"] ?? 10) : spacingName === "spacing.labelPortVertical" ? Number(input.settings["spacing.labelPortVertical"] ?? 1) : spacingName === "spacing.edgeEdge" ? Number(input.settings["spacing.edgeEdge"] ?? 10) : spacingName === "spacing.edgeNode" ? Number(input.settings["spacing.edgeNode"] ?? 10) : input.spacing.node;
 	for (const id of [firstId, secondId]) {
-		const node = input.graph.nodes.find((candidate) => candidate.id === id);
+		const node = findNode(input.graph.nodes, id);
 		if (!node) continue;
 		const individual = input.nodeSettings?.(node)?.["spacing.individual"];
 		if (individual && typeof individual === "object") {
@@ -3362,16 +3449,35 @@ function sidePorts(node, side) {
 	const ports = node.ports.filter((port) => port.side === side);
 	return side === "WEST" || side === "SOUTH" ? ports.reverse() : ports;
 }
+function greedySwitchTopology(graph) {
+	const topology = {
+		incoming: /* @__PURE__ */ new Map(),
+		outgoing: /* @__PURE__ */ new Map(),
+		layerByPort: /* @__PURE__ */ new Map(),
+		ownerByPort: /* @__PURE__ */ new Map()
+	};
+	for (const [layer, nodes] of graph.layers.entries()) for (const node of nodes) for (const port of node.ports) {
+		topology.layerByPort.set(port.id, layer);
+		topology.ownerByPort.set(port.id, node);
+		topology.incoming.set(port.id, []);
+		topology.outgoing.set(port.id, []);
+	}
+	for (const edge of graph.edges) {
+		topology.outgoing.get(edge.source)?.push(edge.target);
+		topology.incoming.get(edge.target)?.push(edge.source);
+	}
+	return topology;
+}
 /**
 * Decides greedy switches in one free layer from local two-node crossing
 * counts, exactly as ELK does; these estimates can differ from a global recount.
 */
 var GreedySwitchDecider = class {
 	#free;
-	#incoming = /* @__PURE__ */ new Map();
-	#outgoing = /* @__PURE__ */ new Map();
-	#layerByPort = /* @__PURE__ */ new Map();
-	#ownerByPort = /* @__PURE__ */ new Map();
+	#incoming;
+	#outgoing;
+	#layerByPort;
+	#ownerByPort;
 	#neighbourPositions = /* @__PURE__ */ new Map();
 	#adjacencies = /* @__PURE__ */ new Map();
 	#matrix = /* @__PURE__ */ new Map();
@@ -3379,19 +3485,13 @@ var GreedySwitchDecider = class {
 	#cardinality = /* @__PURE__ */ new Map();
 	#inLayerSize = /* @__PURE__ */ new Map();
 	#oneSided;
-	constructor(graph, freeLayerIndex, oneSided) {
+	constructor(graph, freeLayerIndex, oneSided, topology = greedySwitchTopology(graph)) {
 		this.#free = graph.layers[freeLayerIndex] ?? [];
 		this.#oneSided = oneSided;
-		for (const [layer, nodes] of graph.layers.entries()) for (const node of nodes) for (const port of node.ports) {
-			this.#layerByPort.set(port.id, layer);
-			this.#ownerByPort.set(port.id, node);
-			this.#incoming.set(port.id, []);
-			this.#outgoing.set(port.id, []);
-		}
-		for (const edge of graph.edges) {
-			this.#outgoing.get(edge.source)?.push(edge.target);
-			this.#incoming.get(edge.target)?.push(edge.source);
-		}
+		this.#incoming = topology.incoming;
+		this.#outgoing = topology.outgoing;
+		this.#layerByPort = topology.layerByPort;
+		this.#ownerByPort = topology.ownerByPort;
 		for (const [layerIndex, side] of [[freeLayerIndex - 1, "EAST"], [freeLayerIndex + 1, "WEST"]]) {
 			let position = 0;
 			for (const node of graph.layers[layerIndex] ?? []) for (const port of sidePorts(node, side)) this.#neighbourPositions.set(port.id, position++);
@@ -3641,6 +3741,18 @@ function cycleModelOrder(input) {
 	const count = Math.max(1, input.graph.nodes.length);
 	return new Map(input.graph.nodes.map((node, index) => [node.id, enforced ? Number(input.nodeSettings?.(node)?.["considerModelOrder.groupModelOrder.cycleBreakingId"] ?? 0) * count + index : index]));
 }
+/**
+* Internal setting: how crossing minimization models ports and tracks.
+* `mixedPorts` (default true) counts a port carrying both directions as two
+* ports and groups its neighbours by direction. `separateSharedTracks`
+* (default false) counts a hyperedge joining two or more ports on each side
+* of its gap edge by edge, since routing never lets edges run opposite ways
+* along one track. A `probe` records whether either choice can change the
+* order. Each helps on average but steers the sweeps into worse orders on
+* some graphs, so the elkjs facade also lays such graphs out with the
+* alternatives and keeps the best result.
+*/
+const CROSSING_MODEL = "internal.crossingModel";
 const breakCyclesWithDepthFirstSearch = (input) => {
 	const outgoing = /* @__PURE__ */ new Map();
 	for (const node of input.graph.nodes) outgoing.set(node.id, []);
@@ -4128,8 +4240,7 @@ function applyLayerConstraintOrder(input, order) {
 	return {
 		...order,
 		layers: order.layers.map((layer) => {
-			const unconstrained = layer.filter((id) => !constrained.has(id));
-			return [...input.settings.mergeEdges === true ? [...unconstrained.filter((id) => id.startsWith("__layout_dummy:")), ...unconstrained.filter((id) => !id.startsWith("__layout_dummy:"))] : unconstrained, ...layer.filter((id) => constrained.has(id))];
+			return [...layer.filter((id) => !constrained.has(id)), ...layer.filter((id) => constrained.has(id))];
 		})
 	};
 }
@@ -4252,6 +4363,7 @@ function applyGreedySwitch(input, orientation, order) {
 		if (oneSidedBoundary !== void 0) return countBoundary(oneSidedBoundary);
 		return (layerIndex > 0 ? countBoundary(layerIndex - 1) : 0) + (layerIndex + 1 < layers.length ? countBoundary(layerIndex) : 0);
 	};
+	let greedyTopology;
 	const sweep = (forward$1) => {
 		let changed = false;
 		const indices = forward$1 ? Array.from({ length: layers.length }, (_, index) => index) : Array.from({ length: layers.length }, (_, index) => layers.length - index - 1);
@@ -4261,7 +4373,7 @@ function applyGreedySwitch(input, orientation, order) {
 			if (greedyGraph) {
 				const units = getCrossingUnits(input);
 				greedyGraph.layers = layers.map((ids) => ids.map((id) => greedyNodes.get(id)));
-				const decider = new GreedySwitchDecider(greedyGraph, layerIndex, type === "ONE_SIDED" ? forward$1 ? "WEST" : "EAST" : void 0);
+				const decider = new GreedySwitchDecider(greedyGraph, layerIndex, type === "ONE_SIDED" ? forward$1 ? "WEST" : "EAST" : void 0, greedyTopology ??= greedySwitchTopology(greedyGraph));
 				do {
 					improved$1 = false;
 					for (let index = 0; index + 1 < layer.length; index++) {
@@ -4854,7 +4966,9 @@ function sortLayerByAdjacentPosition(layer, ranksByNodeId, statistic, random, pr
 	if (units && !forcedCompare) layer.splice(0, layer.length, ...resolveCrossingConstraints(layer, adjacentPosition, units));
 }
 function clonePortOrders(orders) {
-	return new Map([...orders ?? []].map(([id, edges]) => [id, [...edges]]));
+	const clone = /* @__PURE__ */ new Map();
+	if (orders) for (const [id, edges] of orders) clone.set(id, edges.slice());
+	return clone;
 }
 function minimizeCrossingsWithLayerSweep(statistic, sweeps = 7) {
 	return (input, orientation, assignment) => createLayerSweepSession(input, orientation, assignment, statistic, sweeps).minimize();
@@ -4896,6 +5010,18 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 	}
 	const nodeById = new Map(input.graph.nodes.map((node) => [node.id, node]));
 	const edgeById = new Map(input.graph.edges.map((edge) => [edge.id, edge]));
+	const boundaryPortIndex = (nodeId, edgeId, incoming) => {
+		const edge = edgeById.get(edgeId);
+		const name = incoming !== orientation.reversedEdgeIds.has(edgeId) ? edge.targetPort : edge.sourcePort;
+		if (!name?.startsWith("__native_hierarchy")) return -1;
+		return nodeById.get(nodeId).ports?.findIndex((port) => port.name === name) ?? -1;
+	};
+	for (const [orders, incoming] of [[outputPortOrder, false], [inputPortOrder, true]]) for (const [nodeId, edgeIds] of orders) {
+		if (edgeIds.length < 2) continue;
+		const slots = edgeIds.flatMap((id, slot) => boundaryPortIndex(nodeId, id, incoming) < 0 ? [] : [slot]);
+		const sorted = slots.map((slot) => edgeIds[slot]).sort((a, b) => boundaryPortIndex(nodeId, a, incoming) - boundaryPortIndex(nodeId, b, incoming));
+		slots.forEach((slot, index) => edgeIds[slot] = sorted[index]);
+	}
 	const edgeModelOrder = new Map(input.graph.edges.map((edge, index) => [edge.id, index]));
 	const hierarchicalNodes = /* @__PURE__ */ new Set();
 	const fixedOrderNodes = new Set(input.graph.nodes.filter((node) => {
@@ -4933,10 +5059,26 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 		if (edgeIds.length >= 4) edgeIds.splice(0, edgeIds.length - 1, ...edgeIds.slice(0, -1).reverse());
 	}
 	const buildCrossingGraph$1 = createCrossingGraphBuilder(input);
+	const crossingModel = input.settings[CROSSING_MODEL] ?? {};
+	const mixedPorts = crossingModel.mixedPorts !== false, probe = crossingModel.probe;
+	const physicalSlot = /* @__PURE__ */ new Map();
 	const countCrossings = (candidateLayers) => {
 		if (exactPortSweep) {
 			const graph = buildCrossingGraph$1(orientation, candidateLayers, inputPortOrder, outputPortOrder);
-			let total = countAllCrossings(splitMixedCrossingPorts(graph, canonicalReversed)).total;
+			for (const layer of graph.layers) for (const node of layer) {
+				const physical = node.ports.length > 1 ? canonicalNodes.get(node.id)?.ports : void 0;
+				if (physical?.length !== node.ports.length) continue;
+				physicalSlot.clear();
+				for (const [index, port] of physical.entries()) physicalSlot.set(port.id, index);
+				if (node.ports.every((port) => physicalSlot.has(port.id))) node.ports.sort((a, b) => physicalSlot.get(a.id) - physicalSlot.get(b.id));
+			}
+			const split = mixedPorts ? splitMixedCrossingPorts(graph, canonicalReversed) : graph;
+			const score = countAllCrossings(split, crossingModel.separateSharedTracks ? "separated" : "hyperedges");
+			if (probe) {
+				if (split !== graph) probe.mixedPorts = true;
+				if (score.sharedTracks) probe.sharedTracks = true;
+			}
+			let total = score.total;
 			const nodeInfluence = Number(input.settings["considerModelOrder.crossingCounterNodeInfluence"] ?? 0);
 			if ((input.settings["considerModelOrder.strategy"] ?? "NONE") !== "NONE" && nodeInfluence !== 0) {
 				const changes = countModelOrderChanges(input, orientation, graph);
@@ -4986,11 +5128,12 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 				const nodes = fixedLayer.map((id) => canonicalNodes.get(id));
 				canonicalGraph.layers[fixedIndex] = nodes;
 				canonicalDistributor.calculatePortRanks(canonicalGraph, nodes, !forward, nodeRelativePortRanks);
-				const fixedIds = new Set(fixedLayer);
-				for (let index = 0; index < canonicalEdges.length; index++) {
+				const byEnd = forward ? canonicalEdgesBySource : canonicalEdgesByTarget;
+				const indices = fixedLayer.flatMap((id) => byEnd.get(id) ?? []).sort((a, b) => a - b);
+				for (const index of indices) {
 					const edge = canonicalEdges[index];
 					const [source, target] = canonicalOrientedEndpoints[index];
-					if (!fixedIds.has(forward ? source : target) || !freeIds.has(forward ? target : source)) continue;
+					if (!freeIds.has(forward ? target : source)) continue;
 					const endpoint = canonicalEndpoints.get(edge.id);
 					const rank = canonicalDistributor.state.ranks[forward ? endpoint.source : endpoint.target];
 					ranks.get(forward ? target : source).push(rank);
@@ -5029,6 +5172,17 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 		}
 		for (const id of freeLayer) {
 			const order = (forward ? inputPortOrder : outputPortOrder).get(id) ?? [];
+			const visit = (edgeId) => {
+				const [source, target] = getOrientedEndpoints(edgeById.get(edgeId), orientation);
+				const neighbor = forward ? source : target;
+				const rank$1 = edgeRanks.get(edgeId);
+				if (assignment.layerByNodeId.get(neighbor) === assignment.layerByNodeId.get(id)) visits.get(id).push(neighbor);
+				else if (rank$1 !== void 0) visits.get(id).push(rank$1);
+			};
+			if (order.length < 2) {
+				for (const edgeId of order) visit(edgeId);
+				continue;
+			}
 			const groups = /* @__PURE__ */ new Map();
 			for (const edgeId of order) {
 				const edge = edgeById.get(edgeId);
@@ -5037,17 +5191,11 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 				if (group) group.push(edgeId);
 				else groups.set(key, [edgeId]);
 			}
+			const listed = units?.edgeListRanks?.[forward ? "incoming" : "outgoing"].get(id);
+			const rank = (edgeId) => listed?.get(listedEdgeId(edgeId));
 			for (const group of groups.values()) {
-				const listed = units?.edgeListRanks?.[forward ? "incoming" : "outgoing"].get(id);
-				const rank = (edgeId) => listed?.get(listedEdgeId(edgeId));
-				group.sort((a, b) => (rank(a) !== void 0 && rank(b) !== void 0 ? rank(a) - rank(b) : 0) || edgeModelOrder.get(a) - edgeModelOrder.get(b));
-				for (const edgeId of group) {
-					const [source, target] = getOrientedEndpoints(edgeById.get(edgeId), orientation);
-					const neighbor = forward ? source : target;
-					const rank$1 = edgeRanks.get(edgeId);
-					if (assignment.layerByNodeId.get(neighbor) === assignment.layerByNodeId.get(id)) visits.get(id).push(neighbor);
-					else if (rank$1 !== void 0) visits.get(id).push(rank$1);
-				}
+				if (group.length > 1) group.sort((a, b) => (rank(a) !== void 0 && rank(b) !== void 0 ? rank(a) - rank(b) : 0) || edgeModelOrder.get(a) - edgeModelOrder.get(b));
+				for (const edgeId of group) visit(edgeId);
 			}
 		}
 		return {
@@ -5072,6 +5220,14 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 	const canonicalEdges = input.graph.edges.filter((edge) => edge.sourceId !== edge.targetId);
 	const canonicalReversed = canonicalEdges.map((edge) => orientation.reversedEdgeIds.has(edge.id));
 	const canonicalOrientedEndpoints = canonicalEdges.map((edge) => getOrientedEndpoints(edge, orientation));
+	const canonicalEdgesBySource = /* @__PURE__ */ new Map(), canonicalEdgesByTarget = /* @__PURE__ */ new Map();
+	canonicalOrientedEndpoints.forEach(([source, target], index) => {
+		for (const [byEnd, id] of [[canonicalEdgesBySource, source], [canonicalEdgesByTarget, target]]) {
+			const list = byEnd.get(id);
+			if (list) list.push(index);
+			else byEnd.set(id, [index]);
+		}
+	});
 	const canonicalEndpoints = new Map(canonicalEdges.map((edge, index) => [edge.id, canonicalGraph.edges[index]]));
 	const canonicalFixedOrder = new Set(input.graph.nodes.filter((node) => {
 		const constraint = input.nodeSettings?.(node)?.portConstraints;
@@ -5087,6 +5243,7 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 			hierarchical: hierarchicalNodes
 		});
 		for (const index of touched) for (const node of canonicalGraph.layers[index]) {
+			if (node.ports.length < 2 || (outputPortOrder.get(node.id)?.length ?? 0) < 2 && (inputPortOrder.get(node.id)?.length ?? 0) < 2) continue;
 			const ordinal = new Map(node.ports.map((port, index$1) => [port.id, index$1]));
 			for (const [orders, source] of [[outputPortOrder, true], [inputPortOrder, false]]) orders.get(node.id)?.sort((left, right) => ordinal.get(canonicalEndpoints.get(left)[source ? "source" : "target"]) - ordinal.get(canonicalEndpoints.get(right)[source ? "source" : "target"]));
 		}
@@ -5121,6 +5278,7 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 	*/
 	const constrained = new Set([...units?.units.keys() ?? [], ...[...units?.successors ?? []].flatMap(([id, after]) => [id, ...after])]);
 	const groupMixedPortDirections = (free, fixed, beyond = []) => {
+		if (!mixedPorts) return;
 		const fixedIds = new Set(fixed);
 		const groups = /* @__PURE__ */ new Map();
 		for (const id of free) {
@@ -5143,6 +5301,7 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 			groups.set(key, group);
 		}
 		if (![...groups.values()].some((g) => g.some((m) => m.reversed) && g.some((m) => !m.reversed))) return;
+		if (probe) probe.mixedPorts = true;
 		const index = new Map(free.map((id, i) => [id, i]));
 		const far = new Map(beyond.map((id, i) => [id, i]));
 		const reach = (members) => {
@@ -5302,15 +5461,23 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 		shuffleFirstLayer,
 		sweep,
 		countCrossings: () => countCrossings(working),
-		snapshot: () => ({
-			physicalPortOrderByNodeId: new Map([...canonicalNodes].map(([id, node]) => [id, node.ports.map((port) => port.id)])),
-			layers: working.map((layer) => [...layer]),
-			inputPortOrderByNodeId: clonePortOrders(inputPortOrder),
-			outputPortOrderByNodeId: clonePortOrders(outputPortOrder)
-		}),
+		snapshot: () => {
+			const physicalPortOrderByNodeId = /* @__PURE__ */ new Map();
+			for (const [id, node] of canonicalNodes) physicalPortOrderByNodeId.set(id, node.ports.map((port) => port.id));
+			return {
+				physicalPortOrderByNodeId,
+				layers: working.map((layer) => [...layer]),
+				inputPortOrderByNodeId: clonePortOrders(inputPortOrder),
+				outputPortOrderByNodeId: clonePortOrders(outputPortOrder)
+			};
+		},
 		restore,
 		finish,
 		currentLayers: () => working,
+		crossingGraph: () => ({
+			layers: working.map((layer) => layer.map((id) => canonicalNodes.get(id))),
+			edges: canonicalGraph.edges
+		}),
 		physicalPortOrder: (id) => canonicalNodes.get(id)?.ports.map((port) => port.id) ?? [],
 		edgeOrders: (id) => ({
 			incoming: inputPortOrder.get(id) ?? [],
@@ -5713,7 +5880,7 @@ function sumWithSpacing(ids, input, axis) {
 	}, 0);
 }
 function nodeFlowOffset(input, id, layerFlowSize, nodeFlowSize, layerByNodeId, margins) {
-	const node = input.graph.nodes.find((candidate) => candidate.id === id);
+	const node = findNode(input.graph.nodes, id);
 	const alignment = node ? input.nodeSettings?.(node)?.alignment ?? input.settings.alignment : input.settings.alignment;
 	let ratio;
 	if (alignment === "LEFT" || alignment === "TOP") ratio = 0;
@@ -5962,7 +6129,56 @@ function simplifyRoute$1(points) {
 function implicitEdgeEndpoints(input, placement, orientation) {
 	const horizontal$1 = input.direction === "left" || input.direction === "right";
 	const nodeById = new Map(input.graph.nodes.map((node) => [node.id, node]));
-	const groups = /* @__PURE__ */ new Map();
+	const nodeSettingsByNode = /* @__PURE__ */ new Map();
+	const nodeSettingsOf = (node) => {
+		if (!nodeSettingsByNode.has(node)) nodeSettingsByNode.set(node, input.nodeSettings?.(node));
+		return nodeSettingsByNode.get(node);
+	};
+	const portSettingsByNode = /* @__PURE__ */ new Map();
+	const portSettingsOf = (port, node) => {
+		let byPort = portSettingsByNode.get(node);
+		if (!byPort) portSettingsByNode.set(node, byPort = /* @__PURE__ */ new Map());
+		if (!byPort.has(port)) byPort.set(port, input.portSettings?.(port, node));
+		return byPort.get(port);
+	};
+	const groups = [];
+	const groupsBySide = /* @__PURE__ */ new Map();
+	const modelOrderPromotion = input.settings["layering.nodePromotion.strategy"] === "MODEL_ORDER_LEFT_TO_RIGHT";
+	const directionReversed = input.direction === "left" || input.direction === "up";
+	const endpointSide = (nodeId, portName) => {
+		const node = nodeById.get(nodeId);
+		const port = node?.ports?.find((candidate) => candidate.name === portName);
+		const constraints = node ? nodeSettingsOf(node)?.portConstraints : void 0;
+		if (!node || !port || constraints !== "FIXED_SIDE" && constraints !== "FIXED_ORDER" && constraints !== "FIXED_RATIO" && constraints !== "FIXED_POS") return;
+		const configured = portSettingsOf(port, node)?.["port.side"];
+		return configured === "WEST" || configured === "NORTH" ? "before" : configured === "EAST" || configured === "SOUTH" ? "after" : void 0;
+	};
+	const fixedImplicitSide = (nodeId, portName, source) => {
+		const node = nodeById.get(nodeId);
+		const constraints = node && nodeSettingsOf(node)?.portConstraints;
+		if (portName !== void 0 || ![
+			"FIXED_SIDE",
+			"FIXED_ORDER",
+			"FIXED_RATIO",
+			"FIXED_POS"
+		].includes(String(constraints))) return void 0;
+		return source !== directionReversed ? "after" : "before";
+	};
+	const addEntry = (nodeId, side, entry) => {
+		let byNode = groupsBySide.get(side);
+		if (!byNode) groupsBySide.set(side, byNode = /* @__PURE__ */ new Map());
+		const group = byNode.get(nodeId);
+		if (group) group.entries.push(entry);
+		else {
+			const created = {
+				nodeId,
+				side,
+				entries: [entry]
+			};
+			byNode.set(nodeId, created);
+			groups.push(created);
+		}
+	};
 	for (const edge of input.graph.edges) {
 		if (hasMovableLoopPorts(input, edge)) continue;
 		const sourceRect = placement.rectByNodeId.get(edge.sourceId);
@@ -5970,50 +6186,33 @@ function implicitEdgeEndpoints(input, placement, orientation) {
 		if (!sourceRect || !targetRect) continue;
 		const sourceFlow = horizontal$1 ? sourceRect.x : sourceRect.y;
 		const targetFlow = horizontal$1 ? targetRect.x : targetRect.y;
-		const modelOrderPromotion = input.settings["layering.nodePromotion.strategy"] === "MODEL_ORDER_LEFT_TO_RIGHT";
 		const sourceBoundary = externalPortDummyOf(nodeById.get(edge.sourceId) ?? {});
 		const targetBoundary = externalPortDummyOf(nodeById.get(edge.targetId) ?? {});
 		const forward = modelOrderPromotion || (sourceFlow === targetFlow && (sourceBoundary || targetBoundary) ? sourceBoundary ? sourceBoundary.port.side === "EAST" || sourceBoundary.port.side === "SOUTH" : targetBoundary.port.side === "WEST" || targetBoundary.port.side === "NORTH" : sourceFlow <= targetFlow);
 		const feedback = input.settings.feedbackEdges === true && orientation?.reversedEdgeIds.has(edge.id) === true;
-		const directionReversed = input.direction === "left" || input.direction === "up";
-		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 fixedImplicitSide = (nodeId, portName, source) => {
-			const node = nodeById.get(nodeId);
-			const constraints = node && input.nodeSettings?.(node)?.portConstraints;
-			if (portName !== void 0 || ![
-				"FIXED_SIDE",
-				"FIXED_ORDER",
-				"FIXED_RATIO",
-				"FIXED_POS"
-			].includes(String(constraints))) return void 0;
-			return source !== directionReversed ? "after" : "before";
-		};
 		const sourceSide = endpointSide(edge.sourceId, edge.sourcePort) ?? fixedImplicitSide(edge.sourceId, edge.sourcePort, true) ?? (feedback ? directionReversed ? "before" : "after" : forward ? "after" : "before");
 		const targetSide = endpointSide(edge.targetId, edge.targetPort) ?? fixedImplicitSide(edge.targetId, edge.targetPort, false) ?? (feedback ? directionReversed ? "after" : "before" : forward ? "before" : "after");
-		const sourceKey = `${edge.sourceId}:${sourceSide}`;
-		const targetKey = `${edge.targetId}:${targetSide}`;
-		const sourceGroup = groups.get(sourceKey) ?? [];
-		sourceGroup.push({
+		addEntry(edge.sourceId, sourceSide, {
 			edge,
 			endpoint: "source"
 		});
-		groups.set(sourceKey, sourceGroup);
-		const targetGroup = groups.get(targetKey) ?? [];
-		targetGroup.push({
+		addEntry(edge.targetId, targetSide, {
 			edge,
 			endpoint: "target"
 		});
-		groups.set(targetKey, targetGroup);
 	}
 	const result = /* @__PURE__ */ new Map();
 	const edgeModelOrder = new Map(input.graph.edges.map((edge, index) => [edge.id, index]));
+	const orderIndexes = /* @__PURE__ */ new Map();
+	const orderIndex = (list, id) => {
+		let positions = orderIndexes.get(list);
+		if (!positions) {
+			positions = /* @__PURE__ */ new Map();
+			for (const [index, item] of list.entries()) if (!positions.has(item)) positions.set(item, index);
+			orderIndexes.set(list, positions);
+		}
+		return positions.get(id) ?? -1;
+	};
 	const placedPorts = /* @__PURE__ */ new Map();
 	const portSideCounts = /* @__PURE__ */ new Map();
 	const portSideCount = (node, side) => {
@@ -6021,22 +6220,19 @@ function implicitEdgeEndpoints(input, placement, orientation) {
 		if (!counts) {
 			counts = /* @__PURE__ */ new Map();
 			for (const port of node.ports ?? []) {
-				const portSide = input.portSettings?.(port, node)?.["port.side"];
+				const portSide = portSettingsOf(port, node)?.["port.side"];
 				counts.set(portSide, (counts.get(portSide) ?? 0) + 1);
 			}
 			portSideCounts.set(node, counts);
 		}
 		return counts.get(side) ?? 0;
 	};
-	for (const [key, entries] of groups) {
-		const split = key.lastIndexOf(":");
-		const nodeId = key.slice(0, split);
-		const side = key.slice(split + 1);
+	for (const { nodeId, side, entries } of groups) {
 		const rect = placement.rectByNodeId.get(nodeId);
 		if (!rect) continue;
 		const mergeEdges = input.settings.mergeEdges === true;
 		const node = nodeById.get(nodeId);
-		const nodeSettings = node ? input.nodeSettings?.(node) : void 0;
+		const nodeSettings = node ? nodeSettingsOf(node) : void 0;
 		const hypernode = nodeSettings?.hypernode;
 		const unzipping = (input.settings["layerUnzipping.strategy"] ?? "NONE") === "ALTERNATING";
 		const crossingStrategy = input.settings["crossingMinimization.strategy"] ?? "LAYER_SWEEP";
@@ -6055,7 +6251,7 @@ function implicitEdgeEndpoints(input, placement, orientation) {
 			const leftIncoming = left.endpoint === "target" !== (orientation?.reversedEdgeIds.has(left.edge.id) ?? false);
 			if (leftIncoming === (right.endpoint === "target" !== (orientation?.reversedEdgeIds.has(right.edge.id) ?? false))) {
 				const selected = (leftIncoming ? sweptOrder?.inputPortOrderByNodeId : sweptOrder?.outputPortOrderByNodeId)?.get(nodeId);
-				const a = selected?.indexOf(left.edge.id) ?? -1, b = selected?.indexOf(right.edge.id) ?? -1;
+				const a = selected ? orderIndex(selected, left.edge.id) : -1, b = selected ? orderIndex(selected, right.edge.id) : -1;
 				if (a >= 0 && b >= 0 && a !== b) return (leftIncoming ? -1 : 1) * (a - b);
 			}
 			if (interactiveLeftSourceOrder) {
@@ -6128,9 +6324,9 @@ function implicitEdgeEndpoints(input, placement, orientation) {
 			};
 			const portName = endpoint === "source" ? edge.sourcePort : edge.targetPort;
 			const explicitPort = node?.ports?.find((port) => port.name === portName);
-			const physicalSide = node && explicitPort ? input.portSettings?.(explicitPort, node)?.["port.side"] : void 0;
+			const physicalSide = node && explicitPort ? portSettingsOf(explicitPort, node)?.["port.side"] : void 0;
 			const singleFixedSidePort = constraints === "FIXED_SIDE" && physicalSide !== void 0 && node?.ports !== void 0 && portSideCount(node, physicalSide) === 1;
-			const authoredAnchor = node && explicitPort ? input.portSettings?.(explicitPort, node)?.["port.anchor"] : void 0;
+			const authoredAnchor = node && explicitPort ? portSettingsOf(explicitPort, node)?.["port.anchor"] : void 0;
 			if (portName !== void 0 && node && (constraints === "FIXED_POS" || constraints === "FIXED_RATIO" || constraints === "FIXED_ORDER" || singleFixedSidePort || authoredAnchor !== void 0)) point = getPortPoint(node, portName, rect, point, input.direction, input, placedPorts);
 			const pair = result.get(edge.id) ?? {
 				source: point,
@@ -6341,6 +6537,14 @@ function routeEdges(style) {
 			flowLayerByNodeId.set(interval.id, flowLayers.length - 1);
 		}
 		const bodyFlowLayers = flowLayers.map((bounds) => ({ ...bounds }));
+		const placedIdsByFlowLayer = () => {
+			const ids = flowLayers.map(() => []);
+			for (const id of placement.rectByNodeId.keys()) {
+				const layer = flowLayerByNodeId.get(id);
+				if (layer !== void 0) ids[layer].push(id);
+			}
+			return ids;
+		};
 		const labelFlowLayers = new Set([...flowLayerByNodeId].filter(([id]) => id.startsWith("__layout_dummy:label:")).map(([, layer]) => layer));
 		for (const [id, rect] of placement.rectByNodeId) {
 			const node = nodeById.get(id);
@@ -6417,10 +6621,11 @@ function routeEdges(style) {
 			labelExtraByGap[gap] = Math.max(labelExtraByGap[gap] ?? 0, extra);
 		}
 		let labelShift = 0;
+		const labelShiftIds = placedIdsByFlowLayer();
 		for (const [layerNo, bounds] of flowLayers.entries()) {
 			if (labelShift !== 0) {
-				for (const [id, rect] of placement.rectByNodeId) {
-					if (flowLayerByNodeId.get(id) !== layerNo) continue;
+				for (const id of labelShiftIds[layerNo]) {
+					const rect = placement.rectByNodeId.get(id);
 					mutableRects.set(id, horizontal$1 ? {
 						...rect,
 						x: rect.x + labelShift
@@ -6753,8 +6958,9 @@ function routeEdges(style) {
 					candidate.slot = increasing ? segment.slot : maximumSlot - segment.slot;
 					if (segment.partner !== void 0) {
 						const partner = result.segments[segment.partner];
-						candidate.secondSlot = increasing ? partner.slot : maximumSlot - segment.slot;
-						if (!increasing) candidate.slot = maximumSlot - partner.slot;
+						const [first, second] = physicalPort(candidate, "source").graphSource ? [segment, partner] : [partner, segment];
+						candidate.slot = increasing ? first.slot : maximumSlot - first.slot;
+						candidate.secondSlot = increasing ? second.slot : maximumSlot - second.slot;
 						const sourcePort = portByCandidate.get(candidate).source;
 						const offset = (increasing ? candidate.sourceCross : candidate.targetCross) - byPort.get(sourcePort).position + (runShift.get(sourcePort) ?? 0);
 						candidate.crossover = segment.outgoing[0] + offset;
@@ -6767,18 +6973,21 @@ function routeEdges(style) {
 			const leadingSlots = slotsByGap[0] ?? 0;
 			const leadingWidth = leadingSlots > 0 ? edgeNodeSpacing + (leadingSlots - 1) * edgeEdgeSpacing : 0;
 			let nextStart = (flowLayers[0]?.start ?? 0) + leadingWidth;
+			const flowLayerIds = flowLayers.map(() => []);
+			for (const [id, layer] of flowLayerByNodeId) flowLayerIds[layer].push(id);
 			const externalFlowLayers = new Set(flowLayers.flatMap((_, layer) => {
-				const ids = [...flowLayerByNodeId].filter(([, index]) => index === layer);
-				return ids.length && ids.every(([id]) => {
+				const ids = flowLayerIds[layer];
+				return ids.length && ids.every((id) => {
 					const node = nodeById.get(id);
 					const side = node && externalPortDummyOf(node)?.side;
 					return horizontal$1 ? side === "WEST" || side === "EAST" : side === "NORTH" || side === "SOUTH";
 				}) ? [layer] : [];
 			}));
+			const shiftedIds = placedIdsByFlowLayer();
 			for (const [layerNo, bounds] of flowLayers.entries()) {
 				const shift = nextStart - bounds.start;
-				for (const [id, rect] of placement.rectByNodeId) {
-					if (flowLayerByNodeId.get(id) !== layerNo) continue;
+				for (const id of shiftedIds[layerNo]) {
+					const rect = placement.rectByNodeId.get(id);
 					mutableRects.set(id, horizontal$1 ? {
 						...rect,
 						x: rect.x + shift
@@ -6992,10 +7201,11 @@ function routeEdges(style) {
 				});
 			}
 			let nextStart = flowLayers[0]?.start ?? 0;
+			const shiftedIds = placedIdsByFlowLayer();
 			for (const [layerNo, bounds] of flowLayers.entries()) {
 				const shift = nextStart - bounds.start;
-				for (const [id, rect] of placement.rectByNodeId) {
-					if (flowLayerByNodeId.get(id) !== layerNo) continue;
+				for (const id of shiftedIds[layerNo]) {
+					const rect = placement.rectByNodeId.get(id);
 					mutableRects.set(id, horizontal$1 ? {
 						...rect,
 						x: rect.x + shift
@@ -7868,7 +8078,7 @@ function normalizePlacementForPortExtents(input, placement, order, orientation)
 		let trailingBoundary = Number.NEGATIVE_INFINITY;
 		let leadingBoundary = Number.POSITIVE_INFINITY;
 		for (const [ids, trailing] of [[layer, true], [nextLayer, false]]) for (const id of ids) {
-			const node = input.graph.nodes.find((candidate) => candidate.id === id);
+			const node = findNode(input.graph.nodes, id);
 			const rect = placement.rectByNodeId.get(id);
 			if (!node || !rect) continue;
 			const bodyStart = horizontal$1 ? rect.x : rect.y;
@@ -9654,6 +9864,10 @@ function crossing(s, t) {
 	const v = h === s ? t : s;
 	return v.a.x > Math.min(h.a.x, h.b.x) + EPS && v.a.x < Math.max(h.a.x, h.b.x) - EPS && h.a.y > Math.min(v.a.y, v.b.y) + EPS && h.a.y < Math.max(v.a.y, v.b.y) - EPS;
 }
+const onBorder = (p, r) => {
+	const inX = p.x >= r.x - EPS && p.x <= r.x + r.width + EPS;
+	return p.y >= r.y - EPS && p.y <= r.y + r.height + EPS && (Math.abs(p.x - r.x) <= EPS || Math.abs(p.x - r.x - r.width) <= EPS) || inX && (Math.abs(p.y - r.y) <= EPS || Math.abs(p.y - r.y - r.height) <= EPS);
+};
 const segmentsOf = (points) => points.slice(1).flatMap((b, i) => {
 	const s = {
 		a: points[i],
@@ -9686,7 +9900,34 @@ function separateOpposingTracks(scene) {
 		if (!rects) terminalCache.set(key, rects = terminals(a.route, b.route));
 		return rects;
 	};
+	const boxes = /* @__PURE__ */ new WeakMap();
+	const boxOf = (segments) => {
+		let box = boxes.get(segments);
+		if (!box) {
+			box = [
+				Infinity,
+				Infinity,
+				-Infinity,
+				-Infinity
+			];
+			for (const { a, b } of segments) {
+				box[0] = Math.min(box[0], a.x, b.x);
+				box[1] = Math.min(box[1], a.y, b.y);
+				box[2] = Math.max(box[2], a.x, b.x);
+				box[3] = Math.max(box[3], a.y, b.y);
+			}
+			boxes.set(segments, box);
+		}
+		return box;
+	};
+	const none = {
+		opposing: 0,
+		overlap: 0,
+		crossings: 0
+	};
 	const pair = (mine, self, other) => {
+		const [ax0, ay0, ax1, ay1] = boxOf(mine), [bx0, by0, bx1, by1] = boxOf(other.measured);
+		if (ax1 < bx0 - EPS || bx1 < ax0 - EPS || ay1 < by0 - EPS || by1 < ay0 - EPS) return none;
 		const rects = terminalsOf(self, other);
 		const as = rects.length ? clip(mine, rects, true) : mine, bs = rects.length ? clip(other.measured, rects, true) : other.measured;
 		let opposing = 0, overlap = 0, crossings$1 = 0;
@@ -9899,8 +10140,8 @@ function separateOpposingTracks(scene) {
 					y: p.y
 				};
 				if (k >= 1 && k <= raw.length - 2) {
-					const before = raw[k - 1], after = raw[k + 1];
-					if (h ? !vertical(before) || !vertical(after) : !horizontal(before) || !horizontal(after)) continue;
+					const before = raw[k - 1], after$1 = raw[k + 1];
+					if (h ? !vertical(before) || !vertical(after$1) : !horizontal(before) || !horizontal(after$1)) continue;
 					for (const delta of offsets) {
 						const points = state.points.map((p, i) => i === k || i === k + 1 ? shift(p, delta) : p);
 						const next = [
@@ -9911,11 +10152,11 @@ function separateOpposingTracks(scene) {
 							a: points[i],
 							b: points[i + 1]
 						}));
-						if (!keeps(before, next[0]) || !keeps(after, next[2])) continue;
+						if (!keeps(before, next[0]) || !keeps(after$1, next[2])) continue;
 						consider(points, [
 							before,
 							segment,
-							after
+							after$1
 						], next, next[1], 0, delta);
 					}
 					continue;
@@ -9938,6 +10179,32 @@ function separateOpposingTracks(scene) {
 					a: port,
 					b: corner
 				}], [inflate(rect, TERMINAL_MARGIN)], true).reduce((sum, part) => sum + size(part), 0) : along;
+				const after = {
+					a: corner,
+					b: beyond
+				};
+				const against = (s) => states.reduce((sum, other) => other === state ? sum : other.measured.reduce((n, t) => n + (opposite(s, t) ? shared(s, t) : 0), sum), 0);
+				if (state.route.ends.length === 2 && state.route.ports?.[reversed ? 1 : 0] === void 0 && rect && onBorder(port, rect) && (h ? vertical(after) : horizontal(after))) {
+					const lo = h ? rect.y : rect.x, hi = lo + (h ? rect.height : rect.width);
+					for (const delta of offsets) {
+						const moved = shift(port, delta);
+						if ((h ? moved.y : moved.x) < lo - EPS || (h ? moved.y : moved.x) > hi + EPS) continue;
+						const next = [{
+							a: moved,
+							b: shift(corner, delta)
+						}, {
+							a: shift(corner, delta),
+							b: beyond
+						}];
+						if (!keeps(after, next[1]) || against(next[1]) > against(after) + EPS) continue;
+						const replaced = [
+							moved,
+							shift(corner, delta),
+							...path.slice(2)
+						];
+						consider(reversed ? replaced.reverse() : replaced, [segment, after], next, next[0], 0, delta);
+					}
+				}
 				for (const stub of new Set([along - clearance, spacing])) for (const delta of offsets) {
 					if (stub < 1 || along - stub < spacing) continue;
 					const q = {
@@ -9995,14 +10262,34 @@ function separateOpposingTracks(scene) {
 	* half a spacing either side of the port's centre.
 	*/
 	function splitSharedPorts(tolerant) {
-		const ports = scene.ports;
-		if (!ports?.size) return;
 		const groups = /* @__PURE__ */ new Map();
+		const implicit = /* @__PURE__ */ new Map();
 		for (const state of states) for (const end of [0, 1]) {
-			const id = state.route.ports?.[end];
-			const port = id === void 0 ? void 0 : ports.get(id);
-			if (!port || state.points.length < 2) continue;
+			if (state.points.length < 2) continue;
 			const [p, q] = end ? [...state.points].reverse() : state.points;
+			let id = state.route.ports?.[end];
+			let port = id === void 0 ? void 0 : scene.ports?.get(id);
+			const node = state.route.ends.length === 2 ? state.route.ends[end] : void 0;
+			const rect = node === void 0 ? void 0 : nodes.get(node);
+			if (id === void 0 && rect && onBorder(p, rect)) {
+				const points = implicit.get(node) ?? [];
+				implicit.set(node, points);
+				let at = points.find((o) => Math.abs(o.x - p.x) <= EPS && Math.abs(o.y - p.y) <= EPS);
+				if (!at) points.push(at = {
+					x: p.x,
+					y: p.y
+				});
+				id = `${node}\0${points.indexOf(at)}`;
+				port = {
+					node,
+					rect: {
+						...at,
+						width: 0,
+						height: 0
+					}
+				};
+			}
+			if (!port) continue;
 			const s = {
 				a: p,
 				b: q
@@ -10024,7 +10311,13 @@ function separateOpposingTracks(scene) {
 				end
 			});
 		}
-		for (const { port, normal, ends } of groups.values()) {
+		for (const group of groups.values()) {
+			const { port, normal } = group;
+			const ends = group.ends.filter(({ state, end }) => {
+				if (state.route.ports?.[end] !== void 0) return true;
+				const p = end ? state.points.at(-1) : state.points[0];
+				return Math.abs(p.x - port.rect.x) <= EPS && Math.abs(p.y - port.rect.y) <= EPS;
+			});
 			const incoming = ends.filter((e) => e.end === 1), outgoing = ends.filter((e) => e.end === 0);
 			if (!incoming.length || !outgoing.length) continue;
 			const stub = ({ state, end }) => {
@@ -10043,9 +10336,25 @@ function separateOpposingTracks(scene) {
 			const sideLo = node[lateral], sideHi = node[lateral] + (lateral === "x" ? node.width : node.height);
 			const wide = extent$2 >= spacing - EPS;
 			const half = spacing / 2;
-			const shifted = (points, end, offset) => {
+			const slid = (state, points, end, offset) => {
+				if (state.route.ports?.some((id) => id !== void 0)) return void 0;
+				if (Math.abs(points[0][across] - points[1][across]) <= EPS) return void 0;
+				const far = nodes.get(state.route.ends[1 - end] ?? "");
+				const moved = points.map((p) => ({
+					...p,
+					[lateral]: p[lateral] + offset
+				}));
+				const within = (value$1, rect) => {
+					const lo = rect[lateral];
+					return value$1 >= lo - EPS && value$1 <= lo + (lateral === "x" ? rect.width : rect.height) + EPS;
+				};
+				const value = moved[0][lateral];
+				return within(value, node) && far && within(value, far) ? moved : void 0;
+			};
+			const shifted = (state, points, end, offset) => {
 				if (Math.abs(offset) <= EPS) return points;
 				const path = end ? [...points].reverse() : [...points];
+				if (path.length === 2) return slid(state, points, end, offset);
 				if (path.length < 3) return void 0;
 				const [p, q, r] = path;
 				const along = r[lateral] - q[lateral];
@@ -10109,7 +10418,7 @@ function separateOpposingTracks(scene) {
 				const next = /* @__PURE__ */ new Map();
 				let feasible = true;
 				for (const e of ends) {
-					const points = shifted(next.get(e.state) ?? e.state.points, e.end, offsetOf(e));
+					const points = shifted(e.state, next.get(e.state) ?? e.state.points, e.end, offsetOf(e));
 					if (!points) {
 						feasible = false;
 						break;
@@ -14589,10 +14898,16 @@ function buildNeighbors(input, order) {
 			return (horizontal$1 ? port?.height : port?.width) ?? 0;
 		});
 	};
+	const loopsByNodeId = /* @__PURE__ */ new Map();
+	for (const edge of input.graph.edges) if (edge.sourceId === edge.targetId) {
+		const loops = loopsByNodeId.get(edge.sourceId);
+		if (loops) loops.push(edge);
+		else loopsByNodeId.set(edge.sourceId, [edge]);
+	}
 	const loopTerminals = (id, side) => {
 		const node = nodeById.get(id);
 		if (!node) return 0;
-		return input.graph.edges.filter((edge) => edge.sourceId === id && edge.targetId === id).flatMap((edge) => [edge.sourcePort, edge.targetPort]).filter((name) => {
+		return (loopsByNodeId.get(id) ?? []).flatMap((edge) => [edge.sourcePort, edge.targetPort]).filter((name) => {
 			const port = node.ports?.find((candidate) => candidate.name === name);
 			return port !== void 0 && input.portSettings?.(port, node)?.["port.side"] === side.toUpperCase() && usesSharedSideSlot(input, node, name);
 		}).length;
@@ -14703,8 +15018,8 @@ function alignBlocks(input, order, bal, neighbors, markedEdges) {
 			const adjacent = (bal.hdir === "LEFT" ? neighbors.right : neighbors.left).get(id) ?? [];
 			const low = Math.floor((adjacent.length + 1) / 2) - 1;
 			const high = Math.ceil((adjacent.length + 1) / 2) - 1;
-			const indices = bal.vdir === "UP" ? Array.from({ length: Math.max(0, high - low + 1) }, (_, i) => high - i) : Array.from({ length: Math.max(0, high - low + 1) }, (_, i) => low + i);
-			for (const median of indices) {
+			for (let i = 0; i < high - low + 1; i++) {
+				const median = bal.vdir === "UP" ? high - i : low + i;
 				if (bal.align.get(id) !== id) break;
 				const neighbor = adjacent[median];
 				if (neighbor === void 0) continue;
@@ -18533,11 +18848,14 @@ function* createLayeredScopePipeline(graph, options, context) {
 		settings: options.settings ?? {},
 		...options.nodeSettings === void 0 ? {} : { nodeSettings: options.nodeSettings },
 		...options.edgeSettings === void 0 ? {} : { edgeSettings: options.edgeSettings },
-		portSettings: (port, node) => ({
-			...options.portSettings?.(port, node),
-			...parallelPortIndexByKey.has(`${node.id}\0${port.name}`) ? { "port.index": parallelPortIndexByKey.get(`${node.id}\0${port.name}`) } : {},
-			...switchedSideByPort.has(`${node.id}\0${port.name}`) ? { "port.side": switchedSideByPort.get(`${node.id}\0${port.name}`) } : {}
-		})
+		portSettings: (port, node) => {
+			const key = `${node.id}\0${port.name}`;
+			return {
+				...options.portSettings?.(port, node),
+				...parallelPortIndexByKey.has(key) ? { "port.index": parallelPortIndexByKey.get(key) } : {},
+				...switchedSideByPort.has(key) ? { "port.side": switchedSideByPort.get(key) } : {}
+			};
+		}
 	};
 	const measure = (id, run) => {
 		context?.throwIfAborted();
@@ -18683,8 +19001,10 @@ function* createLayeredScopePipeline(graph, options, context) {
 	const northEdges = /* @__PURE__ */ new Set(), southEdges = /* @__PURE__ */ new Set();
 	const upper = direction === "right" || direction === "left" ? "NORTH" : "WEST";
 	const lower = direction === "right" || direction === "left" ? "SOUTH" : "EAST";
+	const endpointNodes = /* @__PURE__ */ new Map();
+	for (const node of expanded.input.graph.nodes) if (!endpointNodes.has(node.id)) endpointNodes.set(node.id, node);
 	for (const edge of expanded.input.graph.edges) for (const [id, name] of [[edge.sourceId, edge.sourcePort], [edge.targetId, edge.targetPort]]) {
-		const node = expanded.input.graph.nodes.find((n) => n.id === id), port = node?.ports?.find((p) => p.name === name);
+		const node = endpointNodes.get(id), port = node?.ports?.find((p) => p.name === name);
 		const side = node && port ? expanded.input.portSettings?.(port, node)?.["port.side"] : void 0;
 		if (side === upper) northEdges.add(id);
 		if (side === lower) southEdges.add(id);
@@ -18811,10 +19131,6 @@ function* createLayeredScopePipeline(graph, options, context) {
 			switchedSideByPort.set(`${origin.node.id}\0${origin.port.name}`, opposite$2);
 		}
 	}
-	if (expanded.input.settings.mergeEdges === true) order = {
-		...order,
-		layers: order.layers.map((layer) => [...layer.filter((id) => id.startsWith("__layout_dummy:")), ...layer.filter((id) => !id.startsWith("__layout_dummy:"))])
-	};
 	const unzippingFanIn = graph.edges.length === graph.nodes.length - 1 && graph.nodes.some((node) => graph.edges.filter((edge) => edge.targetId === node.id).length === graph.nodes.length - 1);
 	if ((options.settings?.["layerUnzipping.strategy"] ?? "NONE") === "ALTERNATING") if (unzippingFanIn) order = applyLayerUnzipping(expanded.input, order);
 	else {
@@ -19717,4 +20033,4 @@ const elkjs0111LayeredAlgorithm = {
 };
 
 //#endregion
-export { createExternalPortDummy as $, breakCyclesByStronglyConnectedNodeType as A, minimizeCrossingsWithBarycenter as B, assignLayersByDepthFirstModelOrder as C, assignLayersWithCoffmanGraham as D, assignLayersInteractively as E, breakCyclesWithModelOrderBreadthFirstSearch as F, placePorts as G, minimizeCrossingsWithModelOrder as H, breakCyclesWithModelOrderDepthFirstSearch as I, routeEdgesWithSplines as J, routeEdgesOrthogonally as K, createLayerSweepSession as L, breakCyclesGreedilyByModelOrder as M, breakCyclesInteractively as N, breakCyclesByModelOrder as O, breakCyclesWithDepthFirstSearch as P, attachExternalPortDummy as Q, getPolylineMidpoint as R, assignLayersByBreadthFirstModelOrder as S, assignLayersByLongestPathToSink as T, placeNodesInLayers as U, minimizeCrossingsWithMedian as V, placeNodesInteractively as W, minimizeHierarchyCrossings as X, JavaRandom as Y, assignLayersWithNetworkSimplex as Z, statechartHints as _, fromElkLayeredOptionId as a, elkjs0111ResultPolicy as b, elkLayeredOptionDefinitions as c, placeNodesWithBrandesKoepf as d, externalPortDummyOf as et, assignLayersWithStretchWidth as f, hint as g, separateOpposingTracks as h, layeredAlgorithm as i, breakCyclesGreedily as j, breakCyclesByStronglyConnectedConnectivity as k, placeNodesWithNetworkSimplex as l, c as m, elkjs0111LayeredAlgorithm as n, createOrthogonalHypersegments as nt, toElkLayeredOptions as o, assignLayersWithMinWidth as p, routeEdgesWithPolylines as q, getLayeredLayout as r, elkLayeredEnumValues as s, createLayeredScopePipeline as t, getCrossingUnits as tt, placeNodesWithLinearSegments as u, isPerpendicularPortRestored as v, assignLayersByLongestPath as w, setElkjs0111ResultPolicy as x, hierarchicalPortSides as y, minimizeCrossingsInteractively as z };
+export { attachExternalPortDummy as $, breakCyclesByStronglyConnectedConnectivity as A, minimizeCrossingsInteractively as B, assignLayersByBreadthFirstModelOrder as C, assignLayersInteractively as D, assignLayersByLongestPathToSink as E, breakCyclesWithDepthFirstSearch as F, placeNodesInteractively as G, minimizeCrossingsWithMedian as H, breakCyclesWithModelOrderBreadthFirstSearch as I, routeEdgesWithPolylines as J, placePorts as K, breakCyclesWithModelOrderDepthFirstSearch as L, breakCyclesGreedily as M, breakCyclesGreedilyByModelOrder as N, assignLayersWithCoffmanGraham as O, breakCyclesInteractively as P, assignLayersWithNetworkSimplex as Q, createLayerSweepSession as R, CROSSING_MODEL as S, assignLayersByLongestPath as T, minimizeCrossingsWithModelOrder as U, minimizeCrossingsWithBarycenter as V, placeNodesInLayers as W, JavaRandom as X, routeEdgesWithSplines as Y, minimizeHierarchyCrossings as Z, statechartHints as _, fromElkLayeredOptionId as a, elkjs0111ResultPolicy as b, elkLayeredOptionDefinitions as c, placeNodesWithBrandesKoepf as d, createExternalPortDummy as et, assignLayersWithStretchWidth as f, hint as g, separateOpposingTracks as h, layeredAlgorithm as i, breakCyclesByStronglyConnectedNodeType as j, breakCyclesByModelOrder as k, placeNodesWithNetworkSimplex as l, c as m, elkjs0111LayeredAlgorithm as n, createOrthogonalHypersegments as nt, toElkLayeredOptions as o, assignLayersWithMinWidth as p, routeEdgesOrthogonally as q, getLayeredLayout as r, elkLayeredEnumValues as s, createLayeredScopePipeline as t, externalPortDummyOf as tt, placeNodesWithLinearSegments as u, isPerpendicularPortRestored as v, assignLayersByDepthFirstModelOrder as w, setElkjs0111ResultPolicy as x, hierarchicalPortSides as y, getPolylineMidpoint as z };