@statelyai/layout 0.3.0 → 0.4.1

package/dist/elkjs-dMghiiWW.cjs

@@ -1,1706 +0,0 @@
-const require_routing = require('./routing-ujEP7Qh6.cjs');
-const require_layered = require('./layered-B2buJqMf.cjs');
-const require_layout_engine = require('./layout-engine-Dn1PiFwP.cjs');
-let _statelyai_graph = require("@statelyai/graph");
-
-//#region src/elkjs/statechart.ts
-function option(node, suffix) {
-	const settings = {
-		...node.properties,
-		...node.layoutOptions
-	};
-	return settings[suffix] ?? settings[`elk.${suffix}`] ?? settings[`org.eclipse.elk.${suffix}`];
-}
-const endpoint$1 = (edge, source) => source ? edge.sources?.[0] ?? edge.source : edge.targets?.[0] ?? edge.target;
-/** Compile semantic hints into settings implemented by this package's ELK adapter. */
-function compileStatechartLayout(input, scopes) {
-	const graph = structuredClone(input);
-	const paths = Object.create(null);
-	const commonExits = Object.create(null);
-	const containers = /* @__PURE__ */ new Map();
-	const edges = [];
-	const collect = (node) => {
-		if (node.id === void 0 || containers.has(String(node.id))) throw new Error("Statechart nodes require unique IDs");
-		containers.set(String(node.id), node);
-		edges.push(...node.edges ?? []);
-		node.children?.forEach(collect);
-	};
-	collect(graph);
-	for (const [id, scope] of Object.entries(scopes)) {
-		const container = containers.get(id);
-		if (!container) throw new Error(`Unknown statechart container: ${id}`);
-		const children = container.children ?? [];
-		const ids = new Set(children.map((node) => node.id));
-		const owner = /* @__PURE__ */ new Map();
-		const own = (node, childId) => {
-			owner.set(node.id, childId);
-			node.ports?.forEach((port) => owner.set(port.id, childId));
-			node.children?.forEach((descendant) => own(descendant, childId));
-		};
-		children.forEach((child) => own(child, child.id));
-		const localEdges = edges.filter((edge) => owner.has(endpoint$1(edge, true)) && owner.has(endpoint$1(edge, false)));
-		const successors = new Map(children.map((node) => [node.id, /* @__PURE__ */ new Set()]));
-		const predecessors = new Map(children.map((node) => [node.id, /* @__PURE__ */ new Set()]));
-		for (const edge of localEdges) {
-			const source = owner.get(endpoint$1(edge, true));
-			const target = owner.get(endpoint$1(edge, false));
-			if (source === target) continue;
-			successors.get(source).add(target);
-			predecessors.get(target).add(source);
-		}
-		const exits = children.filter((node) => successors.get(node.id).size === 0 && predecessors.get(node.id).size >= 2).map((node) => node.id);
-		commonExits[id] = exits;
-		const path = [...scope.preferredPath ?? (scope.initialNodeId === void 0 ? [] : [scope.initialNodeId])];
-		if (new Set(path).size !== path.length || path.some((nodeId) => !ids.has(nodeId))) throw new Error(`Path must contain distinct direct children of ${id}`);
-		if (scope.initialNodeId !== void 0 && (!ids.has(scope.initialNodeId) || path[0] !== scope.initialNodeId)) throw new Error(`Path must start at initial child of ${id}`);
-		if (scope.preferredPath) {
-			for (let i = 1; i < path.length; i++) if (!successors.get(path[i - 1])?.has(path[i])) throw new Error(`Disconnected preferred path in ${id}`);
-		} else while (path.length) {
-			const next = [...successors.get(path.at(-1))].filter((nodeId) => !path.includes(nodeId) && !exits.includes(nodeId));
-			if (next.length !== 1) break;
-			path.push(next[0]);
-		}
-		paths[id] = path;
-		container.children = [
-			...path,
-			...children.map((node) => node.id).filter((nodeId) => !path.includes(nodeId) && !exits.includes(nodeId)),
-			...exits.filter((nodeId) => !path.includes(nodeId))
-		].map((nodeId) => children.find((node) => node.id === nodeId));
-		container.layoutOptions = {
-			...path.length > 1 && option(container, "layered.cycleBreaking.strategy") === void 0 ? { "elk.layered.cycleBreaking.strategy": "MODEL_ORDER" } : {},
-			...path.length > 1 && option(container, "layered.feedbackEdges") === void 0 ? { "elk.layered.feedbackEdges": true } : {},
-			...container.layoutOptions,
-			...scope.direction ? { direction: scope.direction } : {}
-		};
-	}
-	return {
-		graph,
-		paths,
-		commonExits
-	};
-}
-const intersects = (a, b) => a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
-const cross = (a, b, c) => (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
-/** Diagnostic objective, not a proof of geometric validity. Coordinates are container-relative. */
-function scoreStatechartLayout(graph, paths = {}) {
-	const score = {
-		invalid: 0,
-		overlaps: 0,
-		pathOrder: 0,
-		crossings: 0,
-		bends: 0,
-		routeLength: 0
-	};
-	const segments = [];
-	const boxes = [];
-	const rect = (shape, x, y) => {
-		if ([
-			shape.x,
-			shape.y,
-			shape.width,
-			shape.height
-		].some((value) => value === void 0 || !Number.isFinite(value)) || (shape.width ?? 0) < 0 || (shape.height ?? 0) < 0) score.invalid++;
-		return {
-			x: x + (shape.x ?? 0),
-			y: y + (shape.y ?? 0),
-			width: shape.width ?? 0,
-			height: shape.height ?? 0
-		};
-	};
-	const visit = (node, x, y, ancestors) => {
-		const direction = String(option(node, "direction") ?? "RIGHT").toUpperCase();
-		const horizontal = direction === "RIGHT" || direction === "LEFT";
-		const sign = direction === "LEFT" || direction === "UP" ? -1 : 1;
-		const path = paths[String(node.id)] ?? [];
-		for (let i = 1; i < path.length; i++) {
-			const a = node.children?.find((child) => child.id === path[i - 1]);
-			const b = node.children?.find((child) => child.id === path[i]);
-			if (!a || !b || sign * (horizontal ? b.x - a.x : b.y - a.y) <= 0) score.pathOrder++;
-		}
-		for (const child of node.children ?? []) {
-			if (String(option(child, "noLayout")).toLowerCase() === "true") continue;
-			const box = rect(child, x, y);
-			if ((child.x ?? 0) < 0 || (child.y ?? 0) < 0 || (child.x ?? 0) + (child.width ?? 0) > (node.width ?? Infinity) + .001 || (child.y ?? 0) + (child.height ?? 0) > (node.height ?? Infinity) + .001) score.invalid++;
-			boxes.push({
-				rect: box,
-				ancestors,
-				node: child
-			});
-			visit(child, box.x, box.y, [...ancestors, child]);
-		}
-		for (const edge of node.edges ?? []) {
-			if (String(option(edge, "noLayout")).toLowerCase() === "true") continue;
-			if (!edge.sections?.length) score.invalid++;
-			for (const label of edge.labels ?? []) {
-				if (String(option(label, "noLayout")).toLowerCase() === "true") continue;
-				boxes.push({
-					rect: rect(label, x, y),
-					ancestors
-				});
-			}
-			for (const section of edge.sections ?? []) {
-				const points = [
-					section.startPoint,
-					...section.bendPoints ?? [],
-					section.endPoint
-				];
-				score.bends += section.bendPoints?.length ?? 0;
-				for (const point of points) if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) score.invalid++;
-				for (let i = 1; i < points.length; i++) {
-					const a = {
-						x: x + points[i - 1].x,
-						y: y + points[i - 1].y
-					};
-					const b = {
-						x: x + points[i].x,
-						y: y + points[i].y
-					};
-					score.routeLength += Math.hypot(b.x - a.x, b.y - a.y);
-					segments.push({
-						a,
-						b,
-						edge
-					});
-				}
-			}
-		}
-	};
-	visit(graph, 0, 0, [graph]);
-	for (let i = 0; i < boxes.length; i++) for (let j = i + 1; j < boxes.length; j++) {
-		const a = boxes[i], b = boxes[j];
-		if (a.node && b.ancestors.includes(a.node) || b.node && a.ancestors.includes(b.node)) continue;
-		if (intersects(a.rect, b.rect)) score.overlaps++;
-	}
-	for (let i = 0; i < segments.length; i++) for (let j = i + 1; j < segments.length; j++) {
-		const a = segments[i], b = segments[j];
-		if (a.edge === b.edge) continue;
-		if (cross(a.a, a.b, b.a) * cross(a.a, a.b, b.b) < 0 && cross(b.a, b.b, a.a) * cross(b.a, b.b, a.b) < 0) score.crossings++;
-	}
-	if (!Number.isFinite(score.routeLength)) score.routeLength = Number.MAX_VALUE;
-	return score;
-}
-const objectives = [
-	"invalid",
-	"overlaps",
-	"pathOrder",
-	"crossings",
-	"bends",
-	"routeLength"
-];
-function better(a, b) {
-	for (const key of objectives) if (a[key] !== b[key]) return a[key] < b[key];
-	return false;
-}
-/** Each attempt starts from original input. No post-layout geometry edits. */
-async function layoutStatechart(input, options) {
-	const maxAttempts = options.maxAttempts ?? 3;
-	if (!Number.isInteger(maxAttempts) || maxAttempts < 1 || maxAttempts > 3) throw new RangeError("maxAttempts must be an integer from 1 to 3");
-	const plan = compileStatechartLayout(input, options.scopes);
-	const attempts = [];
-	let selected;
-	for (let attempt = 0; attempt < maxAttempts; attempt++) {
-		const candidate = structuredClone(attempt === 0 ? input : plan.graph);
-		const configure = (node) => {
-			const scope = Object.hasOwn(options.scopes, String(node.id)) ? options.scopes[String(node.id)] : void 0;
-			if (scope?.direction) node.layoutOptions = {
-				...node.layoutOptions,
-				direction: scope.direction
-			};
-			if (attempt === 2 && scope) node.layoutOptions = {
-				...node.layoutOptions,
-				"spacing.nodeNode": Math.max(40, Number(option(node, "spacing.nodeNode") ?? 20) * 1.5),
-				"layered.spacing.nodeNodeBetweenLayers": Math.max(60, Number(option(node, "layered.spacing.nodeNodeBetweenLayers") ?? 20) * 1.5)
-			};
-			if (attempt === 2 && scope) {
-				const groups = /* @__PURE__ */ new Map();
-				for (const edge of node.edges ?? []) {
-					if (!edge.labels?.length) continue;
-					const key = JSON.stringify([endpoint$1(edge, true), endpoint$1(edge, false)]);
-					const group = groups.get(key) ?? [];
-					group.push(edge);
-					groups.set(key, group);
-				}
-				for (const group of groups.values()) for (let i = 1; i < Math.min(group.length, 3); i++) {
-					const edge = group[i];
-					if (option(edge, "edgeLabels.placement") === void 0 && edge.labels.every((label) => option(label, "edgeLabels.placement") === void 0)) {
-						const placement = i === 1 ? "HEAD" : "TAIL";
-						edge.layoutOptions = {
-							...edge.layoutOptions,
-							"elk.edgeLabels.placement": placement
-						};
-						edge.labels = edge.labels.map((label) => ({
-							...label,
-							layoutOptions: {
-								...label.layoutOptions,
-								"elk.edgeLabels.placement": placement
-							}
-						}));
-					}
-				}
-			}
-			node.children?.forEach(configure);
-		};
-		configure(candidate);
-		const graph = await new ELK().layout(candidate);
-		const score = scoreStatechartLayout(graph, plan.paths);
-		attempts.push({
-			kind: attempt === 0 ? "baseline" : attempt === 1 ? "policy" : "spacing",
-			score
-		});
-		if (!selected || better(score, selected.score)) selected = {
-			graph,
-			score,
-			attempt
-		};
-	}
-	return {
-		...selected,
-		attempts,
-		paths: plan.paths,
-		commonExits: plan.commonExits
-	};
-}
-
-//#endregion
-//#region src/elkjs/routes.ts
-/** Normalize any ELK layout's section geometry, preserving ports and hyperedge junctions. */
-function getElkRoutes(graph, options = {}) {
-	const shapes = /* @__PURE__ */ new Map(), frames = /* @__PURE__ */ new Map();
-	const edges = [];
-	function visit(node, offset, inherited) {
-		const position = {
-			x: offset.x + (node.x ?? 0),
-			y: offset.y + (node.y ?? 0)
-		};
-		const routing = node.layoutOptions?.["elk.edgeRouting"] ?? node.layoutOptions?.["org.eclipse.elk.edgeRouting"] ?? inherited;
-		frames.set(node.id, position);
-		shapes.set(node.id, {
-			ref: {
-				kind: "node",
-				nodeId: node.id
-			},
-			center: {
-				x: position.x + (node.width ?? 0) / 2,
-				y: position.y + (node.height ?? 0) / 2
-			}
-		});
-		for (const port of node.ports ?? []) shapes.set(port.id, {
-			ref: {
-				kind: "node",
-				nodeId: node.id,
-				port: port.id
-			},
-			center: {
-				x: position.x + (port.x ?? 0) + (port.width ?? 0) / 2,
-				y: position.y + (port.y ?? 0) + (port.height ?? 0) / 2
-			}
-		});
-		for (const edge of node.edges ?? []) edges.push({
-			edge,
-			offset: position,
-			routing: edge.layoutOptions?.["elk.edgeRouting"] ?? edge.layoutOptions?.["org.eclipse.elk.edgeRouting"] ?? routing
-		});
-		for (const child of node.children ?? []) visit(child, position, routing);
-	}
-	visit(graph, {
-		x: 0,
-		y: 0
-	}, options.routing ?? "POLYLINE");
-	const result = /* @__PURE__ */ new Map();
-	for (const { edge, offset: inheritedOffset, routing } of edges) {
-		const offset = edge.container ? frames.get(edge.container) ?? inheritedOffset : inheritedOffset;
-		const point = (p) => ({
-			x: p.x + offset.x,
-			y: p.y + offset.y
-		});
-		const parents = /* @__PURE__ */ new Map();
-		const root = (key) => {
-			let current = key;
-			while (parents.has(current)) current = parents.get(current);
-			return current;
-		};
-		const join = (a, b) => {
-			const x = root(a), y = root(b);
-			if (x !== y) parents.set(x < y ? y : x, x < y ? x : y);
-		};
-		for (const section of edge.sections ?? []) {
-			for (const id of section.outgoingSections ?? []) join(`${section.id}:end`, `${id}:start`);
-			for (const id of section.incomingSections ?? []) join(`${id}:end`, `${section.id}:start`);
-		}
-		const sections = [];
-		let malformed = false;
-		for (const section of edge.sections ?? []) {
-			const points = [
-				section.startPoint,
-				...section.bendPoints ?? [],
-				section.endPoint
-			].map(point);
-			let path;
-			if (points.some((p) => !Number.isFinite(p.x) || !Number.isFinite(p.y))) {
-				malformed = true;
-				for (let i = 0; i < points.length; i++) if (!Number.isFinite(points[i].x) || !Number.isFinite(points[i].y)) points[i] = {
-					x: offset.x + i * 20,
-					y: offset.y
-				};
-			}
-			if (routing === "SPLINES") if ((points.length - 1) % 3 || points.length < 4) {
-				malformed = true;
-				path = require_routing.pathFromPoints([points[0], points.at(-1)]);
-			} else path = require_routing.pathFromSplinePoints(points);
-			else path = require_routing.pathFromPoints(points);
-			const fromShape = section.incomingShape ?? (!section.incomingSections?.length && edge.sources.length === 1 ? edge.sources[0] : void 0);
-			const toShape = section.outgoingShape ?? (!section.outgoingSections?.length && edge.targets.length === 1 ? edge.targets[0] : void 0);
-			sections.push({
-				id: section.id,
-				from: fromShape ? shapes.get(fromShape)?.ref ?? {
-					kind: "node",
-					nodeId: fromShape
-				} : {
-					kind: "junction",
-					id: `${edge.id}:${root(`${section.id}:start`)}`
-				},
-				to: toShape ? shapes.get(toShape)?.ref ?? {
-					kind: "node",
-					nodeId: toShape
-				} : {
-					kind: "junction",
-					id: `${edge.id}:${root(`${section.id}:end`)}`
-				},
-				path
-			});
-		}
-		if (!sections.length) {
-			malformed = true;
-			const source = shapes.get(edge.sources[0] ?? ""), origin = source?.center ?? {
-				x: 0,
-				y: 0
-			};
-			const targets = [...edge.targets, ...edge.sources.slice(1)];
-			for (const [i, id] of (targets.length ? targets : [""]).entries()) {
-				const target = shapes.get(id);
-				sections.push({
-					id: `${edge.id}:fallback:${i}`,
-					from: source?.ref ?? {
-						kind: "node",
-						nodeId: edge.sources[0] ?? ""
-					},
-					to: target?.ref ?? {
-						kind: "node",
-						nodeId: id
-					},
-					path: require_routing.pathFromPoints([origin, target?.center ?? {
-						x: origin.x + 40,
-						y: origin.y + 40
-					}])
-				});
-			}
-		}
-		result.set(edge.id, require_routing.freeze({
-			edgeId: edge.id,
-			sections,
-			status: malformed ? "fallback" : "routed",
-			diagnostics: malformed ? [{
-				code: "MISSING_GEOMETRY",
-				edgeId: edge.id,
-				message: "ELK sections contain missing or invalid geometry; rendered fallback paths"
-			}] : []
-		}));
-	}
-	return result;
-}
-
-//#endregion
-//#region src/elkjs/index.ts
-function isLayoutEdgeLabel(label) {
-	return getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true && (Boolean(label.text) || label.width !== void 0 || label.height !== void 0);
-}
-var ELK = class {
-	#options;
-	#algorithmIds;
-	constructor(options = {}) {
-		this.#options = options;
-		this.#algorithmIds = new Set([
-			"box",
-			"fixed",
-			"random",
-			"rectpacking",
-			"sporeCompaction",
-			"sporeOverlap",
-			...(options.algorithms ?? ["layered"]).filter((id) => id === "layered")
-		]);
-	}
-	async knownLayoutAlgorithms() {
-		return [...this.#algorithmIds].map((id) => ({
-			id: id === "layered" ? "org.eclipse.elk.layered" : id,
-			name: {
-				layered: "Layered",
-				box: "Box",
-				fixed: "Fixed",
-				random: "Random",
-				rectpacking: "Rectangle Packing",
-				sporeCompaction: "SPOrE Compaction",
-				sporeOverlap: "SPOrE Overlap Removal"
-			}[id],
-			category: id === "layered" ? "layered" : "other",
-			knownOptions: id === "layered" ? require_layered.elkLayeredOptionDefinitions.map((definition) => definition.elkId) : id === "box" ? [
-				"padding",
-				"spacing.nodeNode",
-				"aspectRatio",
-				"box.packingMode"
-			] : id === "random" ? [
-				"padding",
-				"spacing.nodeNode",
-				"aspectRatio",
-				"randomSeed"
-			] : ["position", "bendPoints"]
-		}));
-	}
-	async knownLayoutOptions() {
-		return [{
-			id: "org.eclipse.elk.algorithm",
-			name: "Layout Algorithm",
-			type: "STRING"
-		}, ...require_layered.elkLayeredOptionDefinitions.map((definition) => ({
-			id: definition.elkId,
-			name: definition.name,
-			type: definition.type,
-			targets: [...definition.targets]
-		}))];
-	}
-	async knownLayoutCategories() {
-		return [{
-			id: "layered",
-			name: "Layered",
-			knownLayouters: this.#algorithmIds.has("layered") ? ["layered"] : []
-		}, {
-			id: "other",
-			name: "Other",
-			knownLayouters: [
-				"box",
-				"fixed",
-				"random"
-			]
-		}];
-	}
-	terminateWorker() {}
-	layout(graph, arguments_ = {}) {
-		return this.#layout(graph, arguments_);
-	}
-	async #layout(graph, arguments_ = {}) {
-		const startedAt = performance.now();
-		if (graph === void 0 || graph === null) throw new TypeError("Missing mandatory parameter: graph");
-		if (typeof graph.id !== "string" && !(typeof graph.id === "number" && Number.isInteger(graph.id))) throw new TypeError("Graph id must be a string or integer");
-		delete graph.logging;
-		const layoutOptions = {
-			...this.#options.defaultLayoutOptions,
-			...arguments_.layoutOptions,
-			...graph.properties,
-			...graph.layoutOptions
-		};
-		getOption(layoutOptions, "debugMode");
-		getOption(layoutOptions, "interactiveLayout");
-		getOption(layoutOptions, "layered.generatePositionAndLayerIds");
-		getOption(layoutOptions, "topdown.scaleFactor");
-		getOption(layoutOptions, "contentAlignment");
-		for (const child of graph.children ?? []) {
-			const childOptions = child.layoutOptions ?? {};
-			getOption(childOptions, "layered.layering.layerId");
-			getOption(childOptions, "layered.crossingMinimization.positionId");
-			getOption(childOptions, "layered.layering.layerChoiceConstraint");
-			getOption(childOptions, "layered.crossingMinimization.positionChoiceConstraint");
-			getOption(childOptions, "layered.crossingMinimization.inLayerPredOf");
-			getOption(childOptions, "layered.crossingMinimization.inLayerSuccOf");
-			getOption(childOptions, "topdown.scaleFactor");
-			getOption(childOptions, "layered.considerModelOrder.groupModelOrder.componentGroupId");
-			for (const port of child.ports ?? []) getOption(port.layoutOptions ?? {}, "layered.considerModelOrder.groupModelOrder.componentGroupId");
-		}
-		for (const edge of graph.edges ?? []) getOption(edge.layoutOptions ?? {}, "layered.considerModelOrder.groupModelOrder.componentGroupId");
-		const requestedAlgorithm = String(getOption(layoutOptions, "algorithm") ?? "layered");
-		const algorithm = requestedAlgorithm.replace(/^(?:org\.eclipse\.)?elk\./, "");
-		if (algorithm !== "layered" && algorithm !== "box" && algorithm !== "fixed" && algorithm !== "random" && algorithm !== "rectpacking" && algorithm !== "sporeCompaction" && algorithm !== "sporeOverlap") throw new Error(`org.eclipse.elk.core.UnsupportedConfigurationException: Layout algorithm '${requestedAlgorithm}' not found`);
-		const hasHierarchy = (graph.children ?? []).some((child) => (child.children?.length ?? 0) > 0);
-		const insideSelfLoopBaseHeightByNodeId = /* @__PURE__ */ new Map();
-		const hierarchyRestorations = [];
-		const syntheticPortIds = /* @__PURE__ */ new Set();
-		const authoredPortsByCompound = /* @__PURE__ */ new Map();
-		const authoredOptionsByCompound = /* @__PURE__ */ new Map();
-		const hierarchyBoundaryCountByEdge = /* @__PURE__ */ new Map();
-		const originalHierarchyEndpoints = new Map((graph.edges ?? []).map((edge) => [edge, {
-			sourceId: String(edge.sources?.[0] ?? edge.source),
-			targetId: String(edge.targets?.[0] ?? edge.target),
-			sources: edge.sources,
-			targets: edge.targets,
-			source: edge.source,
-			target: edge.target
-		}]));
-		let hasHierarchyCrossingEdges = false;
-		const hierarchyHandling = getOption(layoutOptions, "hierarchyHandling");
-		const topdownLayout = getBooleanOption(layoutOptions, "topdownLayout") === true;
-		const separateHierarchy = hasHierarchy && hierarchyHandling !== void 0 && hierarchyHandling !== "INCLUDE_CHILDREN";
-		if (hasHierarchy && topdownLayout && hierarchyHandling === "INCLUDE_CHILDREN") throw new Error("org.eclipse.elk.core.UnsupportedConfigurationException: Topdown layout cannot be used together with hierarchy handling.");
-		if (separateHierarchy) {
-			const hasCrossHierarchyEdge = (container) => {
-				const directEndpointIds = /* @__PURE__ */ new Set();
-				for (const child of container.children ?? []) {
-					directEndpointIds.add(String(child.id));
-					for (const port of child.ports ?? []) directEndpointIds.add(String(port.id));
-				}
-				if ((container.edges ?? []).some((edge) => {
-					const sourceId = String(edge.sources?.[0] ?? edge.source);
-					const targetId = String(edge.targets?.[0] ?? edge.target);
-					return !directEndpointIds.has(sourceId) || !directEndpointIds.has(targetId);
-				})) return true;
-				return (container.children ?? []).some((child) => hasCrossHierarchyEdge(child));
-			};
-			if (hasCrossHierarchyEdge(graph)) throw new Error("org.eclipse.elk.core.UnsupportedGraphException: Hierarchical edges require INCLUDE_CHILDREN");
-			for (const child of graph.children ?? []) {
-				if ((child.children?.length ?? 0) === 0) continue;
-				await this.#layout(child, {
-					...arguments_,
-					layoutOptions: {
-						...arguments_.layoutOptions,
-						...child.layoutOptions,
-						hierarchyHandling
-					},
-					logging: false,
-					measureExecutionTime: false
-				});
-			}
-		}
-		if (hasHierarchy && topdownLayout) {
-			if (getOption(layoutOptions, "topdown.nodeType") === void 0) throw new Error(`${String(graph.id)} has not been assigned a top-down node type.`);
-			for (const child of graph.children ?? []) {
-				if ((child.children?.length ?? 0) === 0) continue;
-				const childOptions = {
-					...layoutOptions,
-					...child.layoutOptions
-				};
-				const childPadding = parsePadding(getOption(childOptions, "padding"), 12);
-				const parallelNode = getOption(childOptions, "topdown.nodeType") === "PARALLEL_NODE";
-				const width = getNumberOption(childOptions, "topdown.hierarchicalNodeWidth") ?? (parallelNode ? 150 : 0);
-				const aspectRatio = getNumberOption(childOptions, "topdown.hierarchicalNodeAspectRatio") ?? (parallelNode ? 1.414 : 1 / Math.sqrt(2));
-				child.width = Math.max(child.width ?? 0, width + childPadding.left + childPadding.right);
-				child.height = Math.max(child.height ?? 0, width / aspectRatio + childPadding.top + childPadding.bottom);
-			}
-		} else if (hasHierarchy && !separateHierarchy) {
-			getNumberOption(layoutOptions, "layered.crossingMinimization.hierarchicalSweepiness");
-			for (const child of graph.children ?? []) {
-				if ((child.children?.length ?? 0) === 0) continue;
-				const descendantById = /* @__PURE__ */ new Map();
-				const descendantOwnerByEndpointId = /* @__PURE__ */ new Map();
-				const collectDescendants = (node) => {
-					for (const descendant of node.children ?? []) {
-						descendantById.set(String(descendant.id), descendant);
-						descendantOwnerByEndpointId.set(String(descendant.id), descendant);
-						for (const port of descendant.ports ?? []) descendantOwnerByEndpointId.set(String(port.id), descendant);
-						collectDescendants(descendant);
-					}
-				};
-				collectDescendants(child);
-				const internalEdges = (graph.edges ?? []).filter((edge) => {
-					const { sourceId, targetId } = originalHierarchyEndpoints.get(edge);
-					return descendantOwnerByEndpointId.has(sourceId) && descendantOwnerByEndpointId.has(targetId);
-				});
-				const crossingEdges = (graph.edges ?? []).filter((edge) => {
-					const { sourceId, targetId } = originalHierarchyEndpoints.get(edge);
-					return descendantOwnerByEndpointId.has(sourceId) !== descendantOwnerByEndpointId.has(targetId);
-				});
-				for (const edge of crossingEdges) hierarchyBoundaryCountByEdge.set(edge, (hierarchyBoundaryCountByEdge.get(edge) ?? 0) + 1);
-				hasHierarchyCrossingEdges ||= crossingEdges.length > 0;
-				getBooleanOption(layoutOptions, "layered.mergeHierarchyEdges");
-				const proxyByKind = /* @__PURE__ */ new Map();
-				const proxyFor = (kind) => {
-					const key = kind;
-					let proxy = proxyByKind.get(key);
-					if (!proxy) {
-						proxy = {
-							id: `__native_hierarchy_${String(child.id)}_${key.replace(/[^a-zA-Z0-9]/g, "_")}`,
-							width: 0,
-							height: 0
-						};
-						proxyByKind.set(key, proxy);
-					}
-					return proxy;
-				};
-				const temporaryEdges = [
-					...child.edges ?? [],
-					...internalEdges.filter((edge) => !(child.edges ?? []).some((candidate) => String(candidate.id) === String(edge.id))),
-					...crossingEdges.map((edge) => {
-						const { sourceId, targetId } = originalHierarchyEndpoints.get(edge);
-						const sourceInside = descendantOwnerByEndpointId.has(sourceId);
-						const proxy = proxyFor(sourceInside ? "output" : "input");
-						return {
-							...edge,
-							id: `__native_hierarchy_edge_${String(child.id)}_${String(edge.id)}`,
-							sources: [sourceInside ? sourceId : proxy.id],
-							targets: [sourceInside ? proxy.id : targetId],
-							source: void 0,
-							target: void 0,
-							sections: void 0
-						};
-					})
-				];
-				const temporaryChild = {
-					...child,
-					children: [...child.children ?? [], ...proxyByKind.values()],
-					edges: temporaryEdges
-				};
-				await this.#layout(temporaryChild, {
-					...arguments_,
-					layoutOptions: {
-						...arguments_.layoutOptions,
-						hierarchyHandling: "INCLUDE_CHILDREN"
-					},
-					logging: false,
-					measureExecutionTime: false
-				});
-				const childPadding = parsePadding(getOption({
-					...layoutOptions,
-					...child.layoutOptions
-				}, "padding"), 12);
-				if (proxyByKind.has("input")) {
-					const direction = getDirection(layoutOptions);
-					const horizontal = direction === "right" || direction === "left";
-					if (direction === "right" || direction === "down") {
-						const minimumFlow = Math.min(...(child.children ?? []).map((node) => horizontal ? node.x ?? 0 : node.y ?? 0));
-						const delta = (horizontal ? childPadding.left : childPadding.top) - minimumFlow;
-						for (const node of child.children ?? []) if (horizontal) node.x = (node.x ?? 0) + delta;
-						else node.y = (node.y ?? 0) + delta;
-						for (const edge of temporaryEdges) for (const section of edge.sections ?? []) for (const point of [
-							section.startPoint,
-							...section.bendPoints ?? [],
-							section.endPoint
-						]) if (horizontal) point.x += delta;
-						else point.y += delta;
-					}
-				}
-				for (const internalEdge of internalEdges) {
-					const temporary = temporaryEdges.find((candidate) => String(candidate.id) === String(internalEdge.id));
-					if (temporary?.sections) internalEdge.sections = temporary.sections;
-				}
-				child.width = Math.max(0, ...(child.children ?? []).map((node) => (node.x ?? 0) + (node.width ?? 0))) + childPadding.right;
-				child.height = Math.max(0, ...(child.children ?? []).map((node) => (node.y ?? 0) + (node.height ?? 0))) + childPadding.bottom;
-				const relativeRect = (id) => {
-					const owner = descendantOwnerByEndpointId.get(id);
-					if (!owner) return void 0;
-					const path = [];
-					const visit = (parent) => {
-						for (const candidate of parent.children ?? []) {
-							path.push(candidate);
-							if (candidate === owner || visit(candidate)) return true;
-							path.pop();
-						}
-						return false;
-					};
-					if (!visit(child)) return void 0;
-					const port = owner.ports?.find((candidate) => String(candidate.id) === id);
-					const ownerX = path.reduce((sum, node) => sum + (node.x ?? 0), 0);
-					const ownerY = path.reduce((sum, node) => sum + (node.y ?? 0), 0);
-					if (port) return {
-						x: ownerX + (port.x ?? 0) + (port.width ?? 0) / 2,
-						y: ownerY + (port.y ?? 0) + (port.height ?? 0) / 2,
-						width: 0,
-						height: 0
-					};
-					return {
-						x: ownerX,
-						y: ownerY,
-						width: path.at(-1)?.width ?? 0,
-						height: path.at(-1)?.height ?? 0
-					};
-				};
-				authoredPortsByCompound.set(child, child.ports);
-				authoredOptionsByCompound.set(child, child.layoutOptions);
-				const ports = [...child.ports ?? []];
-				for (const edge of crossingEdges) {
-					const original = originalHierarchyEndpoints.get(edge);
-					const { sourceId, targetId } = original;
-					const sourceInside = descendantOwnerByEndpointId.has(sourceId);
-					const rect = relativeRect(sourceInside ? sourceId : targetId);
-					if (!rect) continue;
-					const portId = `__native_hierarchy_port_${String(child.id)}_${String(edge.id)}`;
-					syntheticPortIds.add(portId);
-					const direction = getDirection(layoutOptions);
-					const useFarSide = sourceInside === (direction === "right" || direction === "down");
-					ports.push({
-						id: portId,
-						width: 0,
-						height: 0,
-						x: direction === "right" || direction === "left" ? (rect.x ?? 0) + (useFarSide ? rect.width ?? 0 : 0) : (rect.x ?? 0) + (rect.width ?? 0) / 2,
-						y: direction === "down" || direction === "up" ? (rect.y ?? 0) + (useFarSide ? rect.height ?? 0 : 0) : (rect.y ?? 0) + (rect.height ?? 0) / 2
-					});
-					if (!hierarchyRestorations.some((restoration) => restoration.edge === edge)) hierarchyRestorations.push({
-						edge,
-						...original
-					});
-					if (sourceInside) edge.sources = [portId];
-					else edge.targets = [portId];
-					edge.source = void 0;
-					edge.target = void 0;
-				}
-				child.ports = ports;
-				child.layoutOptions = {
-					...child.layoutOptions,
-					"elk.portConstraints": "FIXED_POS"
-				};
-				const insideLoopCount = (graph.edges ?? []).filter((edge) => isInsideSelfLoop(graph, edge, String(child.id))).length;
-				if (insideLoopCount > 0) {
-					const baseHeight = child.height ?? 0;
-					insideSelfLoopBaseHeightByNodeId.set(String(child.id), baseHeight);
-					child.height = baseHeight + insideLoopCount * 11;
-				}
-			}
-		}
-		applyNodeMicroLayout(graph, layoutOptions);
-		const graph_ = toGraph(graph, layoutOptions);
-		const layerConstraintByNodeId = new Map((graph.children ?? []).map((node) => [String(node.id), String(getOption(node.layoutOptions ?? {}, "layered.layering.layerConstraint") ?? getOption(node.layoutOptions ?? {}, "layerConstraint") ?? "NONE")]));
-		if (algorithm === "layered" && graph_.edges.some((edge) => {
-			if (edge.sourceId === edge.targetId) return false;
-			const sourceConstraint = layerConstraintByNodeId.get(edge.sourceId);
-			const targetConstraint = layerConstraintByNodeId.get(edge.targetId);
-			return (sourceConstraint === "FIRST" || sourceConstraint === "FIRST_SEPARATE") && (targetConstraint === "FIRST" || targetConstraint === "FIRST_SEPARATE");
-		})) throw new Error("org.eclipse.elk.core.UnsupportedConfigurationException: Layer constraints conflict");
-		const padding = parsePadding(getOption(layoutOptions, "padding"), algorithm === "layered" ? 12 : 0);
-		const laidOut = await (algorithm === "sporeCompaction" ? require_layout_engine.executeElkjs0111Layout({
-			algorithm: "sporeCompaction",
-			graph: graph_,
-			options: {
-				padding,
-				spacing: getNumberOption(layoutOptions, "spacing.nodeNode")
-			}
-		}) : algorithm === "sporeOverlap" ? require_layout_engine.executeElkjs0111Layout({
-			algorithm: "sporeOverlap",
-			graph: graph_,
-			options: {
-				padding,
-				spacing: getNumberOption(layoutOptions, "spacing.nodeNode")
-			}
-		}) : algorithm === "rectpacking" ? require_layout_engine.executeElkjs0111Layout({
-			algorithm: "rectpacking",
-			graph: graph_,
-			options: {
-				padding: getOption(layoutOptions, "padding") === void 0 ? 15 : padding,
-				spacing: getNumberOption(layoutOptions, "spacing.nodeNode") ?? 15
-			}
-		}) : algorithm === "random" ? require_layout_engine.executeElkjs0111Layout({
-			algorithm: "random",
-			graph: graph_,
-			options: {
-				padding: getOption(layoutOptions, "padding") === void 0 ? 15 : padding,
-				spacing: getNumberOption(layoutOptions, "spacing.nodeNode"),
-				aspectRatio: getNumberOption(layoutOptions, "aspectRatio"),
-				seed: getNumberOption(layoutOptions, "randomSeed")
-			}
-		}) : algorithm === "box" ? require_layout_engine.executeElkjs0111Layout({
-			algorithm: "box",
-			graph: graph_,
-			options: {
-				padding: getOption(layoutOptions, "padding") === void 0 ? 15 : padding,
-				spacing: getNumberOption(layoutOptions, "spacing.nodeNode"),
-				aspectRatio: getNumberOption(layoutOptions, "aspectRatio"),
-				interactive: getBooleanOption(layoutOptions, "interactive"),
-				expandNodes: getBooleanOption(layoutOptions, "expandNodes"),
-				priority: (node) => {
-					const child = graph.children?.find((candidate) => String(candidate.id) === node.id);
-					return getNumberOption(child?.layoutOptions ?? {}, "priority");
-				}
-			}
-		}) : algorithm === "fixed" ? require_layout_engine.executeElkjs0111Layout({
-			algorithm: "fixed",
-			graph: graph_,
-			options: { direction: getDirection(layoutOptions) }
-		}) : require_layout_engine.executeElkjs0111Layout({
-			algorithm: "layered",
-			graph: graph_,
-			options: {
-				direction: getDirection(layoutOptions),
-				spacing: {
-					node: getNumberOption(layoutOptions, "spacing.nodeNode") ?? getNumberOption(layoutOptions, "layered.spacing.baseValue"),
-					layer: (getNumberOption(layoutOptions, "layered.spacing.nodeNodeBetweenLayers") ?? getNumberOption(layoutOptions, "layered.spacing.baseValue") ?? 20) + (hasHierarchyCrossingEdges ? 5 * Math.max(...hierarchyBoundaryCountByEdge.values()) : 0)
-				},
-				padding,
-				constraints: { layer: () => void 0 },
-				settings: {
-					...getLayeredSettings(layoutOptions),
-					...hierarchyHandling === "INCLUDE_CHILDREN" && getOption(layoutOptions, "layered.crossingMinimization.greedySwitchHierarchical.type") !== void 0 ? { "crossingMinimization.greedySwitch.type": String(getOption(layoutOptions, "layered.crossingMinimization.greedySwitchHierarchical.type")) } : {}
-				},
-				nodeSettings: (node) => {
-					const child = graph.children?.find((candidate) => String(candidate.id) === node.id);
-					return getElementLayeredSettings(child?.layoutOptions ?? {});
-				},
-				edgeSettings: (edge) => {
-					const elkEdge = graph.edges?.find((candidate) => String(candidate.id) === edge.id);
-					return {
-						...getElementLayeredSettings(elkEdge?.layoutOptions ?? {}),
-						...getElementLayeredSettings(elkEdge?.labels?.[0]?.layoutOptions ?? {})
-					};
-				},
-				portSettings: (port, node) => {
-					const elkPort = (graph.children?.find((candidate) => String(candidate.id) === node.id))?.ports?.find((candidate) => String(candidate.id) === port.name);
-					return {
-						...getElementLayeredSettings(elkPort?.layoutOptions ?? {}),
-						"port.labelWidth": Math.max(0, ...(elkPort?.labels ?? []).map((label) => label.width ?? 0)),
-						"port.labelHeight": Math.max(0, ...(elkPort?.labels ?? []).map((label) => label.height ?? 0))
-					};
-				}
-			}
-		}));
-		if (hierarchyRestorations.length > 0) {
-			const direction = getDirection(layoutOptions);
-			const horizontal = direction === "right" || direction === "left";
-			const cross$1 = (point) => horizontal ? point.y : point.x;
-			const nodeSpacing = getNumberOption(layoutOptions, "spacing.nodeNode") ?? 20;
-			const shiftsByOutsideId = /* @__PURE__ */ new Map();
-			for (const restoration of hierarchyRestorations) {
-				const route = laidOut.edges.find((edge) => edge.id === String(restoration.edge.id))?.points;
-				if (!route || route.length < 2) continue;
-				const originalSourceId = String(restoration.sources?.[0] ?? restoration.source);
-				const originalTargetId = String(restoration.targets?.[0] ?? restoration.target);
-				const sourceInside = !laidOut.nodes.some((node) => node.id === originalSourceId);
-				const outsideId = sourceInside ? originalTargetId : originalSourceId;
-				const delta = sourceInside ? cross$1(route[0]) - cross$1(route.at(-1)) : cross$1(route.at(-1)) - cross$1(route[0]);
-				const candidates = shiftsByOutsideId.get(outsideId) ?? [];
-				candidates.push(delta);
-				shiftsByOutsideId.set(outsideId, candidates);
-			}
-			for (const [outsideId, candidates] of shiftsByOutsideId) {
-				const delta = [...candidates].sort((left, right) => Math.abs(left) - Math.abs(right))[0];
-				const node = laidOut.nodes.find((candidate) => candidate.id === outsideId);
-				if (!node || Math.abs(delta) < 1e-9 || Math.abs(delta) > nodeSpacing) continue;
-				if (horizontal) node.y = (node.y ?? 0) + delta;
-				else node.x = (node.x ?? 0) + delta;
-				for (const edge of laidOut.edges) {
-					const points = edge.points;
-					if (!points || points.length === 0) continue;
-					if (edge.sourceId === outsideId) if (horizontal) points[0].y += delta;
-					else points[0].x += delta;
-					if (edge.targetId === outsideId) if (horizontal) points.at(-1).y += delta;
-					else points.at(-1).x += delta;
-				}
-			}
-			const modelOrder = new Map((graph.children ?? []).map((node, index) => [String(node.id), index]));
-			const flowLayers = /* @__PURE__ */ new Map();
-			for (const node of laidOut.nodes) {
-				const flow = horizontal ? node.x ?? 0 : node.y ?? 0;
-				const layer = flowLayers.get(flow) ?? [];
-				layer.push(node);
-				flowLayers.set(flow, layer);
-			}
-			for (const layer of flowLayers.values()) {
-				layer.sort((left, right) => (modelOrder.get(left.id) ?? Number.MAX_SAFE_INTEGER) - (modelOrder.get(right.id) ?? Number.MAX_SAFE_INTEGER));
-				let crossEnd = Number.NEGATIVE_INFINITY;
-				for (const node of layer) {
-					const authoredCross = horizontal ? node.y ?? 0 : node.x ?? 0;
-					const compactedCross = Math.max(authoredCross, crossEnd === Number.NEGATIVE_INFINITY ? authoredCross : crossEnd + nodeSpacing);
-					const delta = compactedCross - authoredCross;
-					if (horizontal) node.y = compactedCross;
-					else node.x = compactedCross;
-					if (Math.abs(delta) > 1e-9) for (const edge of laidOut.edges) {
-						const points = edge.points;
-						if (!points || points.length === 0) continue;
-						if (edge.sourceId === node.id) if (horizontal) points[0].y += delta;
-						else points[0].x += delta;
-						if (edge.targetId === node.id) if (horizontal) points.at(-1).y += delta;
-						else points.at(-1).x += delta;
-					}
-					crossEnd = compactedCross + (horizontal ? node.height : node.width);
-				}
-			}
-			const edgeNodeSpacing = getNumberOption(layoutOptions, "spacing.edgeNodeBetweenLayers") ?? 10;
-			for (const restoration of hierarchyRestorations) {
-				const nativeEdge = laidOut.edges.find((edge) => edge.id === String(restoration.edge.id));
-				const route = nativeEdge?.points;
-				if (!route || route.length < 2) continue;
-				const start = route[0];
-				const end = route.at(-1);
-				if (nativeEdge.sourceId === nativeEdge.targetId) continue;
-				if (Math.abs(cross$1(start) - cross$1(end)) < 1e-9) {
-					route.splice(1, route.length - 2);
-					continue;
-				}
-				const originalSourceId = String(restoration.sources?.[0] ?? restoration.source);
-				const sourceInside = !laidOut.nodes.some((node) => node.id === originalSourceId);
-				const flowForward = direction === "right" || direction === "down";
-				const track = sourceInside ? (horizontal ? end.x : end.y) - (flowForward ? edgeNodeSpacing : -edgeNodeSpacing) : (horizontal ? start.x : start.y) + (flowForward ? edgeNodeSpacing : -edgeNodeSpacing);
-				route.splice(1, route.length - 2, horizontal ? {
-					x: track,
-					y: start.y
-				} : {
-					x: start.x,
-					y: track
-				}, horizontal ? {
-					x: track,
-					y: end.y
-				} : {
-					x: end.x,
-					y: track
-				});
-			}
-		}
-		const resultPolicy = laidOut[require_layout_engine.elkjs0111ResultPolicy];
-		applyLayout(graph, laidOut, padding, layoutOptions, resultPolicy);
-		if (resultPolicy?.providerBounds) {
-			graph.width = resultPolicy.providerBounds.width;
-			graph.height = resultPolicy.providerBounds.height;
-		}
-		for (const restoration of hierarchyRestorations) {
-			restoration.edge.sources = restoration.sources;
-			restoration.edge.targets = restoration.targets;
-			restoration.edge.source = restoration.source;
-			restoration.edge.target = restoration.target;
-			for (const section of restoration.edge.sections ?? []) {
-				if (section.incomingShape != null && syntheticPortIds.has(String(section.incomingShape))) section.incomingShape = restoration.sources?.[0] ?? restoration.source;
-				if (section.outgoingShape != null && syntheticPortIds.has(String(section.outgoingShape))) section.outgoingShape = restoration.targets?.[0] ?? restoration.target;
-			}
-		}
-		for (const [compound, ports] of authoredPortsByCompound) compound.ports = ports;
-		for (const [compound, options_] of authoredOptionsByCompound) compound.layoutOptions = options_;
-		if (hasHierarchy && topdownLayout) for (const child of graph.children ?? []) {
-			if ((child.children?.length ?? 0) === 0) continue;
-			const position = {
-				x: child.x,
-				y: child.y
-			};
-			await this.#layout(child, {
-				...arguments_,
-				logging: false,
-				measureExecutionTime: false
-			});
-			child.x = position.x;
-			child.y = position.y;
-		}
-		applyInsideSelfLoops(graph, insideSelfLoopBaseHeightByNodeId);
-		if (arguments_.logging || arguments_.measureExecutionTime) graph.logging = {
-			name: "Native TypeScript layout",
-			children: [{ name: String(algorithm) }],
-			...arguments_.measureExecutionTime ? { executionTime: (performance.now() - startedAt) / 1e3 } : {}
-		};
-		return graph;
-	}
-};
-function parsePadding(value, fallback = 0) {
-	if (typeof value === "number") return {
-		top: value,
-		right: value,
-		bottom: value,
-		left: value
-	};
-	if (typeof value !== "string") return {
-		top: fallback,
-		right: fallback,
-		bottom: fallback,
-		left: fallback
-	};
-	const padding = {
-		top: 0,
-		right: 0,
-		bottom: 0,
-		left: 0
-	};
-	for (const match of value.matchAll(/(top|right|bottom|left)\s*=\s*(-?\d+(?:\.\d+)?)/g)) {
-		const side = match[1];
-		padding[side] = Number(match[2]);
-	}
-	return padding;
-}
-function parseVector(value) {
-	if (typeof value === "object" && value !== null && "x" in value && "y" in value) return {
-		x: Number(value.x),
-		y: Number(value.y)
-	};
-	if (typeof value !== "string") return void 0;
-	const match = value.match(/^\s*\(\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\)\s*$/);
-	return match ? {
-		x: Number(match[1]),
-		y: Number(match[2])
-	} : void 0;
-}
-function applyNodeMicroLayout(graph, globalOptions) {
-	const labelPadding = parsePadding(getOption(globalOptions, "nodeLabels.padding"), 5);
-	for (const node of graph.children ?? []) {
-		const constraints = String(getOption(node.layoutOptions ?? {}, "nodeSize.constraints") ?? "");
-		if (!constraints) continue;
-		const configuredSizeOptions = getOption(node.layoutOptions ?? {}, "nodeSize.options");
-		const sizeOptions = new Set(configuredSizeOptions === void 0 ? ["DEFAULT_MINIMUM_SIZE"] : String(configuredSizeOptions).split(/[\s,;]+/).filter(Boolean));
-		const effectivelyFixedPortLabelSize = constraints.includes("PORT_LABELS") && !constraints.includes("NODE_LABELS") && !constraints.includes("MINIMUM_SIZE");
-		const preserveComputedCompoundSize = (node.children?.length ?? 0) > 0;
-		let width = effectivelyFixedPortLabelSize || preserveComputedCompoundSize ? node.width ?? 0 : 0;
-		let height = effectivelyFixedPortLabelSize || preserveComputedCompoundSize ? node.height ?? 0 : 0;
-		let insideHorizontalInset = 0;
-		let insideVerticalInset = 0;
-		const insideLabelCells = /* @__PURE__ */ new Map();
-		if (constraints.includes("PORTS")) {
-			const spacing = getNumberOption(globalOptions, "spacing.portPort") ?? 10;
-			const sideCounts = {
-				NORTH: 0,
-				EAST: 0,
-				SOUTH: 0,
-				WEST: 0
-			};
-			for (const port of node.ports ?? []) {
-				const side = String(getOption(port.layoutOptions ?? {}, "port.side") ?? "EAST");
-				if (side in sideCounts) sideCounts[side]++;
-			}
-			const nodeId = String(node.id);
-			for (const edge of graph.edges ?? []) {
-				const source = String(edge.sources?.[0] ?? edge.source);
-				const target = String(edge.targets?.[0] ?? edge.target);
-				if (source === nodeId) sideCounts.EAST++;
-				if (target === nodeId) sideCounts.WEST++;
-			}
-			width = Math.max(width, (Math.max(sideCounts.NORTH, sideCounts.SOUTH) + 1) * spacing);
-			height = Math.max(height, (Math.max(sideCounts.EAST, sideCounts.WEST) + 1) * spacing);
-			if (!preserveComputedCompoundSize && sideCounts.NORTH === 0 && sideCounts.SOUTH === 0) width = 0;
-			if (!preserveComputedCompoundSize && sideCounts.EAST === 0 && sideCounts.WEST === 0) height = 0;
-		}
-		if (constraints.includes("NODE_LABELS")) {
-			for (const label of node.labels ?? []) {
-				if (!label.text) continue;
-				const placement = String(getOption({
-					...globalOptions,
-					...node.layoutOptions,
-					...label.layoutOptions
-				}, "nodeLabels.placement") ?? "");
-				if (!placement) continue;
-				const labelWidth = label.width ?? 0;
-				const labelHeight = label.height ?? 0;
-				if (placement.includes("OUTSIDE")) {
-					if (!sizeOptions.has("OUTSIDE_NODE_LABELS_OVERHANG")) width = Math.max(width, labelWidth);
-				} else {
-					width = Math.max(width, labelWidth + labelPadding.left + labelPadding.right);
-					const verticalInset = labelHeight * (placement.includes("V_CENTER") ? 1 : 2) + labelPadding.top + labelPadding.bottom;
-					height = Math.max(height, verticalInset);
-					insideHorizontalInset = Math.max(insideHorizontalInset, labelPadding.left + labelPadding.right);
-					insideVerticalInset = Math.max(insideVerticalInset, verticalInset);
-					const key = `${placement.includes("V_CENTER") ? "center" : placement.includes("V_BOTTOM") ? "bottom" : "top"}:${placement.includes("H_CENTER") ? "center" : placement.includes("H_RIGHT") ? "right" : "left"}`;
-					const cell = insideLabelCells.get(key) ?? {
-						width: 0,
-						height: 0
-					};
-					cell.width = Math.max(cell.width, labelWidth);
-					cell.height += labelHeight;
-					insideLabelCells.set(key, cell);
-				}
-			}
-			if (insideLabelCells.size > 0) {
-				const rows = [
-					"top",
-					"center",
-					"bottom"
-				];
-				const columns = [
-					"left",
-					"center",
-					"right"
-				];
-				const cellWidth = (row, column) => insideLabelCells.get(`${row}:${column}`)?.width ?? 0;
-				const forceTabular = sizeOptions.has("FORCE_TABULAR_NODE_LABELS");
-				const asymmetrical = sizeOptions.has("ASYMMETRICAL");
-				const globalColumns = columns.map((column) => Math.max(...rows.map((row) => cellWidth(row, column))));
-				const labelGridWidth = forceTabular ? globalColumns.reduce((sum, value) => sum + value, 0) : Math.max(...rows.map((row) => {
-					const left = cellWidth(row, "left");
-					const center = cellWidth(row, "center");
-					const right = cellWidth(row, "right");
-					return asymmetrical ? left + center + right : 2 * Math.max(left, right) + center;
-				}));
-				const labelGridHeight = rows.reduce((sum, row) => sum + Math.max(...columns.map((column) => insideLabelCells.get(`${row}:${column}`)?.height ?? 0)), 0);
-				width = Math.max(width, labelGridWidth + labelPadding.left + labelPadding.right);
-				height = Math.max(height, labelGridHeight + labelPadding.top + labelPadding.bottom);
-			}
-		}
-		if (constraints.includes("MINIMUM_SIZE")) {
-			const configuredMinimum = parseVector(getOption(node.layoutOptions ?? {}, "nodeSize.minimum"));
-			const minimum = {
-				x: configuredMinimum?.x && configuredMinimum.x > 0 ? configuredMinimum.x : sizeOptions.has("DEFAULT_MINIMUM_SIZE") ? 20 : 0,
-				y: configuredMinimum?.y && configuredMinimum.y > 0 ? configuredMinimum.y : sizeOptions.has("DEFAULT_MINIMUM_SIZE") ? 20 : 0
-			};
-			if (sizeOptions.has("MINIMUM_SIZE_ACCOUNTS_FOR_PADDING")) {
-				width = Math.max(width, minimum.x + insideHorizontalInset);
-				height = Math.max(height, minimum.y + insideVerticalInset);
-			} else {
-				width = Math.max(width, minimum.x);
-				height = Math.max(height, minimum.y);
-			}
-		}
-		sizeOptions.has("COMPUTE_PADDING");
-		node.width = width;
-		node.height = height;
-	}
-}
-function getOption(options, suffix) {
-	const exactKeys = [
-		suffix,
-		`elk.${suffix}`,
-		`org.eclipse.elk.${suffix}`
-	];
-	for (const key of exactKeys) if (options[key] !== void 0) return options[key];
-}
-const ergonomicallyMappedLayeredSettings = new Set([
-	"direction",
-	"padding",
-	"spacing.node",
-	"spacing.layer"
-]);
-function coerceLayeredOptionValue(value, type) {
-	if (type === "BOOLEAN") {
-		if (typeof value === "boolean") return value;
-		if (typeof value === "string") return value.toLowerCase() === "true";
-	}
-	if (type === "DOUBLE" || type === "INT") {
-		if (typeof value === "number") return value;
-		if (typeof value === "string" && value.trim() !== "") return Number(value);
-	}
-	return value;
-}
-function parseIndividualSpacing(value) {
-	if (typeof value === "object" && value !== null) return value;
-	if (typeof value !== "string") return value;
-	const result = {};
-	for (const entry of value.split(/;,;|;/)) {
-		const match = entry.match(/^\s*(?:org\.eclipse\.elk\.)?(?:layered\.)?([^:]+)\s*:\s*(-?\d+(?:\.\d+)?)\s*$/);
-		if (!match) continue;
-		const sourceName = match[1];
-		const definition = require_layered.elkLayeredOptionDefinitions.find((candidate) => {
-			const suffix = candidate.elkId.replace(/^org\.eclipse\.elk\./, "");
-			return candidate.name === sourceName || suffix === sourceName;
-		});
-		if (definition) result[definition.name] = Number(match[2]);
-	}
-	return result;
-}
-function parseMargin(value) {
-	if (typeof value === "object" && value !== null) return value;
-	if (typeof value !== "string") return value;
-	return parsePadding(value, 0);
-}
-function getElementLayeredSettings(options) {
-	const settings = {};
-	for (const definition of require_layered.elkLayeredOptionDefinitions) {
-		const suffix = definition.elkId.replace(/^org\.eclipse\.elk\./, "");
-		const value = [
-			definition.name,
-			suffix,
-			`elk.${suffix}`,
-			definition.elkId
-		].map((key) => options[key]).find((candidate) => candidate !== void 0);
-		if (value === void 0) continue;
-		const vectorMatch = definition.name === "port.anchor" && typeof value === "string" ? value.match(/^\s*\(\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\)\s*$/) : void 0;
-		settings[definition.name] = vectorMatch ? {
-			x: Number(vectorMatch[1]),
-			y: Number(vectorMatch[2])
-		} : definition.name === "spacing.individual" ? parseIndividualSpacing(value) : definition.name === "spacing.portsSurrounding" ? parseMargin(value) : coerceLayeredOptionValue(value, definition.type);
-	}
-	return settings;
-}
-function getLayeredSettings(options) {
-	const settings = getElementLayeredSettings(options);
-	const baseValue = settings["spacing.baseValue"];
-	if (baseValue !== void 0) for (const [name, defaultValue] of [
-		["spacing.componentComponent", 20],
-		["spacing.edgeEdge", 10],
-		["spacing.edgeLabel", 2],
-		["spacing.edgeNode", 10],
-		["spacing.labelLabel", 0],
-		["spacing.labelNode", 5],
-		["spacing.labelPortHorizontal", 1],
-		["spacing.labelPortVertical", 1],
-		["spacing.nodeSelfLoop", 10],
-		["spacing.portPort", 10],
-		["spacing.edgeEdgeBetweenLayers", 10],
-		["spacing.edgeNodeBetweenLayers", 10]
-	]) settings[name] ??= baseValue * defaultValue / 20;
-	for (const name of ergonomicallyMappedLayeredSettings) delete settings[name];
-	return settings;
-}
-function getNumberOption(options, suffix) {
-	const value = getOption(options, suffix);
-	if (typeof value === "number" && Number.isFinite(value)) return value;
-	if (typeof value === "string" && value.trim() !== "") {
-		const parsed = Number(value);
-		if (Number.isFinite(parsed)) return parsed;
-	}
-}
-function getBooleanOption(options, suffix) {
-	const value = getOption(options, suffix);
-	if (typeof value === "boolean") return value;
-	if (typeof value === "string") {
-		if (value.toLowerCase() === "true") return true;
-		if (value.toLowerCase() === "false") return false;
-	}
-}
-function getDirection(options) {
-	const direction = String(getOption(options, "direction") ?? "RIGHT").toLowerCase();
-	return direction === "up" || direction === "left" || direction === "down" ? direction : "right";
-}
-function endpoint(value, portOwnerById) {
-	const id = String(value);
-	const ownerId = portOwnerById.get(id);
-	return ownerId === void 0 ? { nodeId: id } : {
-		nodeId: ownerId,
-		port: id
-	};
-}
-function isInsideSelfLoop(root, edge, expectedNodeId) {
-	const source = String(edge.sources?.[0] ?? edge.source);
-	if (source !== String(edge.targets?.[0] ?? edge.target) || expectedNodeId !== void 0 && source !== expectedNodeId) return false;
-	const node = root.children?.find((child) => String(child.id) === source);
-	return getBooleanOption(node?.layoutOptions ?? {}, "insideSelfLoops.activate") === true && getBooleanOption(edge.layoutOptions ?? {}, "insideSelfLoops.yo") === true;
-}
-function applyInsideSelfLoops(root, baseHeightByNodeId) {
-	const indexByNodeId = /* @__PURE__ */ new Map();
-	for (const edge of root.edges ?? []) {
-		if (!isInsideSelfLoop(root, edge)) continue;
-		const nodeId = String(edge.sources?.[0] ?? edge.source);
-		const node = root.children?.find((child) => String(child.id) === nodeId);
-		const baseHeight = baseHeightByNodeId.get(nodeId);
-		if (!node || baseHeight === void 0) continue;
-		const index = indexByNodeId.get(nodeId) ?? 0;
-		indexByNodeId.set(nodeId, index + 1);
-		const y = (node.y ?? 0) + baseHeight - 2 + index * 11;
-		edge.sections = [{
-			id: `${String(edge.id)}_s0`,
-			startPoint: {
-				x: node.x ?? 0,
-				y
-			},
-			endPoint: {
-				x: (node.x ?? 0) + (node.width ?? 0),
-				y
-			},
-			incomingShape: edge.sources?.[0] ?? edge.source,
-			outgoingShape: edge.targets?.[0] ?? edge.target
-		}];
-	}
-}
-function toGraph(root, globalOptions = {}) {
-	const children = (root.children ?? []).filter((child) => getBooleanOption(child.layoutOptions ?? {}, "noLayout") !== true);
-	const nodeIds = new Set(children.map((child) => String(child.id)));
-	const portOwnerById = /* @__PURE__ */ new Map();
-	for (const child of children) for (const port of child.ports ?? []) if (port.id !== void 0) portOwnerById.set(String(port.id), String(child.id));
-	const sourcePortIds = new Set((root.edges ?? []).flatMap((edge) => (edge.sources ?? (edge.source === void 0 ? [] : [edge.source])).map(String)));
-	const targetPortIds = new Set((root.edges ?? []).flatMap((edge) => (edge.targets ?? (edge.target === void 0 ? [] : [edge.target])).map(String)));
-	const sourcePortDegree = /* @__PURE__ */ new Map();
-	const targetPortDegree = /* @__PURE__ */ new Map();
-	const edgeModelOrderByPortId = /* @__PURE__ */ new Map();
-	for (const [edgeIndex, edge] of (root.edges ?? []).entries()) {
-		for (const source of edge.sources ?? (edge.source === void 0 ? [] : [edge.source])) {
-			const id = String(source);
-			sourcePortDegree.set(id, (sourcePortDegree.get(id) ?? 0) + 1);
-			if (portOwnerById.has(id) && !edgeModelOrderByPortId.has(id)) edgeModelOrderByPortId.set(id, edgeIndex);
-		}
-		for (const target of edge.targets ?? (edge.target === void 0 ? [] : [edge.target])) {
-			const id = String(target);
-			targetPortDegree.set(id, (targetPortDegree.get(id) ?? 0) + 1);
-			if (portOwnerById.has(id) && !edgeModelOrderByPortId.has(id)) edgeModelOrderByPortId.set(id, edgeIndex);
-		}
-	}
-	const orderedPorts = (child) => {
-		const ports = [...child.ports ?? []];
-		if (String(getOption(child.layoutOptions ?? {}, "portConstraints")) !== "FIXED_SIDE") return ports;
-		const side = (port) => String(getOption(port.layoutOptions ?? {}, "port.side"));
-		const sideOrder = [
-			"NORTH",
-			"EAST",
-			"SOUTH",
-			"WEST"
-		];
-		ports.sort((left, right) => {
-			const leftSide = side(left);
-			const rightSide = side(right);
-			const sideDifference = sideOrder.indexOf(leftSide) - sideOrder.indexOf(rightSide);
-			if (sideDifference !== 0) return sideDifference;
-			if (String(getOption(globalOptions, "layered.portSortingStrategy")) === "PORT_DEGREE") {
-				if (leftSide === "EAST") return (sourcePortDegree.get(String(right.id)) ?? 0) - (sourcePortDegree.get(String(left.id)) ?? 0);
-				if (leftSide === "WEST") return (targetPortDegree.get(String(left.id)) ?? 0) - (targetPortDegree.get(String(right.id)) ?? 0);
-			}
-			const modelOrderStrategy = String(getOption(globalOptions, "layered.considerModelOrder.strategy") ?? "NONE");
-			const usePortModelOrder = getBooleanOption(globalOptions, "layered.considerModelOrder.portModelOrder") === true;
-			if (modelOrderStrategy !== "NONE" && !usePortModelOrder) {
-				const edgeOrderDifference = (edgeModelOrderByPortId.get(String(left.id)) ?? Infinity) - (edgeModelOrderByPortId.get(String(right.id)) ?? Infinity);
-				if (edgeOrderDifference !== 0) return edgeOrderDifference;
-			}
-			return (leftSide === "WEST" ? -1 : 1) * ((child.ports?.indexOf(left) ?? 0) - (child.ports?.indexOf(right) ?? 0));
-		});
-		return ports;
-	};
-	return (0, _statelyai_graph.createGraph)({
-		id: String(root.id),
-		nodes: children.map((child) => ({
-			id: String(child.id),
-			x: child.x,
-			y: child.y,
-			...parsePosition(getOption(child.layoutOptions ?? {}, "position")),
-			width: child.width,
-			height: child.height,
-			label: child.labels?.[0]?.text,
-			ports: orderedPorts(child).filter((port) => getBooleanOption(port.layoutOptions ?? {}, "noLayout") !== true).map((port) => ({
-				name: String(port.id),
-				direction: sourcePortIds.has(String(port.id)) ? targetPortIds.has(String(port.id)) ? "inout" : "out" : targetPortIds.has(String(port.id)) ? "in" : "inout",
-				x: port.x,
-				y: port.y,
-				width: port.width,
-				height: port.height
-			}))
-		})),
-		edges: (root.edges ?? []).flatMap((edge) => {
-			if (getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true) return [];
-			if (isInsideSelfLoop(root, edge)) return [];
-			const source = endpoint(edge.sources?.[0] ?? edge.source, portOwnerById);
-			const target = endpoint(edge.targets?.[0] ?? edge.target, portOwnerById);
-			const labels = (edge.labels ?? []).filter(isLayoutEdgeLabel);
-			const labelLabelSpacing = getNumberOption(globalOptions, "spacing.labelLabel") ?? 0;
-			const labelWidth = Math.max(0, ...labels.map((label) => label.width ?? 0));
-			const labelHeight = labels.reduce((sum, label) => sum + (label.height ?? 0), 0) + Math.max(0, labels.length - 1) * labelLabelSpacing;
-			return nodeIds.has(source.nodeId) && nodeIds.has(target.nodeId) ? [{
-				id: String(edge.id),
-				sourceId: source.nodeId,
-				targetId: target.nodeId,
-				sourcePort: source.port,
-				targetPort: target.port,
-				label: edge.labels?.[0]?.text,
-				width: labelWidth,
-				height: labelHeight,
-				points: parsePoints(getOption(edge.layoutOptions ?? {}, "bendPoints"))
-			}] : [];
-		})
-	});
-}
-function parsePoints(value) {
-	if (typeof value !== "string") return void 0;
-	const points = [...value.matchAll(/\{\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\}/g)].map((match) => ({
-		x: Number(match[1]),
-		y: Number(match[2])
-	}));
-	return points.length > 0 ? points : void 0;
-}
-function parsePosition(value) {
-	if (typeof value !== "string") return void 0;
-	const match = value.match(/\(\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\)/);
-	return match ? {
-		x: Number(match[1]),
-		y: Number(match[2])
-	} : void 0;
-}
-function toSection(edge, points) {
-	const startPoint = points[0];
-	const endPoint = points.at(-1);
-	if (!startPoint || !endPoint) return void 0;
-	return {
-		id: `${String(edge.id)}_s0`,
-		startPoint: { ...startPoint },
-		endPoint: { ...endPoint },
-		incomingShape: edge.sources?.[0] ?? edge.source,
-		outgoingShape: edge.targets?.[0] ?? edge.target,
-		...points.length > 2 ? { bendPoints: points.slice(1, -1).map((point) => ({ ...point })) } : {}
-	};
-}
-function applyLayout(root, graph, padding, layoutOptions, resultPolicy) {
-	const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
-	const edgeById = new Map(graph.edges.map((edge) => [edge.id, edge]));
-	for (const child of root.children ?? []) {
-		const node = nodeById.get(String(child.id));
-		if (!node) continue;
-		child.x = node.x;
-		child.y = node.y;
-		child.width = node.width;
-		child.height = node.height;
-		placeNodeLabels(child, layoutOptions);
-		for (const port of child.ports ?? []) {
-			if (getBooleanOption(port.layoutOptions ?? {}, "noLayout") === true) continue;
-			const laidOutPort = node.ports?.find((candidate) => candidate.name === String(port.id));
-			if (!laidOutPort) continue;
-			port.x = laidOutPort.x;
-			port.y = laidOutPort.y;
-			port.width = laidOutPort.width;
-			port.height = laidOutPort.height;
-		}
-		placePortLabels(child, layoutOptions);
-	}
-	for (const edge of root.edges ?? []) {
-		if (resultPolicy?.preserveEdgeSections) {
-			for (const section$1 of edge.sections ?? []) {
-				section$1.incomingShape ??= edge.sources?.[0] ?? edge.source;
-				section$1.outgoingShape ??= edge.targets?.[0] ?? edge.target;
-			}
-			continue;
-		}
-		const laidOutEdge = edgeById.get(String(edge.id));
-		if (!laidOutEdge) {
-			if (getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true) {
-				for (const section$2 of edge.sections ?? []) {
-					section$2.incomingShape ??= edge.sources?.[0] ?? edge.source;
-					section$2.outgoingShape ??= edge.targets?.[0] ?? edge.target;
-				}
-				continue;
-			}
-			const section$1 = getParentEdgeSection(root, edge);
-			if (section$1) edge.sections = [section$1];
-			continue;
-		}
-		const section = toSection(edge, laidOutEdge.points ?? []);
-		edge.sections = section ? [section] : [];
-		const target = root.children?.find((child) => String(child.id) === String(edge.targets?.[0] ?? edge.target));
-		if (getBooleanOption(target?.layoutOptions ?? {}, "hypernode") === true && (section?.bendPoints?.length ?? 0) > 0) edge.junctionPoints = [section.bendPoints.at(-1)];
-		let labelY = laidOutEdge.y ?? 0;
-		const points = laidOutEdge.points ?? [];
-		const firstPoint = points[0] ?? {
-			x: laidOutEdge.x ?? 0,
-			y: laidOutEdge.y ?? 0
-		};
-		const lastPoint = points.at(-1) ?? firstPoint;
-		const midpointX = (laidOutEdge.x ?? 0) + (laidOutEdge.width ?? 0) / 2;
-		const edgeLabelSpacing = getNumberOption(layoutOptions, "spacing.edgeLabel") ?? 2;
-		const labelLabelSpacing = getNumberOption(layoutOptions, "spacing.labelLabel") ?? 0;
-		for (const label of edge.labels ?? []) {
-			if (getBooleanOption(label.layoutOptions ?? {}, "noLayout") === true) {
-				label.x ??= 0;
-				label.y ??= 0;
-				continue;
-			}
-			if (!isLayoutEdgeLabel(label)) {
-				label.x ??= 0;
-				label.y ??= 0;
-				continue;
-			}
-			const placement = String(getOption(label.layoutOptions ?? {}, "edgeLabels.placement") ?? "CENTER");
-			const width = label.width ?? 0;
-			label.x = placement === "TAIL" ? firstPoint.x + edgeLabelSpacing : placement === "HEAD" ? lastPoint.x - width - edgeLabelSpacing : midpointX - width / 2;
-			label.y = labelY;
-			labelY += (label.height ?? 0) + labelLabelSpacing;
-		}
-	}
-	if (!resultPolicy?.skipBoundsNormalization) normalizeElkGraphBounds(root, padding, layoutOptions);
-}
-function normalizeElkGraphBounds(root, padding, layoutOptions = {}) {
-	const authoredWidth = root.width;
-	const authoredHeight = root.height;
-	const fixedGraphSize = getBooleanOption(layoutOptions, "nodeSize.fixedGraphSize") === true;
-	const layoutChildren = (root.children ?? []).filter((node) => getBooleanOption(node.layoutOptions ?? {}, "noLayout") !== true);
-	let minimumX = Number.POSITIVE_INFINITY;
-	let minimumY = Number.POSITIVE_INFINITY;
-	for (const node of layoutChildren) {
-		minimumX = Math.min(minimumX, node.x ?? 0, ...(node.labels ?? []).map((label) => (node.x ?? 0) + (label.x ?? 0)), ...(node.ports ?? []).map((port) => (node.x ?? 0) + (port.x ?? 0)), ...(node.ports ?? []).flatMap((port) => (port.labels ?? []).map((label) => (node.x ?? 0) + (port.x ?? 0) + (label.x ?? 0))));
-		minimumY = Math.min(minimumY, node.y ?? 0, ...(node.labels ?? []).map((label) => (node.y ?? 0) + (label.y ?? 0)), ...(node.ports ?? []).map((port) => (node.y ?? 0) + (port.y ?? 0)), ...(node.ports ?? []).flatMap((port) => (port.labels ?? []).map((label) => (node.y ?? 0) + (port.y ?? 0) + (label.y ?? 0))));
-	}
-	for (const edge of root.edges ?? []) {
-		const laidOutLabels = (edge.labels ?? []).filter(isLayoutEdgeLabel);
-		minimumX = Math.min(minimumX, ...laidOutLabels.map((label) => label.x ?? 0));
-		minimumY = Math.min(minimumY, ...laidOutLabels.map((label) => label.y ?? 0));
-		if (getBooleanOption(edge.layoutOptions ?? {}, "noLayout") !== true) {
-			const points = (edge.sections ?? []).flatMap((section) => [
-				section.startPoint,
-				...section.bendPoints ?? [],
-				section.endPoint
-			]);
-			minimumX = Math.min(minimumX, ...points.map((point) => point.x));
-			minimumY = Math.min(minimumY, ...points.map((point) => point.y));
-		}
-	}
-	const shiftX = Number.isFinite(minimumX) ? Math.max(0, padding.left - minimumX) : 0;
-	const shiftY = Number.isFinite(minimumY) ? Math.max(0, padding.top - minimumY) : 0;
-	if (shiftX !== 0 || shiftY !== 0) {
-		for (const node of layoutChildren) {
-			node.x = (node.x ?? 0) + shiftX;
-			node.y = (node.y ?? 0) + shiftY;
-		}
-		for (const edge of root.edges ?? []) {
-			for (const section of edge.sections ?? []) for (const point of [
-				section.startPoint,
-				...section.bendPoints ?? [],
-				section.endPoint
-			]) {
-				point.x += shiftX;
-				point.y += shiftY;
-			}
-			for (const label of (edge.labels ?? []).filter(isLayoutEdgeLabel)) {
-				label.x = (label.x ?? 0) + shiftX;
-				label.y = (label.y ?? 0) + shiftY;
-			}
-		}
-	}
-	const maximumNodeX = Math.max(0, ...layoutChildren.map((node) => (node.x ?? 0) + (node.width ?? 0)));
-	const maximumNodeY = Math.max(0, ...layoutChildren.map((node) => (node.y ?? 0) + (node.height ?? 0)));
-	const layoutEdgePoints = (root.edges ?? []).flatMap((edge) => getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true ? [] : (edge.sections ?? []).flatMap((section) => [
-		section.startPoint,
-		...section.bendPoints ?? [],
-		section.endPoint
-	]));
-	const wrappingStrategy = String(getOption(layoutOptions, "layered.wrapping.strategy") ?? "OFF");
-	const direction = getDirection(layoutOptions);
-	const laidOutChildById = new Map((root.children ?? []).map((child) => [String(child.id), child]));
-	const childByEndpointId = new Map(laidOutChildById);
-	for (const child of root.children ?? []) for (const port of child.ports ?? []) childByEndpointId.set(String(port.id), child);
-	const wrappedEdgeCount = (root.edges ?? []).filter((edge) => {
-		const source = childByEndpointId.get(String(edge.sources?.[0] ?? edge.source));
-		const target = childByEndpointId.get(String(edge.targets?.[0] ?? edge.target));
-		if (!source || !target) return false;
-		return direction === "right" ? (source.x ?? 0) > (target.x ?? 0) : direction === "left" ? (source.x ?? 0) < (target.x ?? 0) : direction === "down" ? (source.y ?? 0) > (target.y ?? 0) : (source.y ?? 0) < (target.y ?? 0);
-	}).length;
-	const hasWrappedEdge = wrappedEdgeCount > 0;
-	const addBoundaryPixel = wrappingStrategy !== "MULTI_EDGE" && !(wrappingStrategy === "SINGLE_EDGE" && hasWrappedEdge) && String(getOption(layoutOptions, "layered.compaction.postCompaction.strategy") ?? "NONE") === "NONE" && getBooleanOption(layoutOptions, "layered.feedbackEdges") !== true && String(getOption(layoutOptions, "layered.layering.nodePromotion.strategy") ?? "NONE") !== "MODEL_ORDER_LEFT_TO_RIGHT" && !(root.edges ?? []).some((edge) => edge.sources?.[0] === edge.targets?.[0]) && !(root.children ?? []).some((child) => (child.children?.length ?? 0) > 0);
-	const edgeBoundsExtraX = addBoundaryPixel && layoutEdgePoints.length > 0 && Math.max(...layoutEdgePoints.map((point) => point.x)) >= maximumNodeX - 1e-9 ? 1 : 0;
-	const edgeBoundsExtraY = addBoundaryPixel && layoutEdgePoints.length > 0 && Math.max(...layoutEdgePoints.map((point) => point.y)) >= maximumNodeY - 1e-9 ? 1 : 0;
-	const singleMultiEdgeCutBoundsExtraY = wrappingStrategy === "MULTI_EDGE" && wrappedEdgeCount === 1 && layoutEdgePoints.length > 0 && Math.max(...layoutEdgePoints.map((point) => point.y)) >= maximumNodeY - 1e-9 ? 1 : 0;
-	const postCompactionBoundsExtraX = !addBoundaryPixel && !hasWrappedEdge && String(getOption(layoutOptions, "layered.compaction.postCompaction.strategy") ?? "NONE") !== "NONE" && layoutEdgePoints.length > 0 && Math.max(...layoutEdgePoints.map((point) => point.x)) > maximumNodeX + 1e-9 ? .04 : 0;
-	const postCompactionBoundsExtraY = !addBoundaryPixel && !hasWrappedEdge && String(getOption(layoutOptions, "layered.compaction.postCompaction.strategy") ?? "NONE") !== "NONE" && layoutEdgePoints.length > 0 && Math.max(...layoutEdgePoints.map((point) => point.y)) > maximumNodeY + 1e-9 ? .04 : 0;
-	const calculatedWidth = Math.max(0, ...layoutChildren.flatMap((node) => [
-		(node.x ?? 0) + (node.width ?? 0),
-		...(node.labels ?? []).map((label) => (node.x ?? 0) + (label.x ?? 0) + (label.width ?? 0)),
-		...(node.ports ?? []).map((port) => (node.x ?? 0) + (port.x ?? 0) + (port.width ?? 0)),
-		...(node.ports ?? []).flatMap((port) => (port.labels ?? []).map((label) => (node.x ?? 0) + (port.x ?? 0) + (label.x ?? 0) + (label.width ?? 0)))
-	]), ...(root.edges ?? []).flatMap((edge) => (edge.labels ?? []).filter(isLayoutEdgeLabel).map((label) => (label.x ?? 0) + (label.width ?? 0))), ...(root.edges ?? []).flatMap((edge) => getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true ? [] : (edge.sections ?? []).flatMap((section) => [
-		section.startPoint.x,
-		...(section.bendPoints ?? []).map((point) => point.x),
-		section.endPoint.x
-	]))) + padding.right + edgeBoundsExtraX + postCompactionBoundsExtraX + (getBooleanOption(layoutOptions, "layered.feedbackEdges") === true && (getDirection(layoutOptions) === "down" || getDirection(layoutOptions) === "up") ? 1 : 0);
-	const calculatedHeight = Math.max(0, ...layoutChildren.flatMap((node) => [
-		(node.y ?? 0) + (node.height ?? 0),
-		...(node.labels ?? []).map((label) => (node.y ?? 0) + (label.y ?? 0) + (label.height ?? 0)),
-		...(node.ports ?? []).map((port) => (node.y ?? 0) + (port.y ?? 0) + (port.height ?? 0)),
-		...(node.ports ?? []).flatMap((port) => (port.labels ?? []).map((label) => (node.y ?? 0) + (port.y ?? 0) + (label.y ?? 0) + (label.height ?? 0)))
-	]), ...(root.edges ?? []).flatMap((edge) => (edge.labels ?? []).filter(isLayoutEdgeLabel).map((label) => (label.y ?? 0) + (label.height ?? 0) + (String(getOption(label.layoutOptions ?? {}, "edgeLabels.placement") ?? "CENTER") === "CENTER" ? 1 : 0))), ...(root.edges ?? []).flatMap((edge) => getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true ? [] : (edge.sections ?? []).flatMap((section) => [
-		section.startPoint.y,
-		...(section.bendPoints ?? []).map((point) => point.y),
-		section.endPoint.y
-	]))) + padding.bottom + edgeBoundsExtraY + singleMultiEdgeCutBoundsExtraY + postCompactionBoundsExtraY + (getBooleanOption(layoutOptions, "layered.feedbackEdges") === true && (getDirection(layoutOptions) === "right" || getDirection(layoutOptions) === "left") ? 1 : 0);
-	root.width = fixedGraphSize ? authoredWidth ?? 0 : calculatedWidth;
-	root.height = fixedGraphSize ? authoredHeight ?? 0 : calculatedHeight;
-}
-function getParentEdgeSection(root, edge) {
-	const sourceId = String(edge.sources?.[0] ?? edge.source);
-	const targetId = String(edge.targets?.[0] ?? edge.target);
-	const rootId = String(root.id);
-	const source = root.children?.find((child) => String(child.id) === sourceId);
-	const target = root.children?.find((child) => String(child.id) === targetId);
-	if (source && targetId === rootId) {
-		const startPoint = {
-			x: (source.x ?? 0) + (source.width ?? 0) / 2,
-			y: (source.y ?? 0) + (source.height ?? 0)
-		};
-		return {
-			id: `${String(edge.id)}_s0`,
-			startPoint,
-			endPoint: {
-				x: startPoint.x,
-				y: 0
-			}
-		};
-	}
-	if (sourceId === rootId && target) {
-		const endPoint = {
-			x: (target.x ?? 0) + (target.width ?? 0) / 2,
-			y: target.y ?? 0
-		};
-		return {
-			id: `${String(edge.id)}_s0`,
-			startPoint: {
-				x: endPoint.x,
-				y: 0
-			},
-			endPoint
-		};
-	}
-}
-function placeNodeLabels(node, globalOptions) {
-	const labelPadding = parsePadding(getOption(globalOptions, "nodeLabels.padding"), 5);
-	for (const label of node.labels ?? []) {
-		if (!label.text) continue;
-		if (getBooleanOption(label.layoutOptions ?? {}, "noLayout") === true) continue;
-		const placement = String(getOption({
-			...globalOptions,
-			...node.layoutOptions,
-			...label.layoutOptions
-		}, "nodeLabels.placement") ?? "");
-		if (!placement) continue;
-		const width = label.width ?? 0;
-		const height = label.height ?? 0;
-		const nodeWidth = node.width ?? 0;
-		const nodeHeight = node.height ?? 0;
-		label.x = placement.includes("H_CENTER") ? (nodeWidth - width + labelPadding.left - labelPadding.right) / 2 : placement.includes("H_RIGHT") ? nodeWidth - width - labelPadding.right : labelPadding.left;
-		if (placement.includes("OUTSIDE") && placement.includes("V_TOP")) label.y = -height - Number(getOption(globalOptions, "spacing.labelNode") ?? 5);
-		else if (placement.includes("OUTSIDE") && placement.includes("V_BOTTOM")) label.y = nodeHeight + Number(getOption(globalOptions, "spacing.labelNode") ?? 5);
-		else if (placement.includes("V_CENTER")) label.y = (nodeHeight - height + labelPadding.top - labelPadding.bottom) / 2;
-		else if (placement.includes("V_BOTTOM")) label.y = nodeHeight - height - labelPadding.bottom;
-		else label.y = labelPadding.top;
-	}
-}
-function placePortLabels(node, globalOptions) {
-	const placement = String(getOption({
-		...globalOptions,
-		...node.layoutOptions
-	}, "portLabels.placement") ?? "OUTSIDE");
-	const inside = placement.includes("INSIDE");
-	const alwaysOtherSide = placement.includes("ALWAYS_OTHER_SAME_SIDE");
-	const spaceEfficient = placement.includes("SPACE_EFFICIENT") || String(getOption(node.layoutOptions ?? {}, "nodeSize.options") ?? "").includes("SPACE_EFFICIENT_PORT_LABELS");
-	const horizontalSpacing = getNumberOption(globalOptions, "spacing.labelPortHorizontal") ?? 1;
-	const verticalSpacing = getNumberOption(globalOptions, "spacing.labelPortVertical") ?? 1;
-	const labelSpacing = getNumberOption(globalOptions, "spacing.labelLabel") ?? 0;
-	const treatAsGroup = getBooleanOption(node.layoutOptions ?? {}, "portLabels.treatAsGroup") ?? false;
-	const placeNextToPort = placement.includes("NEXT_TO_PORT_IF_POSSIBLE") || getBooleanOption(node.layoutOptions ?? {}, "portLabels.nextToPortIfPossible") === true;
-	const nodeWidth = node.width ?? 0;
-	for (const port of node.ports ?? []) {
-		if (getBooleanOption(port.layoutOptions ?? {}, "noLayout") === true) continue;
-		const portWidth = port.width ?? 0;
-		const portHeight = port.height ?? 0;
-		const side = (port.x ?? 0) < 0 ? "WEST" : (port.x ?? 0) >= nodeWidth ? "EAST" : (port.y ?? 0) < 0 ? "NORTH" : "SOUTH";
-		const portsOnSide = (node.ports ?? []).filter((candidate) => {
-			return ((candidate.x ?? 0) < 0 ? "WEST" : (candidate.x ?? 0) >= nodeWidth ? "EAST" : (candidate.y ?? 0) < 0 ? "NORTH" : "SOUTH") === side;
-		});
-		const labels = (port.labels ?? []).filter((label) => Boolean(label.text) && getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true);
-		const totalLabelHeight = labels.reduce((sum, label) => sum + (label.height ?? 0), 0) + Math.max(0, labels.length - 1) * labelSpacing;
-		let stackedY = labels.length > 1 ? inside || placeNextToPort ? treatAsGroup ? (portHeight - totalLabelHeight) / 2 : (portHeight - (labels[0]?.height ?? 0)) / 2 : portHeight + verticalSpacing : void 0;
-		for (const label of labels) {
-			if (!label.text) continue;
-			const width = label.width ?? 0;
-			const height = label.height ?? 0;
-			if (side === "EAST") {
-				label.x = inside ? -width - horizontalSpacing : portWidth + horizontalSpacing;
-				label.y = stackedY ?? (inside || placeNextToPort ? (portHeight - height) / 2 : alwaysOtherSide ? -height - verticalSpacing : portHeight + verticalSpacing);
-			} else if (side === "WEST") {
-				label.x = inside ? portWidth + horizontalSpacing : -width - horizontalSpacing;
-				label.y = stackedY ?? (inside || placeNextToPort ? (portHeight - height) / 2 : alwaysOtherSide ? -height - verticalSpacing : portHeight + verticalSpacing);
-			} else if (side === "NORTH") {
-				label.x = inside || placeNextToPort ? (portWidth - width) / 2 : alwaysOtherSide ? -width - horizontalSpacing : portWidth + horizontalSpacing;
-				label.y = inside ? portHeight + verticalSpacing : -height - verticalSpacing;
-			} else {
-				label.x = inside || placeNextToPort ? (portWidth - width) / 2 : alwaysOtherSide ? -width - horizontalSpacing : portWidth + horizontalSpacing;
-				label.y = inside ? -height - verticalSpacing : portHeight + verticalSpacing;
-			}
-			if (spaceEfficient && portsOnSide[0] === port && portsOnSide.length >= 2 && !placeNextToPort) if (side === "EAST" || side === "WEST") label.y = -height - verticalSpacing;
-			else label.x = -width - horizontalSpacing;
-			if (stackedY !== void 0) stackedY += height + labelSpacing;
-		}
-	}
-}
-
-//#endregion
-Object.defineProperty(exports, 'ELK', {
-  enumerable: true,
-  get: function () {
-    return ELK;
-  }
-});
-Object.defineProperty(exports, 'compileStatechartLayout', {
-  enumerable: true,
-  get: function () {
-    return compileStatechartLayout;
-  }
-});
-Object.defineProperty(exports, 'getElkRoutes', {
-  enumerable: true,
-  get: function () {
-    return getElkRoutes;
-  }
-});
-Object.defineProperty(exports, 'layoutStatechart', {
-  enumerable: true,
-  get: function () {
-    return layoutStatechart;
-  }
-});
-Object.defineProperty(exports, 'scoreStatechartLayout', {
-  enumerable: true,
-  get: function () {
-    return scoreStatechartLayout;
-  }
-});