@statelyai/layout 0.1.3 → 0.3.0

package/dist/{layered-CoeH9LRO.mjs → layered-DGFTeQSl.mjs}

@@ -1,19 +1,6 @@
-//#region src/errors.ts
-var LayoutError = class extends Error {
-	constructor(message, code) {
-		super(message);
-		this.code = code;
-		this.name = "LayoutError";
-	}
-};
-var UnsupportedLayoutError = class extends LayoutError {
-	constructor(message) {
-		super(message, "UNSUPPORTED_LAYOUT");
-		this.name = "UnsupportedLayoutError";
-	}
-};
+import { F as UnsupportedLayoutError, M as routeCrosses, N as routeOrthogonal, P as LayoutError, _ as routeToPolylines, b as recordRouteGeometry, c as orthogonalRouting, j as overlaps, v as nativeGeometry, y as worldGeometry } from "./routing-A2hrK9MP.mjs";
+import { getNodeSize } from "@statelyai/graph/layout";
 
-//#endregion
 //#region src/java-random.ts
 /** Java's 48-bit `java.util.Random`, used by ELK for seeded tie-breaking. */
 var JavaRandom = class JavaRandom {
@@ -3818,6 +3805,2286 @@ function getPolylineMidpoint(points) {
 	};
 }
 
+//#endregion
+//#region src/layered/compound.ts
+const paddingOf = (value) => ({
+	top: typeof value === "number" ? value : value?.top ?? 12,
+	right: typeof value === "number" ? value : value?.right ?? 12,
+	bottom: typeof value === "number" ? value : value?.bottom ?? 12,
+	left: typeof value === "number" ? value : value?.left ?? 12
+});
+/** Solve each scope's occupied envelope bottom-up; never repair returned sibling positions. */
+function layoutCompounds(graph, options, flat) {
+	const nodes = graph.nodes.map((node) => {
+		const size = options.measure?.(node);
+		return {
+			...node,
+			width: size?.width ?? node.width ?? 0,
+			height: size?.height ?? node.height ?? 0
+		};
+	});
+	const byId = new Map(nodes.map((node) => [node.id, node]));
+	const ancestry = (id) => {
+		const chain = [];
+		let current = id;
+		while (current != null) {
+			if (chain.includes(current)) throw new Error(`Cyclic compound hierarchy at ${current}`);
+			chain.push(current);
+			current = byId.get(current)?.parentId ?? null;
+		}
+		return [...chain, null];
+	};
+	const branch = (id, scope) => {
+		const chain = ancestry(id);
+		return chain[chain.indexOf(scope) - 1];
+	};
+	const owner = (edge) => {
+		const a = ancestry(edge.sourceId), b = ancestry(edge.targetId);
+		if (edge.sourceId !== edge.targetId && b.includes(edge.sourceId)) return edge.sourceId;
+		if (edge.sourceId !== edge.targetId && a.includes(edge.targetId)) return edge.targetId;
+		return a.slice(1).find((id) => b.slice(1).includes(id)) ?? null;
+	};
+	const owned = /* @__PURE__ */ new Map();
+	for (const edge of graph.edges) {
+		const scope = owner(edge);
+		owned.set(scope, [...owned.get(scope) ?? [], edge]);
+	}
+	const edges = new Map(graph.edges.map((e) => [e.id, {
+		...e,
+		x: 0,
+		y: 0,
+		width: e.width ?? 0,
+		height: e.height ?? 0
+	}]));
+	const localLabels = /* @__PURE__ */ new Map();
+	const compoundGeometry = /* @__PURE__ */ new Map();
+	const childScopes = [...new Set(nodes.flatMap((n) => n.parentId == null ? [] : [n.parentId]))].sort((a, b) => ancestry(b).length - ancestry(a).length);
+	const solve = (scope) => {
+		const children = nodes.filter((n) => (n.parentId ?? null) === scope);
+		if (!children.length) return;
+		const container = scope == null ? void 0 : byId.get(scope);
+		const config = container && options.compound?.(container);
+		const direction = config?.direction ?? options.direction ?? graph.direction ?? "right";
+		const horizontal = direction === "left" || direction === "right";
+		const padding = paddingOf(config?.padding ?? options.padding);
+		const insets = { ...padding };
+		const header = config?.header;
+		const side = header?.side ?? "top";
+		if (header) insets[side] += side === "top" || side === "bottom" ? header.height : header.width;
+		const scopeEdges = owned.get(scope) ?? [];
+		const boundary = /* @__PURE__ */ new Map();
+		const projected = [];
+		for (const edge of scopeEdges) if (edge.sourceId === scope || edge.targetId === scope) {
+			const id = branch(edge.sourceId === scope ? edge.targetId : edge.sourceId, scope);
+			boundary.set(id, [...boundary.get(id) ?? [], edge]);
+		} else projected.push({
+			...edge,
+			sourceId: branch(edge.sourceId, scope),
+			targetId: branch(edge.targetId, scope),
+			points: void 0
+		});
+		const gap = options.settings?.["spacing.labelNode"] ?? options.spacing?.node ?? 20;
+		const labelGap = options.settings?.["spacing.labelLabel"] ?? 8;
+		const sizes = new Map(children.map((n) => {
+			const labels$1 = boundary.get(n.id) ?? [];
+			const labelWidth = Math.max(0, ...labels$1.map((e) => e.width ?? 0));
+			const labelHeight = labels$1.reduce((sum, e) => sum + (e.height ?? 0), 0) + Math.max(0, labels$1.length - 1) * labelGap;
+			return [n.id, {
+				width: labels$1.length && !horizontal ? n.width + gap + labelWidth : Math.max(n.width, labelWidth),
+				height: labels$1.length && horizontal ? n.height + gap + labelHeight : Math.max(n.height, labelHeight)
+			}];
+		}));
+		const labels = projected.filter((edge) => (edge.width ?? 0) > 0 && (edge.height ?? 0) > 0);
+		const used = new Set([...graph.nodes, ...graph.edges].map((entity) => entity.id));
+		const labelIds = /* @__PURE__ */ new Map();
+		for (const edge of labels) {
+			let id = `__layout_label_${edge.id}`;
+			while ([
+				id,
+				`${id}_source`,
+				`${id}_target`
+			].some((key) => used.has(key))) id += "_";
+			for (const key of [
+				id,
+				`${id}_source`,
+				`${id}_target`
+			]) used.add(key);
+			labelIds.set(edge.id, id);
+			sizes.set(id, {
+				width: edge.width,
+				height: edge.height
+			});
+		}
+		const originalEdges = new Map(graph.edges.map((edge) => [edge.id, edge]));
+		for (const edge of labels) {
+			originalEdges.set(`${labelIds.get(edge.id)}_source`, edges.get(edge.id));
+			originalEdges.set(`${labelIds.get(edge.id)}_target`, edges.get(edge.id));
+		}
+		const placementOrder = new Map(children.map((node, index) => [node.id, index]));
+		for (const edge of labels) placementOrder.set(labelIds.get(edge.id), ((placementOrder.get(edge.sourceId) ?? 0) + (placementOrder.get(edge.targetId) ?? 0)) / 2 + (edge.sourceId === edge.targetId ? .25 : 0));
+		const result$1 = flat({
+			...graph,
+			nodes: [...children.map((n) => ({
+				...n,
+				parentId: null
+			})), ...labels.map((edge) => ({
+				type: "node",
+				id: labelIds.get(edge.id),
+				data: void 0
+			}))].sort((a, b) => placementOrder.get(a.id) - placementOrder.get(b.id)),
+			edges: projected.flatMap((edge) => {
+				const labelId = labelIds.get(edge.id);
+				return labelId ? [{
+					...edge,
+					id: `${labelId}_source`,
+					targetId: labelId,
+					targetPort: void 0,
+					width: 0,
+					height: 0
+				}, {
+					...edge,
+					id: `${labelId}_target`,
+					sourceId: labelId,
+					sourcePort: void 0,
+					width: 0,
+					height: 0
+				}] : [edge];
+			})
+		}, {
+			...options,
+			compound: void 0,
+			direction,
+			padding: insets,
+			measure: (node) => sizes.get(node.id),
+			nodeSettings: (node) => {
+				const original = byId.get(node.id);
+				return original ? options.nodeSettings?.(original) : void 0;
+			},
+			edgeSettings: (edge) => options.edgeSettings?.(originalEdges.get(edge.id) ?? edge)
+		});
+		for (const placed of result$1.nodes) {
+			const node = byId.get(placed.id);
+			if (node) Object.assign(node, {
+				x: placed.x,
+				y: placed.y,
+				ports: placed.ports
+			});
+		}
+		for (const edge of projected) {
+			const labelId = labelIds.get(edge.id);
+			if (labelId) {
+				const label = result$1.nodes.find((n) => n.id === labelId);
+				localLabels.set(edge.id, {
+					scope,
+					rect: {
+						x: label.x,
+						y: label.y,
+						width: label.width,
+						height: label.height
+					}
+				});
+			}
+		}
+		for (const [id, labels$1] of boundary) {
+			const node = byId.get(id);
+			const totalHeight = labels$1.reduce((sum, e) => sum + (e.height ?? 0), 0) + Math.max(0, labels$1.length - 1) * labelGap;
+			let cross = horizontal ? 0 : (Math.max(node.height, totalHeight) - totalHeight) / 2;
+			for (const edge of labels$1) {
+				const width = edge.width ?? 0, height = edge.height ?? 0;
+				localLabels.set(edge.id, {
+					scope,
+					rect: {
+						x: node.x + (horizontal ? (Math.max(node.width, width) - width) / 2 : node.width + gap),
+						y: node.y + (horizontal ? node.height + gap : 0) + cross,
+						width,
+						height
+					}
+				});
+				cross += height + labelGap;
+			}
+		}
+		const boxes = [...children.map((n) => ({
+			x: n.x,
+			y: n.y,
+			...sizes.get(n.id)
+		})), ...[...localLabels.values()].filter((l) => l.scope === scope).map((l) => l.rect)];
+		let dx = Math.max(0, insets.left - Math.min(...boxes.map((b) => b.x)));
+		let dy = Math.max(0, insets.top - Math.min(...boxes.map((b) => b.y)));
+		if (header && (side === "top" || side === "bottom")) {
+			const occupiedWidth = Math.max(...boxes.map((b) => b.x + b.width)) - Math.min(...boxes.map((b) => b.x)) + padding.left + padding.right;
+			dx += Math.max(0, (header.width - occupiedWidth) / 2);
+		}
+		if (header && (side === "left" || side === "right")) {
+			const occupiedHeight = Math.max(...boxes.map((b) => b.y + b.height)) - Math.min(...boxes.map((b) => b.y)) + padding.top + padding.bottom;
+			dy += Math.max(0, (header.height - occupiedHeight) / 2);
+		}
+		const right = Math.max(...boxes.map((b) => b.x + dx + b.width));
+		const bottom = Math.max(...boxes.map((b) => b.y + dy + b.height));
+		for (const n of children) {
+			n.x += dx;
+			n.y += dy;
+		}
+		for (const l of localLabels.values()) if (l.scope === scope) {
+			l.rect.x += dx;
+			l.rect.y += dy;
+		}
+		if (container) {
+			const width = Math.max(header?.width ?? 0, config?.minContentSize?.width ? config.minContentSize.width + insets.left + insets.right : 0, right + insets.right);
+			const height = Math.max(header?.height ?? 0, config?.minContentSize?.height ? config.minContentSize.height + insets.top + insets.bottom : 0, bottom + insets.bottom);
+			container.width = Math.max(container.width, width);
+			container.height = Math.max(container.height, height);
+			compoundGeometry.set(container.id, {
+				bounds: {
+					x: 0,
+					y: 0,
+					width: container.width,
+					height: container.height
+				},
+				content: {
+					x: insets.left,
+					y: insets.top,
+					width: container.width - insets.left - insets.right,
+					height: container.height - insets.top - insets.bottom
+				},
+				...header ? { header: {
+					x: side === "right" ? container.width - header.width : 0,
+					y: side === "bottom" ? container.height - header.height : 0,
+					width: side === "top" || side === "bottom" ? container.width : header.width,
+					height: side === "left" || side === "right" ? container.height : header.height
+				} } : {}
+			});
+		}
+	};
+	for (const scope of childScopes) solve(scope);
+	const roots = nodes.filter((n) => n.parentId == null);
+	if (roots.length === 1 && compoundGeometry.has(roots[0].id) && !owned.get(null)?.length) Object.assign(roots[0], {
+		x: 0,
+		y: 0
+	});
+	else solve(null);
+	const origin = (id) => {
+		if (id == null) return {
+			x: 0,
+			y: 0
+		};
+		return ancestry(id).slice(0, -1).reduce((p, key) => ({
+			x: p.x + byId.get(key).x,
+			y: p.y + byId.get(key).y
+		}), {
+			x: 0,
+			y: 0
+		});
+	};
+	for (const [id, label] of localLabels) {
+		const offset = origin(label.scope);
+		Object.assign(edges.get(id), {
+			...label.rect,
+			x: label.rect.x + offset.x,
+			y: label.rect.y + offset.y
+		});
+	}
+	const attachmentSettings = {};
+	for (const edge of edges.values()) {
+		const sourceGeometry = compoundGeometry.get(edge.sourceId), targetGeometry = compoundGeometry.get(edge.targetId);
+		const intent = options.edgeAttachment?.(edge);
+		attachmentSettings[edge.id] = {
+			...sourceGeometry && edge.sourceId !== edge.targetId && ancestry(edge.targetId).includes(edge.sourceId) ? { sourceAttachment: {
+				bounds: intent?.source === "outer" ? {
+					x: 0,
+					y: 0,
+					width: sourceGeometry.bounds.width,
+					height: sourceGeometry.bounds.height
+				} : sourceGeometry.content,
+				facing: intent?.source === "outer" ? "outward" : "inward"
+			} } : {},
+			...targetGeometry && intent?.target === "content" ? { targetAttachment: {
+				bounds: targetGeometry.content,
+				facing: "inward"
+			} } : {}
+		};
+	}
+	const worldNodes = nodes.map((n) => ({
+		...n,
+		...origin(n.id)
+	}));
+	const usedIds = new Set(nodes.map((n) => n.id));
+	const headers = [...compoundGeometry].flatMap(([id, geometry]) => {
+		if (!geometry.header) return [];
+		const p = origin(id);
+		let key = `__layout_header_${id}`;
+		while (usedIds.has(key)) key += "_";
+		usedIds.add(key);
+		return [{
+			type: "node",
+			id: key,
+			parentId: id,
+			data: void 0,
+			...geometry.header,
+			x: p.x + geometry.header.x,
+			y: p.y + geometry.header.y
+		}];
+	});
+	const snapshot = orthogonalRouting.route({
+		...graph,
+		nodes: [...worldNodes, ...headers],
+		edges: [...edges.values()]
+	}, {
+		coordinateSpace: "world",
+		edges: attachmentSettings
+	});
+	for (const [id, route] of snapshot.routes) {
+		const polylines = routeToPolylines(route);
+		Object.assign(edges.get(id), {
+			points: polylines.flatMap((p) => p.map((point) => ({ ...point }))),
+			routing: "orthogonal"
+		});
+	}
+	for (const [id, geometry] of compoundGeometry) geometry.bounds = {
+		...geometry.bounds,
+		x: byId.get(id).x,
+		y: byId.get(id).y
+	};
+	const result = {
+		...graph,
+		edgeCoordinateSpace: "world",
+		direction: options.direction ?? graph.direction ?? "right",
+		nodes,
+		edges: graph.edges.map((e) => edges.get(e.id)),
+		compoundGeometry,
+		compoundRoutes: snapshot.routes
+	};
+	recordRouteGeometry(result, snapshot.routes);
+	return result;
+}
+
+//#endregion
+//#region node_modules/.pnpm/@lume+kiwi@0.4.4/node_modules/@lume/kiwi/dist/maptype.js
+function createMap() {
+	return new IndexedMap();
+}
+var IndexedMap = class IndexedMap {
+	index = {};
+	array = [];
+	/**
+	* Returns the number of items in the array.
+	*/
+	size() {
+		return this.array.length;
+	}
+	/**
+	* Returns true if the array is empty.
+	*/
+	empty() {
+		return this.array.length === 0;
+	}
+	/**
+	* Returns the item at the given array index.
+	*
+	* @param index The integer index of the desired item.
+	*/
+	itemAt(index) {
+		return this.array[index];
+	}
+	/**
+	* Returns true if the key is in the array, false otherwise.
+	*
+	* @param key The key to locate in the array.
+	*/
+	contains(key) {
+		return this.index[key.id()] !== void 0;
+	}
+	/**
+	* Returns the pair associated with the given key, or undefined.
+	*
+	* @param key The key to locate in the array.
+	*/
+	find(key) {
+		const i = this.index[key.id()];
+		return i === void 0 ? void 0 : this.array[i];
+	}
+	/**
+	* Returns the pair associated with the key if it exists.
+	*
+	* If the key does not exist, a new pair will be created and
+	* inserted using the value created by the given factory.
+	*
+	* @param key The key to locate in the array.
+	* @param factory The function which creates the default value.
+	*/
+	setDefault(key, factory) {
+		const i = this.index[key.id()];
+		if (i === void 0) {
+			const pair = new Pair(key, factory());
+			this.index[key.id()] = this.array.length;
+			this.array.push(pair);
+			return pair;
+		} else return this.array[i];
+	}
+	/**
+	* Insert the pair into the array and return the pair.
+	*
+	* This will overwrite any existing entry in the array.
+	*
+	* @param key The key portion of the pair.
+	* @param value The value portion of the pair.
+	*/
+	insert(key, value) {
+		const pair = new Pair(key, value);
+		const i = this.index[key.id()];
+		if (i === void 0) {
+			this.index[key.id()] = this.array.length;
+			this.array.push(pair);
+		} else this.array[i] = pair;
+		return pair;
+	}
+	/**
+	* Removes and returns the pair for the given key, or undefined.
+	*
+	* @param key The key to remove from the map.
+	*/
+	erase(key) {
+		const i = this.index[key.id()];
+		if (i === void 0) return;
+		this.index[key.id()] = void 0;
+		const pair = this.array[i];
+		const last = this.array.pop();
+		if (pair !== last) {
+			this.array[i] = last;
+			this.index[last.first.id()] = i;
+		}
+		return pair;
+	}
+	/**
+	* Create a copy of this associative array.
+	*/
+	copy() {
+		const copy = new IndexedMap();
+		for (let i = 0; i < this.array.length; i++) {
+			const pair = this.array[i].copy();
+			copy.array[i] = pair;
+			copy.index[pair.first.id()] = i;
+		}
+		return copy;
+	}
+};
+/**
+* A class which defines a generic pair object.
+* @private
+*/
+var Pair = class Pair {
+	first;
+	second;
+	/**
+	* Construct a new Pair object.
+	*
+	* @param first The first item of the pair.
+	* @param second The second item of the pair.
+	*/
+	constructor(first, second) {
+		this.first = first;
+		this.second = second;
+	}
+	/**
+	* Create a copy of the pair.
+	*/
+	copy() {
+		return new Pair(this.first, this.second);
+	}
+};
+
+//#endregion
+//#region node_modules/.pnpm/@lume+kiwi@0.4.4/node_modules/@lume/kiwi/dist/variable.js
+/**
+* The primary user constraint variable.
+*
+* @class
+* @param {String} [name=""] The name to associated with the variable.
+*/
+var Variable = class {
+	constructor(name = "") {
+		this._name = name;
+	}
+	/**
+	* Returns the unique id number of the variable.
+	* @private
+	*/
+	id() {
+		return this._id;
+	}
+	/**
+	* Returns the name of the variable.
+	*
+	* @return {String} name of the variable
+	*/
+	name() {
+		return this._name;
+	}
+	/**
+	* Set the name of the variable.
+	*
+	* @param {String} name Name of the variable
+	*/
+	setName(name) {
+		this._name = name;
+	}
+	/**
+	* Returns the user context object of the variable.
+	* @private
+	*/
+	context() {
+		return this._context;
+	}
+	/**
+	* Set the user context object of the variable.
+	* @private
+	*/
+	setContext(context) {
+		this._context = context;
+	}
+	/**
+	* Returns the value of the variable.
+	*
+	* @return {Number} Calculated value
+	*/
+	value() {
+		return this._value;
+	}
+	/**
+	* Set the value of the variable.
+	* @private
+	*/
+	setValue(value) {
+		this._value = value;
+	}
+	/**
+	* Creates a new Expression by adding a number, variable or expression
+	* to the variable.
+	*
+	* @param {Number|Variable|Expression} value Value to add.
+	* @return {Expression} expression
+	*/
+	plus(value) {
+		return new Expression(this, value);
+	}
+	/**
+	* Creates a new Expression by substracting a number, variable or expression
+	* from the variable.
+	*
+	* @param {Number|Variable|Expression} value Value to substract.
+	* @return {Expression} expression
+	*/
+	minus(value) {
+		return new Expression(this, typeof value === "number" ? -value : [-1, value]);
+	}
+	/**
+	* Creates a new Expression by multiplying with a fixed number.
+	*
+	* @param {Number} coefficient Coefficient to multiply with.
+	* @return {Expression} expression
+	*/
+	multiply(coefficient) {
+		return new Expression([coefficient, this]);
+	}
+	/**
+	* Creates a new Expression by dividing with a fixed number.
+	*
+	* @param {Number} coefficient Coefficient to divide by.
+	* @return {Expression} expression
+	*/
+	divide(coefficient) {
+		return new Expression([1 / coefficient, this]);
+	}
+	/**
+	* Returns the JSON representation of the variable.
+	* @private
+	*/
+	toJSON() {
+		return {
+			name: this._name,
+			value: this._value
+		};
+	}
+	toString() {
+		return this._context + "[" + this._name + ":" + this._value + "]";
+	}
+	_name;
+	_value = 0;
+	_context = null;
+	_id = VarId++;
+};
+/**
+* The internal variable id counter.
+* @private
+*/
+let VarId = 0;
+
+//#endregion
+//#region node_modules/.pnpm/@lume+kiwi@0.4.4/node_modules/@lume/kiwi/dist/expression.js
+/**
+* An expression of variable terms and a constant.
+*
+* The constructor accepts an arbitrary number of parameters,
+* each of which must be one of the following types:
+*  - number
+*  - Variable
+*  - Expression
+*  - 2-tuple of [number, Variable|Expression]
+*
+* The parameters are summed. The tuples are multiplied.
+*
+* @class
+* @param {...(number|Variable|Expression|Array)} args
+*/
+var Expression = class Expression {
+	constructor() {
+		let parsed = parseArgs(arguments);
+		this._terms = parsed.terms;
+		this._constant = parsed.constant;
+	}
+	/**
+	* Returns the mapping of terms in the expression.
+	*
+	* This *must* be treated as const.
+	* @private
+	*/
+	terms() {
+		return this._terms;
+	}
+	/**
+	* Returns the constant of the expression.
+	* @private
+	*/
+	constant() {
+		return this._constant;
+	}
+	/**
+	* Returns the computed value of the expression.
+	*
+	* @private
+	* @return {Number} computed value of the expression
+	*/
+	value() {
+		let result = this._constant;
+		for (let i = 0, n = this._terms.size(); i < n; i++) {
+			let pair = this._terms.itemAt(i);
+			result += pair.first.value() * pair.second;
+		}
+		return result;
+	}
+	/**
+	* Creates a new Expression by adding a number, variable or expression
+	* to the expression.
+	*
+	* @param {Number|Variable|Expression} value Value to add.
+	* @return {Expression} expression
+	*/
+	plus(value) {
+		return new Expression(this, value);
+	}
+	/**
+	* Creates a new Expression by substracting a number, variable or expression
+	* from the expression.
+	*
+	* @param {Number|Variable|Expression} value Value to substract.
+	* @return {Expression} expression
+	*/
+	minus(value) {
+		return new Expression(this, typeof value === "number" ? -value : [-1, value]);
+	}
+	/**
+	* Creates a new Expression by multiplying with a fixed number.
+	*
+	* @param {Number} coefficient Coefficient to multiply with.
+	* @return {Expression} expression
+	*/
+	multiply(coefficient) {
+		return new Expression([coefficient, this]);
+	}
+	/**
+	* Creates a new Expression by dividing with a fixed number.
+	*
+	* @param {Number} coefficient Coefficient to divide by.
+	* @return {Expression} expression
+	*/
+	divide(coefficient) {
+		return new Expression([1 / coefficient, this]);
+	}
+	isConstant() {
+		return this._terms.size() == 0;
+	}
+	toString() {
+		let result = this._terms.array.map(function(pair) {
+			return pair.second + "*" + pair.first.toString();
+		}).join(" + ");
+		if (!this.isConstant() && this._constant !== 0) result += " + ";
+		result += this._constant;
+		return result;
+	}
+	_terms;
+	_constant;
+};
+/**
+* An internal argument parsing function.
+* @private
+*/
+function parseArgs(args) {
+	let constant = 0;
+	let factory = () => 0;
+	let terms = createMap();
+	for (let i = 0, n = args.length; i < n; ++i) {
+		let item = args[i];
+		if (typeof item === "number") constant += item;
+		else if (item instanceof Variable) terms.setDefault(item, factory).second += 1;
+		else if (item instanceof Expression) {
+			constant += item.constant();
+			let terms2 = item.terms();
+			for (let j = 0, k = terms2.size(); j < k; j++) {
+				let termPair = terms2.itemAt(j);
+				terms.setDefault(termPair.first, factory).second += termPair.second;
+			}
+		} else if (item instanceof Array) {
+			if (item.length !== 2) throw new Error("array must have length 2");
+			let value = item[0];
+			let value2 = item[1];
+			if (typeof value !== "number") throw new Error("array item 0 must be a number");
+			if (value2 instanceof Variable) terms.setDefault(value2, factory).second += value;
+			else if (value2 instanceof Expression) {
+				constant += value2.constant() * value;
+				let terms2 = value2.terms();
+				for (let j = 0, k = terms2.size(); j < k; j++) {
+					let termPair = terms2.itemAt(j);
+					terms.setDefault(termPair.first, factory).second += termPair.second * value;
+				}
+			} else throw new Error("array item 1 must be a variable or expression");
+		} else throw new Error("invalid Expression argument: " + item);
+	}
+	return {
+		terms,
+		constant
+	};
+}
+
+//#endregion
+//#region node_modules/.pnpm/@lume+kiwi@0.4.4/node_modules/@lume/kiwi/dist/strength.js
+/**
+* @class Strength
+*/
+var Strength = class Strength {
+	/**
+	* Create a new symbolic strength.
+	*
+	* @param a strong
+	* @param b medium
+	* @param c weak
+	* @param [w] weight
+	* @return strength
+	*/
+	static create(a, b, c$1, w = 1) {
+		let result = 0;
+		result += Math.max(0, Math.min(1e3, a * w)) * 1e6;
+		result += Math.max(0, Math.min(1e3, b * w)) * 1e3;
+		result += Math.max(0, Math.min(1e3, c$1 * w));
+		return result;
+	}
+	/**
+	* The 'required' symbolic strength.
+	*/
+	static required = Strength.create(1e3, 1e3, 1e3);
+	/**
+	* The 'strong' symbolic strength.
+	*/
+	static strong = Strength.create(1, 0, 0);
+	/**
+	* The 'medium' symbolic strength.
+	*/
+	static medium = Strength.create(0, 1, 0);
+	/**
+	* The 'weak' symbolic strength.
+	*/
+	static weak = Strength.create(0, 0, 1);
+	/**
+	* Clip a symbolic strength to the allowed min and max.
+	* @private
+	*/
+	static clip(value) {
+		return Math.max(0, Math.min(Strength.required, value));
+	}
+};
+
+//#endregion
+//#region node_modules/.pnpm/@lume+kiwi@0.4.4/node_modules/@lume/kiwi/dist/constraint.js
+/**
+* An enum defining the linear constraint operators.
+*
+* |Value|Operator|Description|
+* |----|-----|-----|
+* |`Le`|<=|Less than equal|
+* |`Ge`|>=|Greater than equal|
+* |`Eq`|==|Equal|
+*
+* @enum {Number}
+*/
+var Operator;
+(function(Operator$1) {
+	Operator$1[Operator$1["Le"] = 0] = "Le";
+	Operator$1[Operator$1["Ge"] = 1] = "Ge";
+	Operator$1[Operator$1["Eq"] = 2] = "Eq";
+})(Operator || (Operator = {}));
+/**
+* A linear constraint equation.
+*
+* A constraint equation is composed of an expression, an operator,
+* and a strength. The RHS of the equation is implicitly zero.
+*
+* @class
+* @param {Expression} expression The constraint expression (LHS).
+* @param {Operator} operator The equation operator.
+* @param {Expression} [rhs] Right hand side of the expression.
+* @param {Number} [strength=Strength.required] The strength of the constraint.
+*/
+var Constraint = class {
+	constructor(expression, operator, rhs, strength = Strength.required) {
+		this._operator = operator;
+		this._strength = Strength.clip(strength);
+		if (rhs === void 0 && expression instanceof Expression) this._expression = expression;
+		else this._expression = expression.minus(rhs);
+	}
+	/**
+	* Returns the unique id number of the constraint.
+	* @private
+	*/
+	id() {
+		return this._id;
+	}
+	/**
+	* Returns the expression of the constraint.
+	*
+	* @return {Expression} expression
+	*/
+	expression() {
+		return this._expression;
+	}
+	/**
+	* Returns the relational operator of the constraint.
+	*
+	* @return {Operator} linear constraint operator
+	*/
+	op() {
+		return this._operator;
+	}
+	/**
+	* Returns the strength of the constraint.
+	*
+	* @return {Number} strength
+	*/
+	strength() {
+		return this._strength;
+	}
+	toString() {
+		return this._expression.toString() + " " + [
+			"<=",
+			">=",
+			"="
+		][this._operator] + " 0 (" + this._strength.toString() + ")";
+	}
+	_expression;
+	_operator;
+	_strength;
+	_id = CnId++;
+};
+/**
+* The internal constraint id counter.
+* @private
+*/
+let CnId = 0;
+
+//#endregion
+//#region node_modules/.pnpm/@lume+kiwi@0.4.4/node_modules/@lume/kiwi/dist/solver.js
+/**
+* The constraint solver class.
+*
+* @class
+*/
+var Solver = class {
+	/**
+	* @type {number} - The max number of solver iterations before an error
+	* is thrown, in order to prevent infinite iteration. Default: `10,000`.
+	*/
+	maxIterations = 1e3;
+	/**
+	* Construct a new Solver.
+	*/
+	constructor() {}
+	/**
+	* Creates and add a constraint to the solver.
+	*
+	* @param {Expression|Variable} lhs Left hand side of the expression
+	* @param {Operator} operator Operator
+	* @param {Expression|Variable|Number} rhs Right hand side of the expression
+	* @param {Number} [strength=Strength.required] Strength
+	*/
+	createConstraint(lhs, operator, rhs, strength = Strength.required) {
+		let cn = new Constraint(lhs, operator, rhs, strength);
+		this.addConstraint(cn);
+		return cn;
+	}
+	/**
+	* Add a constraint to the solver.
+	*
+	* @param {Constraint} constraint Constraint to add to the solver
+	*/
+	addConstraint(constraint) {
+		if (this._cnMap.find(constraint) !== void 0) throw new Error("duplicate constraint");
+		let data = this._createRow(constraint);
+		let row = data.row;
+		let tag = data.tag;
+		let subject = this._chooseSubject(row, tag);
+		if (subject.type() === SymbolType.Invalid && row.allDummies()) if (!nearZero(row.constant())) throw new Error("unsatisfiable constraint");
+		else subject = tag.marker;
+		if (subject.type() === SymbolType.Invalid) {
+			if (!this._addWithArtificialVariable(row)) throw new Error("unsatisfiable constraint");
+		} else {
+			row.solveFor(subject);
+			this._substitute(subject, row);
+			this._rowMap.insert(subject, row);
+		}
+		this._cnMap.insert(constraint, tag);
+		this._optimize(this._objective);
+	}
+	/**
+	* Remove a constraint from the solver.
+	*
+	* @param {Constraint} constraint Constraint to remove from the solver
+	*/
+	removeConstraint(constraint) {
+		let cnPair = this._cnMap.erase(constraint);
+		if (cnPair === void 0) throw new Error("unknown constraint");
+		this._removeConstraintEffects(constraint, cnPair.second);
+		let marker = cnPair.second.marker;
+		let rowPair = this._rowMap.erase(marker);
+		if (rowPair === void 0) {
+			let leaving = this._getMarkerLeavingSymbol(marker);
+			if (leaving.type() === SymbolType.Invalid) throw new Error("failed to find leaving row");
+			rowPair = this._rowMap.erase(leaving);
+			rowPair.second.solveForEx(leaving, marker);
+			this._substitute(marker, rowPair.second);
+		}
+		this._optimize(this._objective);
+	}
+	/**
+	* Test whether the solver contains the constraint.
+	*
+	* @param {Constraint} constraint Constraint to test for
+	* @return {Bool} true or false
+	*/
+	hasConstraint(constraint) {
+		return this._cnMap.contains(constraint);
+	}
+	/**
+	* Get an array of the current constraints.
+	*
+	* @return {Constraint[]}
+	*/
+	getConstraints() {
+		return this._cnMap.array.map(({ first }) => first);
+	}
+	/**
+	* Add an edit variable to the solver.
+	*
+	* @param {Variable} variable Edit variable to add to the solver
+	* @param {Number} strength Strength, should be less than `Strength.required`
+	*/
+	addEditVariable(variable, strength) {
+		if (this._editMap.find(variable) !== void 0) throw new Error("duplicate edit variable");
+		strength = Strength.clip(strength);
+		if (strength === Strength.required) throw new Error("bad required strength");
+		let cn = new Constraint(new Expression(variable), Operator.Eq, void 0, strength);
+		this.addConstraint(cn);
+		let info = {
+			tag: this._cnMap.find(cn).second,
+			constraint: cn,
+			constant: 0
+		};
+		this._editMap.insert(variable, info);
+	}
+	/**
+	* Remove an edit variable from the solver.
+	*
+	* @param {Variable} variable Edit variable to remove from the solver
+	*/
+	removeEditVariable(variable) {
+		let editPair = this._editMap.erase(variable);
+		if (editPair === void 0) throw new Error("unknown edit variable");
+		this.removeConstraint(editPair.second.constraint);
+	}
+	/**
+	* Test whether the solver contains the edit variable.
+	*
+	* @param {Variable} variable Edit variable to test for
+	* @return {Bool} true or false
+	*/
+	hasEditVariable(variable) {
+		return this._editMap.contains(variable);
+	}
+	/**
+	* Suggest the value of an edit variable.
+	*
+	* @param {Variable} variable Edit variable to suggest a value for
+	* @param {Number} value Suggested value
+	*/
+	suggestValue(variable, value) {
+		let editPair = this._editMap.find(variable);
+		if (editPair === void 0) throw new Error("unknown edit variable");
+		let rows = this._rowMap;
+		let info = editPair.second;
+		let delta = value - info.constant;
+		info.constant = value;
+		let marker = info.tag.marker;
+		let rowPair = rows.find(marker);
+		if (rowPair !== void 0) {
+			if (rowPair.second.add(-delta) < 0) this._infeasibleRows.push(marker);
+			this._dualOptimize();
+			return;
+		}
+		let other = info.tag.other;
+		rowPair = rows.find(other);
+		if (rowPair !== void 0) {
+			if (rowPair.second.add(delta) < 0) this._infeasibleRows.push(other);
+			this._dualOptimize();
+			return;
+		}
+		for (let i = 0, n = rows.size(); i < n; ++i) {
+			let rowPair$1 = rows.itemAt(i);
+			let row = rowPair$1.second;
+			let coeff = row.coefficientFor(marker);
+			if (coeff !== 0 && row.add(delta * coeff) < 0 && rowPair$1.first.type() !== SymbolType.External) this._infeasibleRows.push(rowPair$1.first);
+		}
+		this._dualOptimize();
+	}
+	/**
+	* Update the values of the variables.
+	*/
+	updateVariables() {
+		let vars = this._varMap;
+		let rows = this._rowMap;
+		for (let i = 0, n = vars.size(); i < n; ++i) {
+			let pair = vars.itemAt(i);
+			let rowPair = rows.find(pair.second);
+			if (rowPair !== void 0) pair.first.setValue(rowPair.second.constant());
+			else pair.first.setValue(0);
+		}
+	}
+	/**
+	* Get the symbol for the given variable.
+	*
+	* If a symbol does not exist for the variable, one will be created.
+	* @private
+	*/
+	_getVarSymbol(variable) {
+		let factory = () => this._makeSymbol(SymbolType.External);
+		return this._varMap.setDefault(variable, factory).second;
+	}
+	/**
+	* Create a new Row object for the given constraint.
+	*
+	* The terms in the constraint will be converted to cells in the row.
+	* Any term in the constraint with a coefficient of zero is ignored.
+	* This method uses the `_getVarSymbol` method to get the symbol for
+	* the variables added to the row. If the symbol for a given cell
+	* variable is basic, the cell variable will be substituted with the
+	* basic row.
+	*
+	* The necessary slack and error variables will be added to the row.
+	* If the constant for the row is negative, the sign for the row
+	* will be inverted so the constant becomes positive.
+	*
+	* Returns the created Row and the tag for tracking the constraint.
+	* @private
+	*/
+	_createRow(constraint) {
+		let expr = constraint.expression();
+		let row = new Row(expr.constant());
+		let terms = expr.terms();
+		for (let i = 0, n = terms.size(); i < n; ++i) {
+			let termPair = terms.itemAt(i);
+			if (!nearZero(termPair.second)) {
+				let symbol = this._getVarSymbol(termPair.first);
+				let basicPair = this._rowMap.find(symbol);
+				if (basicPair !== void 0) row.insertRow(basicPair.second, termPair.second);
+				else row.insertSymbol(symbol, termPair.second);
+			}
+		}
+		let objective = this._objective;
+		let strength = constraint.strength();
+		let tag = {
+			marker: INVALID_SYMBOL,
+			other: INVALID_SYMBOL
+		};
+		switch (constraint.op()) {
+			case Operator.Le:
+			case Operator.Ge: {
+				let coeff = constraint.op() === Operator.Le ? 1 : -1;
+				let slack = this._makeSymbol(SymbolType.Slack);
+				tag.marker = slack;
+				row.insertSymbol(slack, coeff);
+				if (strength < Strength.required) {
+					let error = this._makeSymbol(SymbolType.Error);
+					tag.other = error;
+					row.insertSymbol(error, -coeff);
+					objective.insertSymbol(error, strength);
+				}
+				break;
+			}
+			case Operator.Eq:
+				if (strength < Strength.required) {
+					let errplus = this._makeSymbol(SymbolType.Error);
+					let errminus = this._makeSymbol(SymbolType.Error);
+					tag.marker = errplus;
+					tag.other = errminus;
+					row.insertSymbol(errplus, -1);
+					row.insertSymbol(errminus, 1);
+					objective.insertSymbol(errplus, strength);
+					objective.insertSymbol(errminus, strength);
+				} else {
+					let dummy = this._makeSymbol(SymbolType.Dummy);
+					tag.marker = dummy;
+					row.insertSymbol(dummy);
+				}
+				break;
+		}
+		if (row.constant() < 0) row.reverseSign();
+		return {
+			row,
+			tag
+		};
+	}
+	/**
+	* Choose the subject for solving for the row.
+	*
+	* This method will choose the best subject for using as the solve
+	* target for the row. An invalid symbol will be returned if there
+	* is no valid target.
+	*
+	* The symbols are chosen according to the following precedence:
+	*
+	* 1) The first symbol representing an external variable.
+	* 2) A negative slack or error tag variable.
+	*
+	* If a subject cannot be found, an invalid symbol will be returned.
+	*
+	* @private
+	*/
+	_chooseSubject(row, tag) {
+		let cells = row.cells();
+		for (let i = 0, n = cells.size(); i < n; ++i) {
+			let pair = cells.itemAt(i);
+			if (pair.first.type() === SymbolType.External) return pair.first;
+		}
+		let type = tag.marker.type();
+		if (type === SymbolType.Slack || type === SymbolType.Error) {
+			if (row.coefficientFor(tag.marker) < 0) return tag.marker;
+		}
+		type = tag.other.type();
+		if (type === SymbolType.Slack || type === SymbolType.Error) {
+			if (row.coefficientFor(tag.other) < 0) return tag.other;
+		}
+		return INVALID_SYMBOL;
+	}
+	/**
+	* Add the row to the tableau using an artificial variable.
+	*
+	* This will return false if the constraint cannot be satisfied.
+	*
+	* @private
+	*/
+	_addWithArtificialVariable(row) {
+		let art = this._makeSymbol(SymbolType.Slack);
+		this._rowMap.insert(art, row.copy());
+		this._artificial = row.copy();
+		this._optimize(this._artificial);
+		let success = nearZero(this._artificial.constant());
+		this._artificial = null;
+		let pair = this._rowMap.erase(art);
+		if (pair !== void 0) {
+			let basicRow = pair.second;
+			if (basicRow.isConstant()) return success;
+			let entering = this._anyPivotableSymbol(basicRow);
+			if (entering.type() === SymbolType.Invalid) return false;
+			basicRow.solveForEx(art, entering);
+			this._substitute(entering, basicRow);
+			this._rowMap.insert(entering, basicRow);
+		}
+		let rows = this._rowMap;
+		for (let i = 0, n = rows.size(); i < n; ++i) rows.itemAt(i).second.removeSymbol(art);
+		this._objective.removeSymbol(art);
+		return success;
+	}
+	/**
+	* Substitute the parametric symbol with the given row.
+	*
+	* This method will substitute all instances of the parametric symbol
+	* in the tableau and the objective function with the given row.
+	*
+	* @private
+	*/
+	_substitute(symbol, row) {
+		let rows = this._rowMap;
+		for (let i = 0, n = rows.size(); i < n; ++i) {
+			let pair = rows.itemAt(i);
+			pair.second.substitute(symbol, row);
+			if (pair.second.constant() < 0 && pair.first.type() !== SymbolType.External) this._infeasibleRows.push(pair.first);
+		}
+		this._objective.substitute(symbol, row);
+		if (this._artificial) this._artificial.substitute(symbol, row);
+	}
+	/**
+	* Optimize the system for the given objective function.
+	*
+	* This method performs iterations of Phase 2 of the simplex method
+	* until the objective function reaches a minimum.
+	*
+	* @private
+	*/
+	_optimize(objective) {
+		let iterations = 0;
+		while (iterations < this.maxIterations) {
+			let entering = this._getEnteringSymbol(objective);
+			if (entering.type() === SymbolType.Invalid) return;
+			let leaving = this._getLeavingSymbol(entering);
+			if (leaving.type() === SymbolType.Invalid) throw new Error("the objective is unbounded");
+			let row = this._rowMap.erase(leaving).second;
+			row.solveForEx(leaving, entering);
+			this._substitute(entering, row);
+			this._rowMap.insert(entering, row);
+			iterations++;
+		}
+		throw new Error("solver iterations exceeded");
+	}
+	/**
+	* Optimize the system using the dual of the simplex method.
+	*
+	* The current state of the system should be such that the objective
+	* function is optimal, but not feasible. This method will perform
+	* an iteration of the dual simplex method to make the solution both
+	* optimal and feasible.
+	*
+	* @private
+	*/
+	_dualOptimize() {
+		let rows = this._rowMap;
+		let infeasible = this._infeasibleRows;
+		while (infeasible.length !== 0) {
+			let leaving = infeasible.pop();
+			let pair = rows.find(leaving);
+			if (pair !== void 0 && pair.second.constant() < 0) {
+				let entering = this._getDualEnteringSymbol(pair.second);
+				if (entering.type() === SymbolType.Invalid) throw new Error("dual optimize failed");
+				let row = pair.second;
+				rows.erase(leaving);
+				row.solveForEx(leaving, entering);
+				this._substitute(entering, row);
+				rows.insert(entering, row);
+			}
+		}
+	}
+	/**
+	* Compute the entering variable for a pivot operation.
+	*
+	* This method will return first symbol in the objective function which
+	* is non-dummy and has a coefficient less than zero. If no symbol meets
+	* the criteria, it means the objective function is at a minimum, and an
+	* invalid symbol is returned.
+	*
+	* @private
+	*/
+	_getEnteringSymbol(objective) {
+		let cells = objective.cells();
+		for (let i = 0, n = cells.size(); i < n; ++i) {
+			let pair = cells.itemAt(i);
+			let symbol = pair.first;
+			if (pair.second < 0 && symbol.type() !== SymbolType.Dummy) return symbol;
+		}
+		return INVALID_SYMBOL;
+	}
+	/**
+	* Compute the entering symbol for the dual optimize operation.
+	*
+	* This method will return the symbol in the row which has a positive
+	* coefficient and yields the minimum ratio for its respective symbol
+	* in the objective function. The provided row *must* be infeasible.
+	* If no symbol is found which meats the criteria, an invalid symbol
+	* is returned.
+	*
+	* @private
+	*/
+	_getDualEnteringSymbol(row) {
+		let ratio = Number.MAX_VALUE;
+		let entering = INVALID_SYMBOL;
+		let cells = row.cells();
+		for (let i = 0, n = cells.size(); i < n; ++i) {
+			let pair = cells.itemAt(i);
+			let symbol = pair.first;
+			let c$1 = pair.second;
+			if (c$1 > 0 && symbol.type() !== SymbolType.Dummy) {
+				let r = this._objective.coefficientFor(symbol) / c$1;
+				if (r < ratio) {
+					ratio = r;
+					entering = symbol;
+				}
+			}
+		}
+		return entering;
+	}
+	/**
+	* Compute the symbol for pivot exit row.
+	*
+	* This method will return the symbol for the exit row in the row
+	* map. If no appropriate exit symbol is found, an invalid symbol
+	* will be returned. This indicates that the objective function is
+	* unbounded.
+	*
+	* @private
+	*/
+	_getLeavingSymbol(entering) {
+		let ratio = Number.MAX_VALUE;
+		let found = INVALID_SYMBOL;
+		let rows = this._rowMap;
+		for (let i = 0, n = rows.size(); i < n; ++i) {
+			let pair = rows.itemAt(i);
+			let symbol = pair.first;
+			if (symbol.type() !== SymbolType.External) {
+				let row = pair.second;
+				let temp = row.coefficientFor(entering);
+				if (temp < 0) {
+					let temp_ratio = -row.constant() / temp;
+					if (temp_ratio < ratio) {
+						ratio = temp_ratio;
+						found = symbol;
+					}
+				}
+			}
+		}
+		return found;
+	}
+	/**
+	* Compute the leaving symbol for a marker variable.
+	*
+	* This method will return a symbol corresponding to a basic row
+	* which holds the given marker variable. The row will be chosen
+	* according to the following precedence:
+	*
+	* 1) The row with a restricted basic varible and a negative coefficient
+	*    for the marker with the smallest ratio of -constant / coefficient.
+	*
+	* 2) The row with a restricted basic variable and the smallest ratio
+	*    of constant / coefficient.
+	*
+	* 3) The last unrestricted row which contains the marker.
+	*
+	* If the marker does not exist in any row, an invalid symbol will be
+	* returned. This indicates an internal solver error since the marker
+	* *should* exist somewhere in the tableau.
+	*
+	* @private
+	*/
+	_getMarkerLeavingSymbol(marker) {
+		let dmax = Number.MAX_VALUE;
+		let r1 = dmax;
+		let r2 = dmax;
+		let invalid = INVALID_SYMBOL;
+		let first = invalid;
+		let second = invalid;
+		let third = invalid;
+		let rows = this._rowMap;
+		for (let i = 0, n = rows.size(); i < n; ++i) {
+			let pair = rows.itemAt(i);
+			let row = pair.second;
+			let c$1 = row.coefficientFor(marker);
+			if (c$1 === 0) continue;
+			let symbol = pair.first;
+			if (symbol.type() === SymbolType.External) third = symbol;
+			else if (c$1 < 0) {
+				let r = -row.constant() / c$1;
+				if (r < r1) {
+					r1 = r;
+					first = symbol;
+				}
+			} else {
+				let r = row.constant() / c$1;
+				if (r < r2) {
+					r2 = r;
+					second = symbol;
+				}
+			}
+		}
+		if (first !== invalid) return first;
+		if (second !== invalid) return second;
+		return third;
+	}
+	/**
+	* Remove the effects of a constraint on the objective function.
+	*
+	* @private
+	*/
+	_removeConstraintEffects(cn, tag) {
+		if (tag.marker.type() === SymbolType.Error) this._removeMarkerEffects(tag.marker, cn.strength());
+		if (tag.other.type() === SymbolType.Error) this._removeMarkerEffects(tag.other, cn.strength());
+	}
+	/**
+	* Remove the effects of an error marker on the objective function.
+	*
+	* @private
+	*/
+	_removeMarkerEffects(marker, strength) {
+		let pair = this._rowMap.find(marker);
+		if (pair !== void 0) this._objective.insertRow(pair.second, -strength);
+		else this._objective.insertSymbol(marker, -strength);
+	}
+	/**
+	* Get the first Slack or Error symbol in the row.
+	*
+	* If no such symbol is present, an invalid symbol will be returned.
+	*
+	* @private
+	*/
+	_anyPivotableSymbol(row) {
+		let cells = row.cells();
+		for (let i = 0, n = cells.size(); i < n; ++i) {
+			let pair = cells.itemAt(i);
+			let type = pair.first.type();
+			if (type === SymbolType.Slack || type === SymbolType.Error) return pair.first;
+		}
+		return INVALID_SYMBOL;
+	}
+	/**
+	* Returns a new Symbol of the given type.
+	*
+	* @private
+	*/
+	_makeSymbol(type) {
+		return new Symbol(type, this._idTick++);
+	}
+	_cnMap = createCnMap();
+	_rowMap = createRowMap();
+	_varMap = createVarMap();
+	_editMap = createEditMap();
+	_infeasibleRows = [];
+	_objective = new Row();
+	_artificial = null;
+	_idTick = 0;
+};
+/**
+* Test whether a value is approximately zero.
+* @private
+*/
+function nearZero(value) {
+	let eps = 1e-8;
+	return value < 0 ? -value < eps : value < eps;
+}
+/**
+* An internal function for creating a constraint map.
+* @private
+*/
+function createCnMap() {
+	return createMap();
+}
+/**
+* An internal function for creating a row map.
+* @private
+*/
+function createRowMap() {
+	return createMap();
+}
+/**
+* An internal function for creating a variable map.
+* @private
+*/
+function createVarMap() {
+	return createMap();
+}
+/**
+* An internal function for creating an edit map.
+* @private
+*/
+function createEditMap() {
+	return createMap();
+}
+/**
+* An enum defining the available symbol types.
+* @private
+*/
+var SymbolType;
+(function(SymbolType$1) {
+	SymbolType$1[SymbolType$1["Invalid"] = 0] = "Invalid";
+	SymbolType$1[SymbolType$1["External"] = 1] = "External";
+	SymbolType$1[SymbolType$1["Slack"] = 2] = "Slack";
+	SymbolType$1[SymbolType$1["Error"] = 3] = "Error";
+	SymbolType$1[SymbolType$1["Dummy"] = 4] = "Dummy";
+})(SymbolType || (SymbolType = {}));
+/**
+* An internal class representing a symbol in the solver.
+* @private
+*/
+var Symbol = class {
+	/**
+	* Construct a new Symbol
+	*
+	* @param [type] The type of the symbol.
+	* @param [id] The unique id number of the symbol.
+	*/
+	constructor(type, id) {
+		this._id = id;
+		this._type = type;
+	}
+	/**
+	* Returns the unique id number of the symbol.
+	*/
+	id() {
+		return this._id;
+	}
+	/**
+	* Returns the type of the symbol.
+	*/
+	type() {
+		return this._type;
+	}
+	_id;
+	_type;
+};
+/**
+* A static invalid symbol
+* @private
+*/
+let INVALID_SYMBOL = new Symbol(SymbolType.Invalid, -1);
+/**
+* An internal row class used by the solver.
+* @private
+*/
+var Row = class Row {
+	/**
+	* Construct a new Row.
+	*/
+	constructor(constant = 0) {
+		this._constant = constant;
+	}
+	/**
+	* Returns the mapping of symbols to coefficients.
+	*/
+	cells() {
+		return this._cellMap;
+	}
+	/**
+	* Returns the constant for the row.
+	*/
+	constant() {
+		return this._constant;
+	}
+	/**
+	* Returns true if the row is a constant value.
+	*/
+	isConstant() {
+		return this._cellMap.empty();
+	}
+	/**
+	* Returns true if the Row has all dummy symbols.
+	*/
+	allDummies() {
+		let cells = this._cellMap;
+		for (let i = 0, n = cells.size(); i < n; ++i) if (cells.itemAt(i).first.type() !== SymbolType.Dummy) return false;
+		return true;
+	}
+	/**
+	* Create a copy of the row.
+	*/
+	copy() {
+		let theCopy = new Row(this._constant);
+		theCopy._cellMap = this._cellMap.copy();
+		return theCopy;
+	}
+	/**
+	* Add a constant value to the row constant.
+	*
+	* Returns the new value of the constant.
+	*/
+	add(value) {
+		return this._constant += value;
+	}
+	/**
+	* Insert the symbol into the row with the given coefficient.
+	*
+	* If the symbol already exists in the row, the coefficient
+	* will be added to the existing coefficient. If the resulting
+	* coefficient is zero, the symbol will be removed from the row.
+	*/
+	insertSymbol(symbol, coefficient = 1) {
+		let pair = this._cellMap.setDefault(symbol, () => 0);
+		if (nearZero(pair.second += coefficient)) this._cellMap.erase(symbol);
+	}
+	/**
+	* Insert a row into this row with a given coefficient.
+	*
+	* The constant and the cells of the other row will be
+	* multiplied by the coefficient and added to this row. Any
+	* cell with a resulting coefficient of zero will be removed
+	* from the row.
+	*/
+	insertRow(other, coefficient = 1) {
+		this._constant += other._constant * coefficient;
+		let cells = other._cellMap;
+		for (let i = 0, n = cells.size(); i < n; ++i) {
+			let pair = cells.itemAt(i);
+			this.insertSymbol(pair.first, pair.second * coefficient);
+		}
+	}
+	/**
+	* Remove a symbol from the row.
+	*/
+	removeSymbol(symbol) {
+		this._cellMap.erase(symbol);
+	}
+	/**
+	* Reverse the sign of the constant and cells in the row.
+	*/
+	reverseSign() {
+		this._constant = -this._constant;
+		let cells = this._cellMap;
+		for (let i = 0, n = cells.size(); i < n; ++i) {
+			let pair = cells.itemAt(i);
+			pair.second = -pair.second;
+		}
+	}
+	/**
+	* Solve the row for the given symbol.
+	*
+	* This method assumes the row is of the form
+	* a * x + b * y + c = 0 and (assuming solve for x) will modify
+	* the row to represent the right hand side of
+	* x = -b/a * y - c / a. The target symbol will be removed from
+	* the row, and the constant and other cells will be multiplied
+	* by the negative inverse of the target coefficient.
+	*
+	* The given symbol *must* exist in the row.
+	*/
+	solveFor(symbol) {
+		let cells = this._cellMap;
+		let coeff = -1 / cells.erase(symbol).second;
+		this._constant *= coeff;
+		for (let i = 0, n = cells.size(); i < n; ++i) cells.itemAt(i).second *= coeff;
+	}
+	/**
+	* Solve the row for the given symbols.
+	*
+	* This method assumes the row is of the form
+	* x = b * y + c and will solve the row such that
+	* y = x / b - c / b. The rhs symbol will be removed from the
+	* row, the lhs added, and the result divided by the negative
+	* inverse of the rhs coefficient.
+	*
+	* The lhs symbol *must not* exist in the row, and the rhs
+	* symbol must* exist in the row.
+	*/
+	solveForEx(lhs, rhs) {
+		this.insertSymbol(lhs, -1);
+		this.solveFor(rhs);
+	}
+	/**
+	* Returns the coefficient for the given symbol.
+	*/
+	coefficientFor(symbol) {
+		let pair = this._cellMap.find(symbol);
+		return pair !== void 0 ? pair.second : 0;
+	}
+	/**
+	* Substitute a symbol with the data from another row.
+	*
+	* Given a row of the form a * x + b and a substitution of the
+	* form x = 3 * y + c the row will be updated to reflect the
+	* expression 3 * a * y + a * c + b.
+	*
+	* If the symbol does not exist in the row, this is a no-op.
+	*/
+	substitute(symbol, row) {
+		let pair = this._cellMap.erase(symbol);
+		if (pair !== void 0) this.insertRow(row, pair.second);
+	}
+	_cellMap = createMap();
+	_constant;
+};
+
+//#endregion
+//#region src/constraints.ts
+/** Serializable constraint constructors; graph geometry stays in @statelyai/graph. */
+const c = {
+	align: (value) => ({
+		...value,
+		kind: "align"
+	}),
+	distribute: (value) => ({
+		...value,
+		kind: "distribute"
+	}),
+	pin: (value) => ({
+		...value,
+		kind: "pin"
+	}),
+	linear: (value) => ({
+		...value,
+		kind: "linear"
+	}),
+	waypoint: (value) => ({
+		...value,
+		kind: "waypoint"
+	})
+};
+function constraintFailure(constraint, message) {
+	throw new LayoutError(`${constraint.id}: ${message}`, "UNSATISFIED_CONSTRAINT");
+}
+/** Solve positions only. Fixed geometry is represented by constants, never edit variables. */
+function solveGeometryConstraints(graph, constraints, movableNodes, movableLabels, diagnostics) {
+	const solver = new Solver();
+	const variables = /* @__PURE__ */ new Map();
+	const nodes = new Map(graph.nodes.map((n) => [n.id, n]));
+	const edges = new Map(graph.edges.map((e) => [e.id, e]));
+	function geometry(ref) {
+		const node = "nodeId" in ref;
+		const id = node ? ref.nodeId : ref.edgeId;
+		const rect = node ? nodes.get(id) : edges.get(id);
+		if (!rect) throw new LayoutError(`Unknown constraint entity: ${id}`, "INVALID_CONSTRAINT");
+		const key = JSON.stringify([node ? "node" : "label", id]);
+		if ((node ? movableNodes : movableLabels).has(id) && !variables.has(key)) {
+			const pair = {
+				x: new Variable(`${key}.x`),
+				y: new Variable(`${key}.y`)
+			};
+			variables.set(key, pair);
+			solver.addConstraint(new Constraint(pair.x, Operator.Eq, rect.x, Strength.weak / 10));
+			solver.addConstraint(new Constraint(pair.y, Operator.Eq, rect.y, Strength.weak / 10));
+		}
+		return {
+			rect,
+			variables: variables.get(key)
+		};
+	}
+	function expression(ref, attribute) {
+		const { rect, variables: pair } = geometry(ref);
+		const axis = attribute === "y" || attribute === "centerY" || attribute === "bottom" ? "y" : "x";
+		const extent$1 = axis === "x" ? rect.width : rect.height;
+		const offset = attribute.startsWith("center") ? extent$1 / 2 : attribute === "right" || attribute === "bottom" ? extent$1 : 0;
+		return new Expression(pair?.[axis] ?? rect[axis], offset);
+	}
+	const checks = [];
+	const ids = /* @__PURE__ */ new Set();
+	for (const constraint of constraints) {
+		if (ids.has(constraint.id)) throw new LayoutError(`Duplicate constraint ID: ${constraint.id}`, "INVALID_CONSTRAINT");
+		ids.add(constraint.id);
+		if (constraint.kind === "waypoint") continue;
+		const strength = Strength[constraint.strength ?? "required"];
+		const add = (lhs, operator = Operator.Eq, rhs = 0) => {
+			const difference = lhs.minus(rhs);
+			if (!Number.isFinite(difference.constant()) || !difference.terms().array.every((item) => Number.isFinite(item.second))) throw new LayoutError(`${constraint.id}: non-finite expression`, "INVALID_CONSTRAINT");
+			try {
+				solver.addConstraint(new Constraint(difference, operator, 0, strength));
+			} catch {
+				constraintFailure(constraint, "conflicts with fixed geometry or another required constraint");
+			}
+			checks.push({
+				constraint,
+				expression: difference,
+				operator
+			});
+		};
+		if (constraint.kind === "linear") {
+			let value = new Expression();
+			for (const term of constraint.terms) value = value.plus(expression(term.entity, term.attribute).multiply(term.coefficient));
+			add(value, {
+				eq: Operator.Eq,
+				le: Operator.Le,
+				ge: Operator.Ge
+			}[constraint.relation], constraint.value);
+		} else if (constraint.kind === "pin") {
+			geometry(constraint.entity);
+			if (constraint.x !== void 0) add(expression(constraint.entity, "x"), Operator.Eq, constraint.x);
+			if (constraint.y !== void 0) add(expression(constraint.entity, "y"), Operator.Eq, constraint.y);
+		} else {
+			const refs = constraint.entities;
+			for (const ref of refs) geometry(ref);
+			const axis = constraint.axis;
+			const end = axis === "x" ? "right" : "bottom";
+			const center = axis === "x" ? "centerX" : "centerY";
+			if (constraint.kind === "align") {
+				const attr = constraint.anchor === "start" ? axis : constraint.anchor === "end" ? end : center;
+				for (const ref of refs.slice(1)) add(expression(ref, attr), Operator.Eq, expression(refs[0], attr));
+			} else {
+				const gaps = refs.slice(1).map((ref, i) => constraint.spacing === "centers" ? expression(ref, center).minus(expression(refs[i], center)) : expression(ref, axis).minus(expression(refs[i], end)));
+				for (const gap of gaps) {
+					add(gap, Operator.Ge, 0);
+					add(gap, Operator.Eq, constraint.gap ?? gaps[0]);
+				}
+			}
+		}
+	}
+	solver.updateVariables();
+	const warned = /* @__PURE__ */ new Set();
+	for (const check of checks) {
+		const residual = check.expression.value();
+		if ((check.operator === Operator.Eq ? Math.abs(residual) > 1e-6 : check.operator === Operator.Le ? residual > 1e-6 : residual < -1e-6) && !warned.has(check.constraint.id)) {
+			warned.add(check.constraint.id);
+			diagnostics.push({
+				severity: "warning",
+				code: "CONSTRAINT_VIOLATION",
+				message: `Constraint ${check.constraint.id} could not be satisfied`,
+				constraintIds: [check.constraint.id]
+			});
+		}
+	}
+	const coordinate = (variable) => {
+		const value = variable.value();
+		if (!Number.isFinite(value)) throw new LayoutError("Constraint solution contains non-finite geometry", "INVALID_CONSTRAINT");
+		return value === 0 ? 0 : value;
+	};
+	return {
+		...graph,
+		nodes: graph.nodes.map((node) => {
+			const pair = variables.get(JSON.stringify(["node", node.id]));
+			return pair ? {
+				...node,
+				x: coordinate(pair.x),
+				y: coordinate(pair.y)
+			} : node;
+		}),
+		edges: graph.edges.map((edge) => {
+			const pair = variables.get(JSON.stringify(["label", edge.id]));
+			return pair ? {
+				...edge,
+				x: coordinate(pair.x),
+				y: coordinate(pair.y)
+			} : edge;
+		})
+	};
+}
+
+//#endregion
+//#region src/authoring/partial.ts
+const geometryKeys = [
+	"x",
+	"y",
+	"width",
+	"height"
+];
+function finite(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function samePosition(a, b) {
+	return a.x === b.x && a.y === b.y;
+}
+function onRoute(point, points) {
+	return points?.some((b, i) => {
+		if (!i) return false;
+		const a = points[i - 1];
+		const cross = (point.x - a.x) * (b.y - a.y) - (point.y - a.y) * (b.x - a.x);
+		return Math.abs(cross) < 1e-6 && point.x >= Math.min(a.x, b.x) - 1e-6 && point.x <= Math.max(a.x, b.x) + 1e-6 && point.y >= Math.min(a.y, b.y) - 1e-6 && point.y <= Math.max(a.y, b.y) + 1e-6;
+	}) ?? false;
+}
+function labelReferences(constraints) {
+	const ids = /* @__PURE__ */ new Set();
+	const add = (ref) => {
+		if ("edgeId" in ref) ids.add(ref.edgeId);
+	};
+	for (const c$1 of constraints) if (c$1.kind === "align" || c$1.kind === "distribute") c$1.entities.forEach(add);
+	else if (c$1.kind === "pin") add(c$1.entity);
+	else if (c$1.kind === "linear") c$1.terms.forEach((term) => add(term.entity));
+	return ids;
+}
+/** Authoring path: plan only selected nodes; route against the complete fixed scene. */
+function runPartialLayout(input, options, context, arrange, phase = "selection") {
+	const scope = context.scope;
+	if (scope.mode !== "partial" && scope.mode !== "route-only") throw new Error("Expected authoring scope");
+	const selectedNodes = new Set(scope.mode === "partial" ? scope.nodeIds ?? [] : []);
+	const selectedEdges = new Set(scope.mode === "route-only" ? scope.edgeIds ?? input.edges.map((e) => e.id) : scope.edgeIds ?? []);
+	const geometry = scope.mode === "partial" ? scope.edgeGeometry ?? "both" : "routes";
+	const routing = scope.mode === "partial" ? scope.routing ?? "affected" : "selected";
+	const constraints = context.constraints ?? [];
+	const constrainedLabels = labelReferences(constraints);
+	for (const [ids, entities] of [[selectedNodes, input.nodes], [selectedEdges, input.edges]]) {
+		const known = new Set(entities.map((e) => e.id));
+		for (const id of ids) if (!known.has(id)) throw new LayoutError(`Unknown selected entity: ${id}`, "INVALID_SELECTION");
+	}
+	const containers = new Set(input.nodes.flatMap((n) => n.parentId == null ? [] : [n.parentId]));
+	if ([...selectedNodes].some((id) => containers.has(id))) throw new UnsupportedLayoutError("Authoring layout cannot move containers; select leaf nodes or use full layout without geometry constraints");
+	const previousNodes = new Map(scope.previous?.nodes.map((n) => [n.id, n]));
+	const previousEdges = new Map(scope.previous?.edges.map((e) => [e.id, e]));
+	const missing = (id) => {
+		throw new LayoutError(`Fixed entity ${id} requires finite geometry in graph or previous`, "MISSING_GEOMETRY");
+	};
+	let nodes = input.nodes.map((node) => {
+		const previous = previousNodes.get(node.id);
+		const size = getNodeSize(node, options);
+		const rect = { ...node };
+		for (const key of geometryKeys) {
+			const value = node[key] ?? previous?.[key];
+			if (value !== void 0 && (!finite(value) || (key === "width" || key === "height") && value < 0)) missing(node.id);
+			rect[key] = value ?? (selectedNodes.has(node.id) ? key === "width" || key === "height" ? size[key] : 0 : missing(node.id));
+			if (!finite(rect[key]) || (key === "width" || key === "height") && rect[key] < 0) missing(node.id);
+		}
+		return rect;
+	});
+	let edges = input.edges.map((edge) => {
+		const previous = previousEdges.get(edge.id);
+		const absentLabel = !edge.label && (edge.width ?? previous?.width ?? 0) === 0 && (edge.height ?? previous?.height ?? 0) === 0;
+		const rect = {
+			...edge,
+			...edge.points === void 0 && previous?.points !== void 0 ? { points: previous.points } : {},
+			...edge.routing === void 0 && previous?.routing !== void 0 ? { routing: previous.routing } : {}
+		};
+		for (const key of geometryKeys) {
+			const value = edge[key] ?? previous?.[key];
+			if (value !== void 0 && (!finite(value) || (key === "width" || key === "height") && value < 0)) missing(edge.id);
+			rect[key] = value ?? (selectedEdges.has(edge.id) && geometry !== "routes" && (key === "x" || key === "y") || absentLabel ? 0 : missing(edge.id));
+		}
+		return rect;
+	});
+	const authored = {
+		...input,
+		direction: options.direction ?? input.direction ?? scope.previous?.direction ?? "down",
+		nodes,
+		edges
+	};
+	const baseline = worldGeometry(authored);
+	nodes = baseline.nodes;
+	edges = baseline.edges;
+	let graph = baseline;
+	const byId = new Map(nodes.map((n) => [n.id, n]));
+	const ancestorSets = /* @__PURE__ */ new Map();
+	const ancestors = (id) => {
+		const cached = ancestorSets.get(id);
+		if (cached) return cached;
+		const result = /* @__PURE__ */ new Set();
+		let parent = byId.get(id)?.parentId;
+		while (parent != null && !result.has(parent)) {
+			result.add(parent);
+			parent = byId.get(parent)?.parentId;
+		}
+		ancestorSets.set(id, result);
+		return result;
+	};
+	for (const node of nodes) ancestors(node.id);
+	const direction = options.direction ?? input.direction ?? scope.previous?.direction ?? "down";
+	const gap = options.spacing?.node ?? 20;
+	if (!finite(gap) || gap < 0) throw new LayoutError("Spacing must be finite and non-negative", "INVALID_OPTIONS");
+	context.throwIfAborted();
+	if (selectedNodes.size && phase === "selection") {
+		const groups = /* @__PURE__ */ new Map();
+		for (const node of nodes) if (selectedNodes.has(node.id)) {
+			const group = groups.get(node.parentId ?? null) ?? [];
+			group.push(node);
+			groups.set(node.parentId ?? null, group);
+		}
+		const placed = new Map(nodes.map((n) => [n.id, n]));
+		for (const group of groups.values()) {
+			const ids = new Set(group.map((n) => n.id));
+			const local = arrange({
+				...input,
+				initialNodeId: void 0,
+				nodes: group.map((n) => ({
+					...n,
+					parentId: void 0,
+					initialNodeId: void 0
+				})),
+				edges: edges.filter((e) => ids.has(e.sourceId) && ids.has(e.targetId))
+			}, {
+				...options,
+				padding: 0
+			});
+			const anchorX = Math.min(...group.map((n) => n.x));
+			const anchorY = Math.min(...group.map((n) => n.y));
+			const localX = Math.min(...local.nodes.map((n) => n.x));
+			const localY = Math.min(...local.nodes.map((n) => n.y));
+			const proposed = group.map((n) => {
+				const p = local.nodes.find((item) => item.id === n.id);
+				return {
+					...n,
+					x: p.x - localX + anchorX,
+					y: p.y - localY + anchorY
+				};
+			});
+			const obstacles = [...placed.values()].filter((n) => !ids.has(n.id));
+			const fixedLabels = edges.filter((e) => geometry === "routes" || !selectedEdges.has(e.id));
+			const candidates = [{
+				x: 0,
+				y: 0
+			}];
+			candidateGeneration: for (const obstacle of [...obstacles, ...fixedLabels]) for (const node of proposed) {
+				context.throwIfAborted();
+				if (candidates.length + 4 > 2e3) break candidateGeneration;
+				candidates.push({
+					x: obstacle.x + obstacle.width + gap - node.x,
+					y: 0
+				}, {
+					x: obstacle.x - gap - node.x - node.width,
+					y: 0
+				}, {
+					x: 0,
+					y: obstacle.y + obstacle.height + gap - node.y
+				}, {
+					x: 0,
+					y: obstacle.y - gap - node.y - node.height
+				});
+			}
+			candidates.sort((a, b) => Math.abs(a.x) + Math.abs(a.y) - Math.abs(b.x) - Math.abs(b.y));
+			let comparisons = 0;
+			const budget = () => {
+				if (++comparisons % 128 === 0) context.throwIfAborted();
+				return comparisons <= 1e5;
+			};
+			const fits = (offset$1) => {
+				context.throwIfAborted();
+				return proposed.every((n) => {
+					if (!budget()) return false;
+					const translated = {
+						...n,
+						x: n.x + offset$1.x,
+						y: n.y + offset$1.y
+					};
+					const parent = n.parentId == null ? void 0 : placed.get(n.parentId);
+					if (parent && (translated.x < parent.x || translated.y < parent.y || translated.x + translated.width > parent.x + parent.width || translated.y + translated.height > parent.y + parent.height)) return false;
+					return fixedLabels.every((label) => budget() && !overlaps(translated, label, gap)) && obstacles.every((o) => budget() && (ancestors(n.id).has(o.id) || ancestors(o.id).has(n.id) || !overlaps(translated, o, gap)));
+				});
+			};
+			const offset = candidates.find((candidate) => comparisons <= 1e5 && fits(candidate));
+			if (offset) for (const n of proposed) placed.set(n.id, {
+				...n,
+				x: n.x + offset.x,
+				y: n.y + offset.y
+			});
+			else context.diagnostics.push({
+				severity: "warning",
+				code: "PLACEMENT_BLOCKED",
+				message: "No placement found within the search budget without moving fixed geometry; preserved selected positions",
+				entityIds: [...ids],
+				geometry: "node"
+			});
+		}
+		graph = {
+			...graph,
+			nodes: nodes.map((n) => placed.get(n.id))
+		};
+	}
+	graph = solveGeometryConstraints(graph, constraints, selectedNodes, geometry === "routes" ? /* @__PURE__ */ new Set() : selectedEdges, context.diagnostics);
+	const moved = graph.nodes.filter((n) => !samePosition(n, byId.get(n.id)));
+	const movedIds = new Set(moved.map((n) => n.id));
+	const resultNodes = new Map(graph.nodes.map((n) => [n.id, n]));
+	const automatic = /* @__PURE__ */ new Set();
+	const affected = (edge) => movedIds.has(edge.sourceId) || movedIds.has(edge.targetId) || moved.some((n) => !ancestors(edge.sourceId).has(n.id) && !ancestors(edge.targetId).has(n.id) && (routeCrosses(edge.points, n) || overlaps(edge, n) || edge.routing === "splines" && edge.points?.length && overlaps(n, {
+		x: Math.min(...edge.points.map((p) => p.x)),
+		y: Math.min(...edge.points.map((p) => p.y)),
+		width: Math.max(...edge.points.map((p) => p.x)) - Math.min(...edge.points.map((p) => p.x)),
+		height: Math.max(...edge.points.map((p) => p.y)) - Math.min(...edge.points.map((p) => p.y))
+	})));
+	const edgeById = new Map(graph.edges.map((e) => [e.id, e]));
+	for (const constraint of constraints) if (constraint.kind === "waypoint") {
+		if (!finite(constraint.point.x) || !finite(constraint.point.y) || !edgeById.has(constraint.edgeId)) throw new LayoutError(`${constraint.id}: invalid waypoint`, "INVALID_CONSTRAINT");
+	}
+	graph = {
+		...graph,
+		edges: graph.edges.map((edge) => {
+			context.throwIfAborted();
+			const needsRepair = affected(edge);
+			const allowed = selectedEdges.has(edge.id) || routing === "affected" && needsRepair;
+			const waypoints = constraints.filter((c$1) => c$1.kind === "waypoint" && c$1.edgeId === edge.id);
+			const routeAllowed = phase === "constraints" ? needsRepair || waypoints.some((c$1) => c$1.kind === "waypoint" && (edge.routing === "splines" || !onRoute(c$1.point, edge.points))) : allowed && geometry !== "labels";
+			const labelAllowed = allowed && geometry !== "routes" && !constrainedLabels.has(edge.id);
+			const source = resultNodes.get(edge.sourceId);
+			const target = resultNodes.get(edge.targetId);
+			let next = edge;
+			let routeFailed = false;
+			if (needsRepair && !routeAllowed) context.diagnostics.push({
+				severity: "warning",
+				code: "ROUTE_REPAIR_REQUIRED",
+				message: `Edge ${edge.id} needs routing outside the permitted geometry`,
+				entityIds: [edge.id],
+				geometry: "routes"
+			});
+			if (routeAllowed) {
+				if (options.settings?.edgeRouting === "SPLINES" || options.strategies?.routeEdges) throw new UnsupportedLayoutError("Partial layout supports its built-in orthogonal router only");
+				const ancestorIds = new Set([...ancestors(source.id), ...ancestors(target.id)]);
+				const nodeObstacles = graph.nodes.filter((n) => !ancestorIds.has(n.id)).map((n) => n.id === source.id || n.id === target.id ? n : {
+					...n,
+					x: n.x - 1,
+					y: n.y - 1,
+					width: n.width + 2,
+					height: n.height + 2
+				});
+				const labelObstacles = [...edgeById.values()].filter((e) => e.id !== edge.id && e.width > 0 && e.height > 0);
+				const required = waypoints.filter((c$1) => (c$1.strength ?? "required") === "required");
+				const accepted = new Set(required.map((c$1) => c$1.id));
+				const route = () => routeOrthogonal(edge, source, target, direction, [...nodeObstacles, ...labelObstacles], waypoints.filter((c$1) => c$1.kind === "waypoint" && accepted.has(c$1.id)).map((c$1) => c$1.kind === "waypoint" ? c$1.point : {
+					x: 0,
+					y: 0
+				}), () => context.throwIfAborted());
+				let points = route();
+				const priorities = {
+					strong: 3,
+					medium: 2,
+					weak: 1,
+					required: 4
+				};
+				for (const preference of waypoints.filter((c$1) => !accepted.has(c$1.id)).sort((a, b) => priorities[b.strength ?? "required"] - priorities[a.strength ?? "required"])) {
+					accepted.add(preference.id);
+					const candidate = route();
+					if (candidate) points = candidate;
+					else accepted.delete(preference.id);
+				}
+				if (points) next = {
+					...next,
+					points,
+					routing: "orthogonal"
+				};
+				else {
+					routeFailed = true;
+					context.diagnostics.push({
+						severity: "warning",
+						code: "ROUTE_BLOCKED",
+						message: `No route found for ${edge.id} within the search budget; preserved the route`,
+						entityIds: [edge.id],
+						geometry: "routes"
+					});
+				}
+			}
+			for (const constraint of waypoints) if (constraint.kind === "waypoint" && (routeFailed || next.routing === "splines" || !onRoute(constraint.point, next.points))) {
+				if ((constraint.strength ?? "required") === "required") constraintFailure(constraint, "route cannot pass through the waypoint within the permitted geometry");
+				context.diagnostics.push({
+					severity: "warning",
+					code: "CONSTRAINT_VIOLATION",
+					message: `Waypoint ${constraint.id} could not be satisfied`,
+					entityIds: [edge.id],
+					constraintIds: [constraint.id],
+					geometry: "routes"
+				});
+			}
+			if (labelAllowed && (next.points?.length ?? 0) >= 2) {
+				const midpoint = getPolylineMidpoint(next.points ?? []);
+				const candidates = [
+					{
+						x: midpoint.x - next.width / 2,
+						y: midpoint.y - next.height / 2
+					},
+					{
+						x: midpoint.x - next.width / 2,
+						y: midpoint.y - next.height - gap
+					},
+					{
+						x: midpoint.x - next.width / 2,
+						y: midpoint.y + gap
+					},
+					{
+						x: midpoint.x + gap,
+						y: midpoint.y - next.height / 2
+					},
+					{
+						x: midpoint.x - next.width - gap,
+						y: midpoint.y - next.height / 2
+					}
+				];
+				const parentIds = new Set([...ancestors(source.id), ...ancestors(target.id)]);
+				for (const obstacle of [...graph.nodes, ...edgeById.values()]) candidates.push({
+					x: midpoint.x - next.width / 2,
+					y: obstacle.y - next.height - gap
+				}, {
+					x: midpoint.x - next.width / 2,
+					y: obstacle.y + obstacle.height + gap
+				}, {
+					x: obstacle.x - next.width - gap,
+					y: midpoint.y - next.height / 2
+				}, {
+					x: obstacle.x + obstacle.width + gap,
+					y: midpoint.y - next.height / 2
+				});
+				candidates.sort((a, b) => Math.hypot(a.x + next.width / 2 - midpoint.x, a.y + next.height / 2 - midpoint.y) - Math.hypot(b.x + next.width / 2 - midpoint.x, b.y + next.height / 2 - midpoint.y));
+				const chosen = candidates.find((p) => {
+					const rect = {
+						...next,
+						...p
+					};
+					return !graph.nodes.some((n) => !parentIds.has(n.id) && overlaps(rect, n)) && ![...edgeById.values()].some((e) => e.id !== edge.id && overlaps(rect, e));
+				});
+				if (chosen) next = {
+					...next,
+					...chosen
+				};
+				else context.diagnostics.push({
+					severity: "warning",
+					code: "LABEL_PLACEMENT_BLOCKED",
+					message: `No clear label position found for ${edge.id}; preserved label position`,
+					entityIds: [edge.id],
+					geometry: "labels"
+				});
+			}
+			if (geometry === "labels" && allowed && !samePosition(next, baseline.edges.find((e) => e.id === edge.id))) context.diagnostics.push({
+				severity: "info",
+				code: "ROUTE_PRESERVED",
+				message: `Route for ${edge.id} was preserved; label attachment may need repair`,
+				entityIds: [edge.id],
+				geometry: "routes"
+			});
+			edgeById.set(edge.id, next);
+			if (!selectedEdges.has(edge.id) && (next.x !== edge.x || next.y !== edge.y || next.routing !== edge.routing || JSON.stringify(next.points) !== JSON.stringify(edge.points))) automatic.add(edge.id);
+			return next;
+		})
+	};
+	if (automatic.size) context.diagnostics.push({
+		severity: "info",
+		code: "AFFECTED_EDGES_UPDATED",
+		message: "Repaired geometry affected by moved nodes",
+		entityIds: [...automatic]
+	});
+	for (const node of graph.nodes) if (selectedNodes.has(node.id) || node.parentId != null && movedIds.has(node.parentId)) {
+		const parent = node.parentId == null ? void 0 : resultNodes.get(node.parentId);
+		if (parent && (node.x < parent.x || node.y < parent.y || node.x + node.width > parent.x + parent.width || node.y + node.height > parent.y + parent.height)) context.diagnostics.push({
+			severity: "warning",
+			code: "CONTAINMENT_VIOLATION",
+			message: `Node ${node.id} extends outside its fixed parent`,
+			entityIds: [node.id, parent.id],
+			geometry: "node"
+		});
+		if (graph.nodes.some((other) => other.id !== node.id && !ancestors(node.id).has(other.id) && !ancestors(other.id).has(node.id) && overlaps(node, other))) context.diagnostics.push({
+			severity: "warning",
+			code: "NODE_OVERLAP",
+			message: `Node ${node.id} overlaps another node`,
+			entityIds: [node.id],
+			geometry: "node"
+		});
+	}
+	for (const edge of graph.edges) {
+		const before = baseline.edges.find((e) => e.id === edge.id);
+		if (!samePosition(edge, before)) {
+			const containerIds = new Set([...ancestors(edge.sourceId), ...ancestors(edge.targetId)]);
+			const collisions = [...graph.nodes.filter((n) => !containerIds.has(n.id) && overlaps(edge, n)), ...graph.edges.filter((other) => other.id !== edge.id && overlaps(edge, other))];
+			if (collisions.length) context.diagnostics.push({
+				severity: "warning",
+				code: "LABEL_OVERLAP",
+				message: `Label ${edge.id} overlaps fixed or constrained geometry`,
+				entityIds: [edge.id, ...collisions.map((e) => e.id)],
+				geometry: "labels"
+			});
+			for (const other of graph.edges) if (other.id !== edge.id && routeCrosses(other.points, edge) && !routeCrosses(other.points, before)) context.diagnostics.push({
+				severity: "warning",
+				code: "ROUTE_REPAIR_REQUIRED",
+				message: `Route ${other.id} crosses the moved label ${edge.id}`,
+				entityIds: [other.id, edge.id],
+				geometry: "routes"
+			});
+		}
+		if (geometry === "routes" && routeCrosses(before.points, before) && !routeCrosses(edge.points, edge)) context.diagnostics.push({
+			severity: "warning",
+			code: "LABEL_REPAIR_REQUIRED",
+			message: `Label ${edge.id} is no longer attached to its route`,
+			entityIds: [edge.id],
+			geometry: "labels"
+		});
+	}
+	return nativeGeometry(graph, authored);
+}
+
 //#endregion
 //#region src/layered/separate-exterior-labels.ts
 /** Assigns collision-free cross-axis lanes to inline labels and their route tracks. */
@@ -3829,7 +6096,7 @@ function separateExteriorLabels({ edges, nodeRects, direction, spacing, settings
 	const flowEnd = (rect) => horizontalFlow ? rect.x + rect.width : rect.y + rect.height;
 	const crossStart = (rect) => horizontalFlow ? rect.y : rect.x;
 	const crossEnd = (rect) => horizontalFlow ? rect.y + rect.height : rect.x + rect.width;
-	const overlaps = (left, right) => flowStart(left) < flowEnd(right) && flowEnd(left) > flowStart(right) && crossStart(left) < crossEnd(right) && crossEnd(left) > crossStart(right);
+	const overlaps$1 = (left, right) => flowStart(left) < flowEnd(right) && flowEnd(left) > flowStart(right) && crossStart(left) < crossEnd(right) && crossEnd(left) > crossStart(right);
 	const labelRectByEdgeId = new Map(edges.filter((edge) => edge.width > 0 && edge.height > 0).map((edge) => [String(edge.id), {
 		x: edge.x,
 		y: edge.y,
@@ -3914,14 +6181,14 @@ function separateExteriorLabels({ edges, nodeRects, direction, spacing, settings
 					x: labelRect.x + delta
 				};
 				const candidateTrackCross = exteriorTrack.cross + delta;
-				return obstacles.every((obstacle) => !overlaps(candidateLabel, obstacle)) && nodeRects.every((nodeRect) => !lineIntersects(nodeRect, candidateTrackCross, exteriorTrack.flowStart) && !lineIntersects(nodeRect, candidateTrackCross, exteriorTrack.flowEnd));
+				return obstacles.every((obstacle) => !overlaps$1(candidateLabel, obstacle)) && nodeRects.every((nodeRect) => !lineIntersects(nodeRect, candidateTrackCross, exteriorTrack.flowStart) && !lineIntersects(nodeRect, candidateTrackCross, exteriorTrack.flowEnd));
 			});
 			if (candidate === void 0) continue;
 			totalDelta = candidate - labelCrossStart;
 			if (horizontalFlow) labelRect.y += totalDelta;
 			else labelRect.x += totalDelta;
 		} else while (true) {
-			const blockers = obstacles.filter((rect) => overlaps(labelRect, rect));
+			const blockers = obstacles.filter((rect) => overlaps$1(labelRect, rect));
 			if (blockers.length === 0) break;
 			const delta = (lowSide ? Math.min(...blockers.map(crossStart)) - spacing - (horizontalFlow ? edge.height : edge.width) : Math.max(...blockers.map(crossEnd)) + spacing) - crossStart(labelRect);
 			totalDelta += delta;
@@ -7843,7 +10110,7 @@ function adjustUnzippedSinkRoutes(graph, routes, direction, edgeNodeSpacing, edg
 	}
 	return result;
 }
-function getNodeSize(node, options) {
+function getNodeSize$1(node, options) {
 	const measured = options.measure?.(node);
 	if (measured) return measured;
 	return {
@@ -7884,7 +10151,7 @@ function runWrappedPathPipeline(graph, options) {
 		currentId = targets[0];
 	}
 	if (orderedIds.length !== graph.nodes.length) return void 0;
-	const sizes = new Map(graph.nodes.map((node) => [node.id, getNodeSize(node, options)]));
+	const sizes = new Map(graph.nodes.map((node) => [node.id, getNodeSize$1(node, options)]));
 	const maximumWidth = Math.max(...[...sizes.values()].map((size) => size.width));
 	const maximumHeight = Math.max(...[...sizes.values()].map((size) => size.height));
 	if ([...sizes.values()].some((size) => size.width !== maximumWidth || size.height !== maximumHeight)) return;
@@ -8060,7 +10327,7 @@ function runWrappedMultiEdgePipeline(graph, options) {
 	}
 	if (nodeIdByRank.size !== maximumRank + 1) return void 0;
 	const orderedIds = Array.from({ length: maximumRank + 1 }, (_, index) => nodeIdByRank.get(index));
-	const sizes = new Map(graph.nodes.map((node) => [node.id, getNodeSize(node, options)]));
+	const sizes = new Map(graph.nodes.map((node) => [node.id, getNodeSize$1(node, options)]));
 	const layerSpacing = options.spacing?.layer ?? options.settings?.["spacing.baseValue"] ?? 20;
 	const nodeSpacing = options.spacing?.node ?? options.settings?.["spacing.baseValue"] ?? 20;
 	const widths = orderedIds.map((id) => sizes.get(id).width + layerSpacing);
@@ -8285,8 +10552,8 @@ function runCommentBoxPipeline(graph, options, context) {
 	const horizontal = direction === "left" || direction === "right";
 	const commentNodeSpacing = Number(options.settings?.["spacing.commentNode"] ?? 10);
 	const commentCommentSpacing = Number(options.settings?.["spacing.commentComment"] ?? 10);
-	const targetSize = getNodeSize(target, options);
-	const commentSizes = comments.map((comment) => getNodeSize(comment, options));
+	const targetSize = getNodeSize$1(target, options);
+	const commentSizes = comments.map((comment) => getNodeSize$1(comment, options));
 	const beforeIndexes = comments.flatMap((_, index) => index % 2 === 0 ? [index] : []);
 	const afterIndexes = comments.flatMap((_, index) => index % 2 === 1 ? [index] : []);
 	const rowFlowSize = (indexes) => indexes.reduce((sum, index) => sum + (horizontal ? commentSizes[index].width : commentSizes[index].height), 0) + Math.max(0, indexes.length - 1) * commentCommentSpacing;
@@ -8312,7 +10579,7 @@ function runCommentBoxPipeline(graph, options, context) {
 		edges: graph.edges.filter((edge) => !commentIds.has(edge.sourceId) && !commentIds.has(edge.targetId))
 	}, {
 		...options,
-		measure: (node) => node.id === targetId ? groupSize : options.measure?.(node) ?? getNodeSize(node, options)
+		measure: (node) => node.id === targetId ? groupSize : options.measure?.(node) ?? getNodeSize$1(node, options)
 	}, context);
 	const groupRect = base.nodes.find((node) => node.id === targetId);
 	if (!groupRect) return void 0;
@@ -8567,126 +10834,16 @@ function runSeparatedComponents(graph, options, context) {
 	};
 }
 function runCompoundPipeline(graph, options, context) {
-	const nodes = graph.nodes.map((node) => ({ ...node }));
-	const nodeById = new Map(nodes.map((node) => [node.id, node]));
-	const depth = (node) => {
-		let value = 0;
-		let parentId = node.parentId;
-		const seen = /* @__PURE__ */ new Set();
-		while (parentId != null && !seen.has(parentId)) {
-			seen.add(parentId);
-			value++;
-			parentId = nodeById.get(parentId)?.parentId;
-		}
-		return value;
-	};
-	const parentIds = [...new Set(nodes.flatMap((node) => node.parentId == null ? [] : [node.parentId]))].sort((left, right) => depth(nodeById.get(right)) - depth(nodeById.get(left)));
-	const edgeById = new Map(graph.edges.map((edge) => [edge.id, { ...edge }]));
-	const padding = typeof options.padding === "number" ? options.padding : 12;
-	const layoutSiblings = (parentId) => {
-		const siblings = nodes.filter((node) => (node.parentId ?? null) === parentId);
-		if (siblings.length === 0) return;
-		const siblingIds = new Set(siblings.map((node) => node.id));
-		const siblingEdges = graph.edges.filter((edge) => siblingIds.has(edge.sourceId) && siblingIds.has(edge.targetId));
-		const flatNodes = siblings.map((node) => ({
-			...node,
-			parentId: null
-		}));
-		const result = runLayeredPipeline({
-			...graph,
-			nodes: flatNodes,
-			edges: siblingEdges
-		}, options, context);
-		for (const laidOut of result.nodes) {
-			const node = nodeById.get(laidOut.id);
-			if (!node) continue;
-			Object.assign(node, laidOut, { parentId });
-		}
-		for (const edge of result.edges) edgeById.set(edge.id, edge);
-	};
-	for (const parentId of parentIds) {
-		layoutSiblings(parentId);
-		const parent = nodeById.get(parentId);
-		if (!parent) continue;
-		const children = nodes.filter((node) => node.parentId === parentId);
-		const right = Math.max(0, ...children.map((node) => (node.x ?? 0) + (node.width ?? 0)));
-		const bottom = Math.max(0, ...children.map((node) => (node.y ?? 0) + (node.height ?? 0)));
-		parent.width = Math.max(parent.width ?? 0, right + padding);
-		parent.height = Math.max(parent.height ?? 0, bottom + padding);
-	}
-	const roots = nodes.filter((node) => node.parentId == null);
-	if (roots.length === 1 && parentIds.includes(roots[0].id)) Object.assign(roots[0], {
-		x: 0,
-		y: 0
+	const result = layoutCompounds(graph, options, (scope, local) => runLayeredPipeline(scope, local, context));
+	for (const route of result.compoundRoutes.values()) for (const diagnostic of route.diagnostics) context?.diagnostics.push({
+		severity: "warning",
+		code: diagnostic.code,
+		message: diagnostic.message,
+		entityIds: [route.edgeId],
+		phase: "compound-routing",
+		geometry: "routes"
 	});
-	else layoutSiblings(null);
-	const absoluteRect = (id) => {
-		const node = nodeById.get(id);
-		if (!node) return {
-			x: 0,
-			y: 0,
-			width: 0,
-			height: 0
-		};
-		let x = node.x ?? 0;
-		let y = node.y ?? 0;
-		let parentId = node.parentId;
-		const seen = /* @__PURE__ */ new Set();
-		while (parentId != null && !seen.has(parentId)) {
-			seen.add(parentId);
-			const parent = nodeById.get(parentId);
-			if (!parent) break;
-			x += parent.x ?? 0;
-			y += parent.y ?? 0;
-			parentId = parent.parentId;
-		}
-		return {
-			x,
-			y,
-			width: node.width ?? 0,
-			height: node.height ?? 0
-		};
-	};
-	for (const edge of graph.edges) {
-		if (edgeById.get(edge.id)?.points !== void 0) continue;
-		const source = absoluteRect(edge.sourceId);
-		const target = absoluteRect(edge.targetId);
-		const start = {
-			x: source.x + source.width,
-			y: source.y + source.height / 2
-		};
-		const end = {
-			x: target.x,
-			y: target.y + target.height / 2
-		};
-		const track = (start.x + end.x) / 2;
-		const points = [
-			start,
-			{
-				x: track,
-				y: start.y
-			},
-			{
-				x: track,
-				y: end.y
-			},
-			end
-		];
-		edgeById.set(edge.id, {
-			...edge,
-			points,
-			x: track,
-			y: (start.y + end.y) / 2,
-			width: edge.width ?? 0,
-			height: edge.height ?? 0,
-			routing: "orthogonal"
-		});
-	}
-	return {
-		...graph,
-		nodes,
-		edges: graph.edges.map((edge) => edgeById.get(edge.id) ?? edge)
-	};
+	return result;
 }
 function runLayeredPipeline(graph, options, context) {
 	if (options.settings?.noLayout) return {
@@ -8750,7 +10907,7 @@ function runLayeredPipeline(graph, options, context) {
 	}
 	const input = {
 		graph,
-		sizes: new Map(graph.nodes.map((node) => [node.id, getNodeSize(node, options)])),
+		sizes: new Map(graph.nodes.map((node) => [node.id, getNodeSize$1(node, options)])),
 		direction,
 		spacing: {
 			node: options.spacing?.node ?? options.settings?.["spacing.baseValue"] ?? 20,
@@ -9575,22 +11732,39 @@ function runLayeredPipeline(graph, options, context) {
 * custom phase strategies, and all layered edge-routing styles.
 */
 function getLayeredLayout(graph, options = {}) {
-	return runLayeredPipeline(graph, options);
+	const result = runLayeredPipeline(graph, options);
+	return {
+		...result,
+		compoundGeometry: result.compoundGeometry ?? /* @__PURE__ */ new Map(),
+		compoundRoutes: result.compoundRoutes ?? /* @__PURE__ */ new Map()
+	};
 }
 const layeredAlgorithm = {
 	id: "layered",
 	capabilities: {
 		full: true,
 		incremental: false,
-		partial: false,
-		routeOnly: false,
+		partial: true,
+		routeOnly: true,
+		constraints: true,
 		hierarchy: true,
 		ports: true
 	},
 	layout(graph, options, context) {
-		return runLayeredPipeline(graph, options ?? {}, context);
+		if (context.scope.mode === "partial" || context.scope.mode === "route-only") return context.measurePhase("partial-layout", () => runPartialLayout(graph, options ?? {}, context, getLayeredLayout));
+		if (context.constraints?.length && graph.nodes.some((node) => node.parentId != null)) throw new UnsupportedLayoutError("Full layout with geometry constraints does not support containers; use partial leaf constraints or full layout without geometry constraints");
+		const result = runLayeredPipeline(graph, options ?? {}, context);
+		if (!context.constraints?.length) return result;
+		return context.measurePhase("constraints", () => runPartialLayout(result, options ?? {}, {
+			...context,
+			scope: {
+				mode: "partial",
+				nodeIds: result.nodes.map((n) => n.id),
+				edgeIds: [...labelReferences(context.constraints ?? [])]
+			}
+		}, getLayeredLayout, "constraints"));
 	}
 };
 
 //#endregion
-export { minimizeCrossingsWithBarycenter as A, LayoutError as B, breakCyclesGreedilyByModelOrder as C, breakCyclesWithModelOrderDepthFirstSearch as D, breakCyclesWithModelOrderBreadthFirstSearch as E, placePorts as F, routeEdgesOrthogonally as I, routeEdgesWithPolylines as L, minimizeCrossingsWithModelOrder as M, placeNodesInLayers as N, getPolylineMidpoint as O, placeNodesInteractively as P, routeEdgesWithSplines as R, breakCyclesGreedily as S, breakCyclesWithDepthFirstSearch as T, UnsupportedLayoutError as V, assignLayersInteractively as _, elkLayeredEnumValues as a, breakCyclesByStronglyConnectedConnectivity as b, placeNodesWithLinearSegments as c, assignLayersWithMinWidth as d, assignLayersWithNetworkSimplex as f, assignLayersByLongestPathToSink as g, assignLayersByLongestPath as h, toElkLayeredOptions as i, minimizeCrossingsWithMedian as j, minimizeCrossingsInteractively as k, placeNodesWithBrandesKoepf as l, assignLayersByDepthFirstModelOrder as m, layeredAlgorithm as n, elkLayeredOptionDefinitions as o, assignLayersByBreadthFirstModelOrder as p, fromElkLayeredOptionId as r, placeNodesWithNetworkSimplex as s, getLayeredLayout as t, assignLayersWithStretchWidth as u, assignLayersWithCoffmanGraham as v, breakCyclesInteractively as w, breakCyclesByStronglyConnectedNodeType as x, breakCyclesByModelOrder as y, JavaRandom as z };
+export { minimizeCrossingsInteractively as A, JavaRandom as B, breakCyclesGreedily as C, breakCyclesWithModelOrderBreadthFirstSearch as D, breakCyclesWithDepthFirstSearch as E, placeNodesInteractively as F, placePorts as I, routeEdgesOrthogonally as L, minimizeCrossingsWithMedian as M, minimizeCrossingsWithModelOrder as N, breakCyclesWithModelOrderDepthFirstSearch as O, placeNodesInLayers as P, routeEdgesWithPolylines as R, breakCyclesByStronglyConnectedNodeType as S, breakCyclesInteractively as T, assignLayersByLongestPathToSink as _, elkLayeredEnumValues as a, breakCyclesByModelOrder as b, placeNodesWithLinearSegments as c, assignLayersWithMinWidth as d, assignLayersWithNetworkSimplex as f, assignLayersByLongestPath as g, assignLayersByDepthFirstModelOrder as h, toElkLayeredOptions as i, minimizeCrossingsWithBarycenter as j, getPolylineMidpoint as k, placeNodesWithBrandesKoepf as l, assignLayersByBreadthFirstModelOrder as m, layeredAlgorithm as n, elkLayeredOptionDefinitions as o, c as p, fromElkLayeredOptionId as r, placeNodesWithNetworkSimplex as s, getLayeredLayout as t, assignLayersWithStretchWidth as u, assignLayersInteractively as v, breakCyclesGreedilyByModelOrder as w, breakCyclesByStronglyConnectedConnectivity as x, assignLayersWithCoffmanGraham as y, routeEdgesWithSplines as z };