@mark1russell7/highways 0.9.1 → 0.9.2

package/build/index.js

@@ -402,6 +402,68 @@ function fixedPortPoint(node, end) {
 		y: node.box.y + at.y
 	};
 }
+/** This function throws a `RangeError` when the parent of a node names no node, or when the parents of a node make a cycle. */
+function checkParents(graph, byId = nodeIndex(graph)) {
+	const done = /* @__PURE__ */ new Set();
+	for (const n of graph.nodes) {
+		const seen = /* @__PURE__ */ new Set();
+		for (let m = n; m?.parent !== void 0 && !done.has(m.id);) {
+			seen.add(m.id);
+			const p = byId.get(m.parent);
+			if (!p) throw new RangeError(`The parent "${m.parent}" of the node "${m.id}" names no node of the graph.`);
+			if (seen.has(p.id)) throw new RangeError(`The parents of the node "${n.id}" make a cycle through the node "${p.id}".`);
+			m = p;
+		}
+		for (const id of seen) done.add(id);
+	}
+}
+/** This function tells if the node `frame` holds the node `id`, at any depth. A node does not hold itself. */
+function holds$3(byId, frame, id) {
+	for (let p = byId.get(id)?.parent; p !== void 0; p = byId.get(p)?.parent) if (p === frame) return true;
+	return false;
+}
+/**
+* This function checks the parents of a graph (`checkParents`), and takes its inner edges out.
+* An inner edge of the frame F has a plug of F (`End.port`) at one end. F holds the node at the other end.
+* The graph that it gives keeps each node and the other edges. A graph without `parent` comes back as the same object, with no inner edge.
+*/
+function splitFrames(graph) {
+	if (!graph.nodes.some((n) => n.parent !== void 0)) return {
+		graph,
+		inner: []
+	};
+	const byId = nodeIndex(graph);
+	checkParents(graph, byId);
+	const inner = [];
+	const edges = graph.edges.filter((e) => {
+		if (e.source.port !== void 0 && holds$3(byId, e.source.node, e.target.node)) inner.push({
+			edge: e,
+			frame: e.source.node,
+			plug: "source"
+		});
+		else if (e.target.port !== void 0 && holds$3(byId, e.target.node, e.source.node)) inner.push({
+			edge: e,
+			frame: e.target.node,
+			plug: "target"
+		});
+		else return true;
+		return false;
+	});
+	return {
+		graph: inner.length === 0 ? graph : {
+			...graph,
+			edges
+		},
+		inner
+	};
+}
+/**
+* This function gives the graph of a router without frames. It has the plugs of `resolvePorts`, and no inner edges (`splitFrames`).
+* Each router except `corners` uses it at the start of `route`. So an inner edge gets no route from such a router.
+*/
+function outerGraph(graph) {
+	return splitFrames(resolvePorts(graph)).graph;
+}
 // src/fixtures.ts
 /** This function gives a seeded random source with values in [0, 1) (mulberry32). */
 function rng(seed) {
@@ -5036,20 +5098,181 @@ function sidePlugs(ways, s, es, t, et, options = {}) {
 	if (!way) return [ps, pt];
 	return [from[way.from].plug, to[way.to].plug];
 }
+// src/routers/frames.ts
+/** The tiny gap between the bounds and the band of a wall, so that a way along the bounds stays clear of the wall. */
+const EPS$5 = 1e-6;
+/**
+* This function gives the inner routes of the inner edges (`splitFrames`). Each route stays in the bounds of its frame:
+* the box of the frame, smaller by `frameInset`. It goes around the other nodes of the frame.
+* It leaves the plug of the frame into the frame, along the normal of the wall. Each route has the id of its frame in `frame`.
+*/
+function frameRoutes(graph, inner, options) {
+	const byId = nodeIndex(graph);
+	const children = /* @__PURE__ */ new Map();
+	for (const n of graph.nodes) {
+		if (n.parent === void 0) continue;
+		const list = children.get(n.parent);
+		if (list) list.push(n);
+		else children.set(n.parent, [n]);
+	}
+	const margin = options.margin ?? 5;
+	const inset = options.frameInset ?? margin;
+	const rooms = /* @__PURE__ */ new Map();
+	const routes = [];
+	for (const { edge, frame, plug } of inner) {
+		const f = byId.get(frame);
+		const [own, far] = plug === "source" ? [edge.source, edge.target] : [edge.target, edge.source];
+		const chain = [];
+		for (let p = byId.get(far.node).parent; p !== frame; p = byId.get(p).parent) chain.push(p);
+		const key = JSON.stringify([frame, ...chain]);
+		let room = rooms.get(key);
+		if (!room) rooms.set(key, room = makeRoom$1(f, chain, children, byId, inset, options));
+		const end = room.nodes.get(far.node);
+		if (!end) continue;
+		const fp = placePlug(f, own, center(end.box));
+		const inward = {
+			x: -fp.normal.x,
+			y: -fp.normal.y
+		};
+		const start = {
+			point: {
+				x: fp.point.x + inward.x * inset,
+				y: fp.point.y + inward.y * inset
+			},
+			normal: inward
+		};
+		const ep = placePlug(end, far, fp.point);
+		const ends = /* @__PURE__ */ new Set([end]);
+		const points = plug === "source" ? stub(fp.point, room.ways.between(start, ep, ends)) : stub(fp.point, room.ways.between(ep, start, ends).reverse()).reverse();
+		routes.push({
+			edge: edge.id,
+			points,
+			frame
+		});
+	}
+	return routes;
+}
+/** This function puts the plug of the wall before a way that starts on the bounds. A first point on the line of the stub goes. */
+function stub(plug, way) {
+	const [a, b] = way;
+	if (!a || dist(a, plug) === 0) return way;
+	if (b && Math.abs((a.x - plug.x) * (b.y - plug.y) - (a.y - plug.y) * (b.x - plug.x)) < 1e-9 && (a.x - plug.x) * (b.x - a.x) + (a.y - plug.y) * (b.y - a.y) > 0) return [plug, ...way.slice(1)];
+	return [plug, ...way];
+}
+/**
+* This function makes the room of a frame for the far ends below the nodes of `chain` (the nearest first).
+* The obstacles are the children of the frame and of each node of the chain, except the nodes of the chain.
+* Four walls close the bounds, so that no way leaves them.
+*/
+function makeRoom$1(f, chain, children, byId, inset, options) {
+	const margin = options.margin ?? 5;
+	const bounds = shrink(f.box, inset);
+	const skip = new Set(chain);
+	const nodes = /* @__PURE__ */ new Map();
+	for (const holder of [f.id, ...chain]) for (const n of children.get(holder) ?? []) {
+		if (skip.has(n.id)) continue;
+		const box = byId.get(holder).box;
+		if (inside(n.box, box)) {
+			nodes.set(n.id, n);
+			continue;
+		}
+		const rule = options.outside ?? "throw";
+		if (rule === "throw") throw new RangeError(`The box of the node "${n.id}" is not inside the box of its frame "${holder}". The option outside can skip or clamp it.`);
+		if (rule === "skip") continue;
+		const cut = cutBox(n.box, bounds);
+		if (cut) nodes.set(n.id, {
+			...n,
+			box: cut,
+			...n.ports ? { ports: n.ports.map((p) => p.at ? {
+				...p,
+				at: {
+					x: p.at.x + n.box.x - cut.x,
+					y: p.at.y + n.box.y - cut.y
+				}
+			} : p) } : {}
+		});
+	}
+	const w = shrink(bounds, -(margin / 2 + EPS$5));
+	const t = 2 * margin + 1;
+	const walls = [
+		{
+			x: w.x - t,
+			y: w.y - t,
+			w: w.w + 2 * t,
+			h: t
+		},
+		{
+			x: w.x - t,
+			y: w.y + w.h,
+			w: w.w + 2 * t,
+			h: t
+		},
+		{
+			x: w.x - t,
+			y: w.y,
+			w: t,
+			h: w.h
+		},
+		{
+			x: w.x + w.w,
+			y: w.y,
+			w: t,
+			h: w.h
+		}
+	].map((box, i) => ({
+		id: `\u0000wall${i}`,
+		box
+	}));
+	return {
+		ways: new WayFinder([...nodes.values(), ...walls], options),
+		nodes
+	};
+}
+/** This function gives the box, smaller by `d` on each side. A negative `d` makes it larger. */
+function shrink(b, d) {
+	return {
+		x: b.x + d,
+		y: b.y + d,
+		w: Math.max(0, b.w - 2 * d),
+		h: Math.max(0, b.h - 2 * d)
+	};
+}
+/** This function tells if the box `a` is inside the box `b`. */
+function inside(a, b) {
+	return a.x >= b.x && a.y >= b.y && a.x + a.w <= b.x + b.w && a.y + a.h <= b.y + b.h;
+}
+/** This function gives the part of the box `a` inside the box `b`, or `undefined` when they have no common area. */
+function cutBox(a, b) {
+	const x = Math.max(a.x, b.x);
+	const y = Math.max(a.y, b.y);
+	const w = Math.min(a.x + a.w, b.x + b.w) - x;
+	const h = Math.min(a.y + a.h, b.y + b.h) - y;
+	return w > 0 && h > 0 ? {
+		x,
+		y,
+		w,
+		h
+	} : void 0;
+}
 // src/routers/corners.ts
 /**
 * This function makes a router that goes around the nodes.
 * Each edge leaves its plug along the normal of the side. It goes a shortest way (A*) through a sparse visibility graph
 * of the box corners, without the needless corners. It enters the target plug along its normal.
+* An inner edge (`splitFrames`) gets an inner route in the bounds of its frame (`frameRoutes`), after the outer routes.
 */
 function cornersRouter(options) {
 	const router = {
 		name: options.name,
 		route(input) {
-			const graph = resolvePorts(input);
+			const { graph, inner } = splitFrames(resolvePorts(input));
 			const byId = nodeIndex(graph);
 			const ways = new WayFinder(graph.nodes, options);
 			const routes = [];
+			const done = () => {
+				if (inner.length > 0) routes.push(...frameRoutes(graph, inner, options));
+				return { routes };
+			};
 			if (!options.plug && (options.plugs ?? "facing") === "facing" && !((options.plugGap ?? 0) > 0)) {
 				for (const e of graph.edges) {
 					const s = byId.get(e.source.node);
@@ -5062,7 +5285,7 @@ function cornersRouter(options) {
 						points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
 					});
 				}
-				return { routes };
+				return done();
 			}
 			const ends = [];
 			const placed = options.plug ? plugsByEdge(options.plug.run({
@@ -5088,7 +5311,7 @@ function cornersRouter(options) {
 				edge: e.id,
 				points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
 			});
-			return { routes };
+			return done();
 		}
 	};
 	return options.maxNodes === void 0 ? router : {
@@ -5177,7 +5400,7 @@ function spacePlugs(ends, gap) {
 const plugsRouter = {
 	name: "plugs",
 	route(input) {
-		const graph = resolvePorts(input);
+		const graph = outerGraph(input);
 		const byId = nodeIndex(graph);
 		const routes = [];
 		for (const e of graph.edges) {
@@ -5359,7 +5582,7 @@ const LEVEL_LINK_DEFAULTS = Object.freeze({
 	plugInset: 6,
 	throughCost: 8
 });
-const EPS$3 = 1e-6;
+const EPS$4 = 1e-6;
 /**
 * This function removes the repeated points, the points in the middle of a straight run,
 * and the points where the way turns back on itself.
@@ -5374,15 +5597,15 @@ function tidy(p) {
 function tidyPoints(p) {
 	const out = [];
 	for (const q of p) {
-		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$3) continue;
+		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$4) continue;
 		while (out.length >= 2) {
 			const a = out[out.length - 2];
 			const b = out[out.length - 1];
 			const cross = (b.x - a.x) * (q.y - b.y) - (b.y - a.y) * (q.x - b.x);
-			if (Math.abs(cross) > EPS$3 * (1 + dist(a, b) * dist(b, q))) break;
+			if (Math.abs(cross) > EPS$4 * (1 + dist(a, b) * dist(b, q))) break;
 			out.pop();
 		}
-		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$3) continue;
+		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$4) continue;
 		out.push(q);
 	}
 	return out;
@@ -5755,7 +5978,7 @@ function freeSpans(lo, hi, covered) {
 		if (x >= hi) break;
 	}
 	if (x < hi) out.push([x, hi]);
-	return out.filter(([a, b]) => b - a > EPS$3);
+	return out.filter(([a, b]) => b - a > EPS$4);
 }
 /**
 * This function gives the shortest way between the free plugs of the two nodes, or `undefined` when the second corner graph has none.
@@ -5887,7 +6110,7 @@ function squarePull(p, obstacles, pad, first, last, lookahead = 16) {
 		out.push(...step.legs);
 		const end = out[out.length - 1];
 		const before = out[out.length - 2];
-		axis = Math.abs(end.y - before.y) < EPS$3 ? "x" : Math.abs(end.x - before.x) < EPS$3 ? "y" : void 0;
+		axis = Math.abs(end.y - before.y) < EPS$4 ? "x" : Math.abs(end.x - before.x) < EPS$4 ? "y" : void 0;
 		i = step.j;
 	}
 	return out;
@@ -5897,7 +6120,7 @@ function squarePull(p, obstacles, pad, first, last, lookahead = 16) {
 * Of two clear corners, it picks the corner that continues the axis `from` and arrives along the axis `to`.
 */
 function square(a, b, obstacles, pad, from, to) {
-	if (Math.abs(a.x - b.x) < EPS$3 || Math.abs(a.y - b.y) < EPS$3) return obstacles.clear(a, b, pad) ? [b] : void 0;
+	if (Math.abs(a.x - b.x) < EPS$4 || Math.abs(a.y - b.y) < EPS$4) return obstacles.clear(a, b, pad) ? [b] : void 0;
 	const options = [{
 		c: {
 			x: b.x,
@@ -6007,7 +6230,7 @@ function sectionsRouter(options) {
 	const router = {
 		name: options.name,
 		route(input) {
-			const graph = resolvePorts(input);
+			const graph = outerGraph(input);
 			const stretch = options.stretch ?? SECTIONS_DEFAULTS.stretch;
 			const stretchPad = options.stretchPad ?? SECTIONS_DEFAULTS.stretchPad;
 			const hubSlack = options.hubSlack ?? SECTIONS_DEFAULTS.hubSlack;
@@ -7049,7 +7272,7 @@ function trunksRouter(options) {
 	const router = {
 		name: options.name,
 		route(input) {
-			const graph = resolvePorts(input);
+			const graph = outerGraph(input);
 			const byId = nodeIndex(graph);
 			const ways = new WayFinder(graph.nodes, options);
 			const points = /* @__PURE__ */ new Map();
@@ -7245,7 +7468,7 @@ function sharedRouter(options, negotiation) {
 	const router = {
 		name: options.name,
 		route(input) {
-			const graph = resolvePorts(input);
+			const graph = outerGraph(input);
 			const byId = nodeIndex(graph);
 			const ways = new WayFinder(graph.nodes, options);
 			const corners = ways.corners;
@@ -7611,7 +7834,7 @@ function boxExit(box, toward) {
 const straightRouter = {
 	name: "straight",
 	route(input) {
-		const graph = resolvePorts(input);
+		const graph = outerGraph(input);
 		const byId = nodeIndex(graph);
 		const routes = [];
 		for (const e of graph.edges) {
@@ -8378,7 +8601,7 @@ const LANE_TRACKS = [
 	"left-edge",
 	"free"
 ];
-const EPS$2 = 1e-6;
+const EPS$3 = 1e-6;
 const ROUNDS = 8;
 /**
 * This function gives each link that runs along a gap its own lane in the gap. The lanes of a gap are `spacing` apart, around its middle line.
@@ -8403,7 +8626,7 @@ function laneGaps(items, links, options) {
 	})));
 	const counts = [];
 	for (const g of boardGaps(items, options.snap)) {
-		if (g.width <= EPS$2) continue;
+		if (g.width <= EPS$3) continue;
 		const across = g.axis;
 		const along = g.axis === "x" ? "y" : "x";
 		const lo = g.at - g.width;
@@ -8414,8 +8637,8 @@ function laneGaps(items, links, options) {
 			for (let i = 2; i <= p.length - 2; i++) {
 				const a = p[i - 1];
 				const b = p[i];
-				if (Math.abs(a[across] - b[across]) > EPS$2 || a[across] <= lo + EPS$2 || a[across] >= hi - EPS$2) continue;
-				if (Math.abs(a[along] - b[along]) <= EPS$2) continue;
+				if (Math.abs(a[across] - b[across]) > EPS$3 || a[across] <= lo + EPS$3 || a[across] >= hi - EPS$3) continue;
+				if (Math.abs(a[along] - b[along]) <= EPS$3) continue;
 				const side = (q, r) => Math.sign(r[across] - q[across]);
 				pieces.push({
 					link: li,
@@ -8491,7 +8714,7 @@ function leftEdgeLanes(list, constrained) {
 		const now = [];
 		let end = -Infinity;
 		for (const i of byStart) {
-			if (lane[i] >= 0 || wait[i] > 0 || list[i].lo < end - EPS$2) continue;
+			if (lane[i] >= 0 || wait[i] > 0 || list[i].lo < end - EPS$3) continue;
 			now.push(i);
 			end = list[i].hi;
 		}
@@ -8514,15 +8737,15 @@ function density(list) {
 	}
 	return most;
 }
-const overlaps = (P, Q) => Math.min(P.hi, Q.hi) - Math.max(P.lo, Q.lo) > EPS$2;
+const overlaps = (P, Q) => Math.min(P.hi, Q.hi) - Math.max(P.lo, Q.lo) > EPS$3;
 /**
 * This function counts the crossings when the piece `P` is on the near side of the piece `Q`.
 * A turn of `P` to the far side crosses `Q` when it is inside the span of `Q`. A turn of `Q` to the near side crosses `P` in the same way.
 */
 function cost$1(P, Q) {
 	let c = 0;
-	for (const [y, s] of P.turns) if (s > 0 && y > Q.lo + EPS$2 && y < Q.hi - EPS$2) c++;
-	for (const [y, s] of Q.turns) if (s < 0 && y > P.lo + EPS$2 && y < P.hi - EPS$2) c++;
+	for (const [y, s] of P.turns) if (s > 0 && y > Q.lo + EPS$3 && y < Q.hi - EPS$3) c++;
+	for (const [y, s] of Q.turns) if (s < 0 && y > P.lo + EPS$3 && y < P.hi - EPS$3) c++;
 	return c;
 }
 /** This function gives the pieces of one gap in lane order, from the near side to the far side. */
@@ -8837,7 +9060,7 @@ function slice(stops, on, off) {
 * The same graph, plan and options give the same result.
 */
 function follow(input, plan, options = {}) {
-	const graph = resolvePorts(input);
+	const graph = outerGraph(input);
 	const byId = nodeIndex(graph);
 	const ways = new WayFinder(graph.nodes, options);
 	const base = new Map((options.routes?.routes ?? []).map((r) => [r.edge, r.points]));
@@ -19894,6 +20117,23 @@ const CORNERS_SCHEMA = {
 	plugOptions: {
 		type: "object",
 		describe: "The options of the strategy `plug`."
+	},
+	outside: {
+		type: "enum",
+		values: [
+			"throw",
+			"skip",
+			"clamp"
+		],
+		default: "throw",
+		describe: "The rule for a box outside the box of its frame: throw a `RangeError`, skip the box and its inner edges, or cut the box to the bounds."
+	},
+	frameInset: {
+		type: "number",
+		min: 0,
+		max: 20,
+		step: 1,
+		describe: "The distance from the walls of a frame to the bounds of its inner routes. Without a value, the inset is the margin."
 	}
 };
 /** The declarations of the options of the router `trunks`. */
@@ -23831,11 +24071,11 @@ const BUILT_IN_STRATEGIES = Object.freeze([
 /** The registry of the built-in strategies. The benchmark and the site take their lists from it. */
 const STRATEGIES = createRegistry(BUILT_IN_STRATEGIES);
 // src/bench/measures/curves.ts
-const EPS$1 = 1e-9;
+const EPS$2 = 1e-9;
 const DEG = 180 / Math.PI;
 const unit = (x, y) => {
 	const l = Math.hypot(x, y);
-	return l > EPS$1 ? {
+	return l > EPS$2 ? {
 		x: x / l,
 		y: y / l
 	} : void 0;
@@ -23854,7 +24094,7 @@ function frame(from, s, t) {
 				x: -Math.sin(a) * sign,
 				y: Math.cos(a) * sign
 			},
-			curvature: s.radius > EPS$1 ? sign / s.radius : 0
+			curvature: s.radius > EPS$2 ? sign / s.radius : 0
 		};
 	}
 	const [p0, p1, p2, p3] = [
@@ -23878,7 +24118,7 @@ function frame(from, s, t) {
 		y: 6 * (p1.y - 2 * p2.y + p3.y)
 	};
 	const speed = Math.hypot(d.x, d.y);
-	if (speed > EPS$1) return {
+	if (speed > EPS$2) return {
 		tangent: {
 			x: d.x / speed,
 			y: d.y / speed
@@ -23947,18 +24187,71 @@ function g2Defect(segments, u) {
 */
 function bendingEnergy(points, tolerance = .25) {
 	const q = [];
-	for (const v of points) if (q.length === 0 || dist(q[q.length - 1], v) > EPS$1) q.push(v);
+	for (const v of points) if (q.length === 0 || dist(q[q.length - 1], v) > EPS$2) q.push(v);
 	if (q.length < 3) return 0;
 	const phi = turns(q);
 	let sum = 0;
 	for (let i = 1; i + 1 < q.length; i++) {
 		const t = Math.abs(phi[i - 1]);
-		if (t < EPS$1) continue;
+		if (t < EPS$2) continue;
 		const l = Math.min((dist(q[i - 1], q[i]) + dist(q[i], q[i + 1])) / 2, 8 * tolerance / t);
 		sum += t * t / l;
 	}
 	return polylineLength(q) * sum;
 }
+/**
+* This function gives the curvature variation of a sampled curve (C4 of MEAS0, Moreton 1993): `V = L^3 · ∫ (dκ/ds)^2 ds`.
+* Each inner sample gets the curvature `κ = φ / l` of `bendingEnergy`, with its sign. `L` is the length of the curve.
+* The sum is `L^3 · Σ (κ_(i+1) - κ_i)^2 / d_i`, with `d_i` the distance of two inner samples in sequence.
+*
+* The value has no unit, and lower is better. A straight line and an arc of a circle give 0. Fewer than 4 points give 0. The cost is linear.
+*/
+function curvatureVariation(points, tolerance = .25) {
+	const q = [];
+	for (const v of points) if (q.length === 0 || dist(q[q.length - 1], v) > EPS$2) q.push(v);
+	if (q.length < 4) return 0;
+	const phi = turns(q);
+	const kappa = [];
+	for (let i = 1; i + 1 < q.length; i++) {
+		const t = phi[i - 1];
+		const l = Math.min((dist(q[i - 1], q[i]) + dist(q[i], q[i + 1])) / 2, 8 * tolerance / Math.max(EPS$2, Math.abs(t)));
+		kappa.push(Math.abs(t) < EPS$2 ? 0 : t / l);
+	}
+	let sum = 0;
+	for (let i = 0; i + 1 < kappa.length; i++) sum += (kappa[i + 1] - kappa[i]) ** 2 / dist(q[i + 1], q[i + 2]);
+	return polylineLength(q) ** 3 * sum;
+}
+/** This function gives the points of a polyline with no leg longer than `step`. It keeps each vertex. */
+function densify(points, step) {
+	const out = [];
+	for (let i = 0; i < points.length; i++) {
+		const b = points[i];
+		if (i > 0) {
+			const a = points[i - 1];
+			const n = Math.ceil(dist(a, b) / step);
+			for (let k = 1; k < n; k++) out.push({
+				x: a.x + (b.x - a.x) * k / n,
+				y: a.y + (b.y - a.y) * k / n
+			});
+		}
+		out.push(b);
+	}
+	return out;
+}
+/** The most points of each of the two lists of `curveDeviation`. More points give a longer step. */
+const DEVIATION_POINTS = 400;
+/**
+* This function gives the deviation of a curve from its route (C8 of MEAS0).
+* The value is the Fréchet distance of the samples of the curve and the polyline of the route.
+* Each list gets points with no leg longer than `step`, or longer when a list has more than 400 points. Then the discrete Fréchet distance is near the true distance.
+*
+* The value is in units of the board, and lower is better. The caller divides it by the unit of the board. The cost is quadratic for each route.
+*/
+function curveDeviation(samples, polyline, step) {
+	const long = Math.max(polylineLength(samples), polylineLength(polyline));
+	const h = Math.max(step, long / DEVIATION_POINTS, EPS$2);
+	return frechet(densify(samples, h), densify(polyline, h));
+}
 /** This function tells if a polyline crosses itself. Two legs next to each other do not count. The cost is `n log n`. */
 function crossesItself(p) {
 	if (p.length < 4) return false;
@@ -25329,6 +25622,22 @@ function linkAgreement(graph, levels, routes, unit) {
 	}
 	return n > 0 ? sum / n : void 0;
 }
+/**
+* This function gives the level ratio of the levels (Z5 of MEAS0, Mondal 2018): `lr_d = items_(d+1) / items_d`, in the order of depth.
+* A level without items does not count. Fewer than 2 levels give `undefined`. Lower is better for both values. The cost is linear.
+*/
+function levelRatio(levels) {
+	const counts = byDepth(levels).map((l) => l.items.length).filter((n) => n > 0);
+	if (counts.length < 2) return void 0;
+	const ratios = counts.slice(1).map((n, d) => n / counts[d]);
+	const logs = ratios.map((r) => Math.log(r));
+	const mean = logs.reduce((s, x) => s + x, 0) / logs.length;
+	const spread = Math.sqrt(logs.reduce((s, x) => s + (x - mean) ** 2, 0) / logs.length);
+	return {
+		max: Math.max(...ratios),
+		spread
+	};
+}
 // src/bench/measures/groups.ts
 /** This function gives the grouping of one level: each node goes to the id of its item. */
 function levelGrouping(level) {
@@ -25440,6 +25749,73 @@ function leafGroups(root, count) {
 function groupStability(before, after, count) {
 	return adjustedRandIndex(leafGroups(before, count), leafGroups(after, count));
 }
+/**
+* This function gives the fill of the groups of one level (G4 of MEAS0): the mean of `fill(c) = Σ_(v in c) area(box(v)) / area(box(c))`.
+* `box(c)` is the box of the item. Only an item with 2 or more nodes counts, and a fill above 1 counts as 1.
+* The scale is 0 to 1, and higher is better. A level without such an item gives `undefined`. The cost is linear.
+*/
+function groupFill(graph, level) {
+	const area = new Map(graph.nodes.map((n) => [n.id, n.box.w * n.box.h]));
+	const fills = [];
+	for (const item of level.items) {
+		if (item.nodes.length < 2) continue;
+		const own = item.box.w * item.box.h;
+		const inside = item.nodes.reduce((s, v) => s + (area.get(v) ?? 0), 0);
+		fills.push(own > 0 ? Math.min(1, inside / own) : 1);
+	}
+	return fills.length === 0 ? void 0 : fills.reduce((s, f) => s + f, 0) / fills.length;
+}
+/**
+* This function counts the overlaps of the items of the levels (G5 of MEAS0).
+* An overlap is a pair of items of one level whose boxes overlap by more than `TOLERANCE`.
+* It is the sum over the levels of `countOverlaps`. Lower is better. The cost is `n log n` for each level.
+*/
+function itemOverlaps(levels) {
+	return levels.reduce((n, level) => n + countOverlaps(level.items.map((i) => i.box)), 0);
+}
+/** Up to this number of nodes, `silhouette` examines each node. Above it, two seeded samples of this size give an estimate. */
+const SILHOUETTE_NODES = 2e3;
+/**
+* This function gives the silhouette of the groups of one level (G7 of MEAS0, Rousseeuw 1987): the mean of `s(v) = (b_v - a_v) / max(a_v, b_v)`.
+* `a_v` is the mean distance from the center of `v` to the centers of the other nodes of its item. `b_v` is the smallest mean distance to the nodes of another item.
+* A node alone in its item gets `s(v) = 0`. The scale is -1 to 1, and higher is better.
+* A level with fewer than 2 items gives `undefined`. The cost is quadratic up to 2000 nodes.
+* Above 2000 nodes, a seeded sample of 2000 nodes gets `s(v)`, against a second seeded sample of 2000 nodes. Thus the value is an estimate.
+*/
+function silhouette(graph, level) {
+	const at = new Map(graph.nodes.map((n) => [n.id, center(n.box)]));
+	const all = level.items.flatMap((item, k) => item.nodes.flatMap((v) => at.has(v) ? [{
+		p: at.get(v),
+		k
+	}] : []));
+	if (new Set(all.map((x) => x.k)).size < 2) return void 0;
+	const R = rng(all.length);
+	const sample = () => all.length <= SILHOUETTE_NODES ? all : Array.from({ length: SILHOUETTE_NODES }, () => all[Math.floor(R() * all.length)]);
+	const chosen = sample();
+	const ref = sample();
+	const groups = /* @__PURE__ */ new Map();
+	for (const { p, k } of ref) {
+		const g = groups.get(k);
+		if (g) g.push(p);
+		else groups.set(k, [p]);
+	}
+	let sum = 0;
+	for (const { p, k } of chosen) {
+		const own = groups.get(k);
+		if (!own || own.length < 2) continue;
+		let a = 0;
+		let b = Number.POSITIVE_INFINITY;
+		for (const [j, g] of groups) {
+			const d = g.reduce((s, q) => s + dist(p, q), 0);
+			if (j === k) a = d / (g.length - 1);
+			else b = Math.min(b, d / g.length);
+		}
+		if (!Number.isFinite(b)) continue;
+		const m = Math.max(a, b);
+		sum += m > 0 ? (b - a) / m : 0;
+	}
+	return sum / chosen.length;
+}
 // src/bench/measures/stability.ts
 /**
 * This function makes a seeded small change of a graph: one node moves by `boardUnit`, one edge goes and one new edge comes.
@@ -25570,6 +25946,108 @@ function roomOrderFaults(before, after, snap = .5) {
 	}
 	return Math.round(faults * (n * (n - 1)) / 2 / Math.max(1, seen));
 }
+/**
+* This function gives the displacement of the boxes (M3 of MEAS0, Bridgeman 2000): `mean_v dist(box_open(v), box_packed(v)) / u`.
+* The distance is between the centers of the two boxes of a node, and `u` is the unit of the packed board.
+* The value has no unit, and lower is better. A board where no box moves gives 0. The cost is linear.
+*/
+function boxDisplacement(before, after, unit) {
+	const next = new Map(after.map((b) => [b.id, b.box]));
+	let sum = 0;
+	let n = 0;
+	for (const b of before) {
+		const a = next.get(b.id);
+		if (!a) continue;
+		sum += dist(center(b.box), center(a));
+		n++;
+	}
+	return n === 0 ? 0 : sum / n / (unit > 0 ? unit : 1);
+}
+/** The number of nearest boxes of each box that make the neighbour pairs of `distanceDistortion`. */
+const DISTORTION_NEIGHBOURS = 4;
+/**
+* This function gives the distance distortion of the boxes (M5 of MEAS0): the Kruskal stress of the centers.
+* `σ = sqrt(Σ (α d'_ij - d_ij)^2 / Σ d_ij^2)`, with `d` the distance on the packed board, `d'` the distance on the open board, and `α = Σ d d' / Σ d'^2` the best scale.
+* The pairs are each box and its 4 nearest boxes on the packed board. The scale is 0 to 1, and lower is better.
+* A board that only changes its scale gives 0. The cost is `n log n` for an even density.
+*/
+function distanceDistortion(before, after) {
+	const next = new Map(after.map((b) => [b.id, center(b.box)]));
+	const list = before.flatMap((b) => next.has(b.id) ? [{
+		p: center(b.box),
+		q: next.get(b.id)
+	}] : []);
+	const pairs = neighbourPairs(list.map((x) => x.p), 4);
+	let dd = 0;
+	let qq = 0;
+	let pp = 0;
+	const ds = [];
+	for (const [i, j] of pairs) {
+		const d = dist(list[i].p, list[j].p);
+		const e = dist(list[i].q, list[j].q);
+		ds.push([d, e]);
+		dd += d * e;
+		qq += e * e;
+		pp += d * d;
+	}
+	if (pp === 0) return 0;
+	const alpha = qq > 0 ? dd / qq : 0;
+	const res = ds.reduce((s, [d, e]) => s + (alpha * e - d) ** 2, 0);
+	return Math.sqrt(res / pp);
+}
+/** This function gives each pair of a point and one of its `k` nearest points one time, as `[i, j]` with `i < j`. A grid of buckets finds the points. */
+function neighbourPairs(points, k) {
+	const n = points.length;
+	if (n < 2) return [];
+	let x0 = Number.POSITIVE_INFINITY;
+	let y0 = Number.POSITIVE_INFINITY;
+	let x1 = Number.NEGATIVE_INFINITY;
+	let y1 = Number.NEGATIVE_INFINITY;
+	for (const p of points) {
+		x0 = Math.min(x0, p.x);
+		y0 = Math.min(y0, p.y);
+		x1 = Math.max(x1, p.x);
+		y1 = Math.max(y1, p.y);
+	}
+	const cell = Math.max(1e-9, Math.sqrt(((x1 - x0) * (y1 - y0) || 1) / n) * 2);
+	const key = (cx, cy) => `${cx},${cy}`;
+	const buckets = /* @__PURE__ */ new Map();
+	points.forEach((p, i) => {
+		const kk = key(Math.floor((p.x - x0) / cell), Math.floor((p.y - y0) / cell));
+		const list = buckets.get(kk);
+		if (list) list.push(i);
+		else buckets.set(kk, [i]);
+	});
+	const span = Math.ceil(Math.max(x1 - x0, y1 - y0) / cell) + 1;
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	points.forEach((p, i) => {
+		const cx = Math.floor((p.x - x0) / cell);
+		const cy = Math.floor((p.y - y0) / cell);
+		let near = [];
+		for (let ring = 0; ring <= span; ring++) {
+			for (let gx = cx - ring; gx <= cx + ring; gx++) for (let gy = cy - ring; gy <= cy + ring; gy++) {
+				if (Math.max(Math.abs(gx - cx), Math.abs(gy - cy)) !== ring) continue;
+				for (const j of buckets.get(key(gx, gy)) ?? []) if (j !== i) near.push({
+					j,
+					d: dist(p, points[j])
+				});
+			}
+			if (near.length >= Math.min(k, n - 1)) {
+				near.sort((a, b) => a.d - b.d || a.j - b.j);
+				if (near[Math.min(k, n - 1) - 1].d <= ring * cell) break;
+			}
+		}
+		near = near.sort((a, b) => a.d - b.d || a.j - b.j).slice(0, k);
+		for (const { j } of near) {
+			const pk = i < j ? `${i},${j}` : `${j},${i}`;
+			if (seen.has(pk)) continue;
+			seen.add(pk);
+			out.push(i < j ? [i, j] : [j, i]);
+		}
+	});
+	return out;
+}
 // src/bench/measures/pareto.ts
 /** This function gives the value of a measure as a cost: lower is better. A value that is not a number is the worst cost. */
 function cost(values, o) {
@@ -26117,6 +26595,128 @@ function laneArea(graph, open) {
 	}
 	return (x1 - x0) * (y1 - y0) / packed;
 }
+// src/bench/measures/symmetry.ts
+const EPS$1 = 1e-9;
+/** This function gives the corners of a polyline: the points without repeats and without inner points on a straight line. */
+function cornersOf(points) {
+	const q = [];
+	for (const v of points) if (q.length === 0 || dist(q[q.length - 1], v) > EPS$1) q.push(v);
+	const out = [];
+	for (let i = 0; i < q.length; i++) {
+		const v = q[i];
+		if (i > 0 && i + 1 < q.length) {
+			const a = out[out.length - 1];
+			const c = q[i + 1];
+			const cr = (v.x - a.x) * (c.y - v.y) - (v.y - a.y) * (c.x - v.x);
+			const dt = (v.x - a.x) * (c.x - v.x) + (v.y - a.y) * (c.y - v.y);
+			if (Math.abs(cr) <= EPS$1 * Math.max(1, dist(a, v) * dist(v, c)) && dt > 0) continue;
+		}
+		out.push(v);
+	}
+	return out;
+}
+/** This function tells if two lists of corners are the same, point by point, within `tol`. */
+const sameCorners = (a, b, tol) => a.length === b.length && a.every((p, i) => dist(p, b[i]) <= tol);
+/**
+* This function gives the symmetry of the drawing (H3 of MEAS0). The value is the share of the routes that the best map of the board sends onto a route.
+* The maps are the two mirrors on the axes and the half turn. Each one goes through the center of the boxes.
+*
+* A route of the edge `(s, t)` maps when two things are true. The map sends the centers of `s` and `t` to the centers of the nodes `s'` and `t'`, within `u / 4`.
+* A route of an edge between `s'` and `t'` has the same corners as the mapped route, within `u / 4`. `u` is the unit of the board.
+*
+* The scale is 0 to 1, and higher is better. A router keeps the symmetry that the boxes have, or loses it. Routes without points give `undefined`.
+* The cost is linear in the points of the routes.
+*/
+function routeSymmetry(graph, routes) {
+	const drawn = routes.filter((r) => r.points.length >= 2);
+	if (drawn.length === 0 || graph.nodes.length === 0) return void 0;
+	const tol = boardUnit(graph) / 4;
+	let x0 = Number.POSITIVE_INFINITY;
+	let y0 = Number.POSITIVE_INFINITY;
+	let x1 = Number.NEGATIVE_INFINITY;
+	let y1 = Number.NEGATIVE_INFINITY;
+	for (const n of graph.nodes) {
+		x0 = Math.min(x0, n.box.x);
+		y0 = Math.min(y0, n.box.y);
+		x1 = Math.max(x1, n.box.x + n.box.w);
+		y1 = Math.max(y1, n.box.y + n.box.h);
+	}
+	const cx = (x0 + x1) / 2;
+	const cy = (y0 + y1) / 2;
+	const maps = [
+		(p) => ({
+			x: 2 * cx - p.x,
+			y: p.y
+		}),
+		(p) => ({
+			x: p.x,
+			y: 2 * cy - p.y
+		}),
+		(p) => ({
+			x: 2 * cx - p.x,
+			y: 2 * cy - p.y
+		})
+	];
+	const cellOf = (p) => [Math.floor(p.x / tol), Math.floor(p.y / tol)];
+	const cells = /* @__PURE__ */ new Map();
+	const at = /* @__PURE__ */ new Map();
+	for (const n of graph.nodes) {
+		const c = center(n.box);
+		at.set(n.id, c);
+		const [i, j] = cellOf(c);
+		const k = `${i},${j}`;
+		const list = cells.get(k);
+		if (list) list.push({
+			id: n.id,
+			at: c
+		});
+		else cells.set(k, [{
+			id: n.id,
+			at: c
+		}]);
+	}
+	const nodeAt = (p) => {
+		const [i, j] = cellOf(p);
+		let best;
+		for (let a = i - 1; a <= i + 1; a++) for (let b = j - 1; b <= j + 1; b++) for (const n of cells.get(`${a},${b}`) ?? []) {
+			const d = dist(n.at, p);
+			if (d <= tol && (best === void 0 || d < best.d || d === best.d && n.id < best.id)) best = {
+				id: n.id,
+				d
+			};
+		}
+		return best?.id;
+	};
+	const ends = new Map(graph.edges.map((e) => [e.id, [e.source.node, e.target.node]]));
+	const byPair = /* @__PURE__ */ new Map();
+	const corners = drawn.map((r) => cornersOf(r.points));
+	drawn.forEach((r, i) => {
+		const e = ends.get(r.edge);
+		if (!e) return;
+		const k = `${e[0]}\u0000${e[1]}`;
+		const list = byPair.get(k);
+		if (list) list.push(corners[i]);
+		else byPair.set(k, [corners[i]]);
+	});
+	let best = 0;
+	for (const m of maps) {
+		let hits = 0;
+		drawn.forEach((r, i) => {
+			const e = ends.get(r.edge);
+			if (!e) return;
+			const a = at.get(e[0]);
+			const b = at.get(e[1]);
+			const s = a && nodeAt(m(a));
+			const t = b && nodeAt(m(b));
+			if (s === void 0 || t === void 0) return;
+			const mapped = corners[i].map(m);
+			const back = [...mapped].reverse();
+			if ((byPair.get(`${s}\u0000${t}`) ?? []).some((c) => sameCorners(mapped, c, tol)) || (byPair.get(`${t}\u0000${s}`) ?? []).some((c) => sameCorners(back, c, tol))) hits++;
+		});
+		best = Math.max(best, hits / drawn.length);
+	}
+	return best;
+}
 // src/bench/suite.ts
 const now$1 = () => globalThis.performance?.now() ?? Date.now();
 /** The names of the proposed hard rules of MEAS0. The suite counts them. It does not apply them as rules yet. */
@@ -26287,7 +26887,7 @@ function routeMeasures(graph, result, row) {
 		...levelMeasures(graph, result)
 	};
 }
-/** This function draws the routes of a result with each curve strategy and measures the curves (C1, C2, C3, C6 and the curve rules). */
+/** This function draws the routes of a result with each curve strategy and measures the curves (C1, C2, C3, C4, C6, C8 and the curve rules). */
 function curveRuns(graph, result, curves, options) {
 	const byId = nodeIndex(graph);
 	const edges = new Map(graph.edges.map((e) => [e.id, e]));
@@ -26332,6 +26932,8 @@ function curveRuns(graph, result, curves, options) {
 		const g1 = [];
 		const g2 = [];
 		const energy = [];
+		const variation = [];
+		const deviation = [];
 		const rules = {
 			"curve-clear": 0,
 			"curve-ends": 0,
@@ -26345,6 +26947,8 @@ function curveRuns(graph, result, curves, options) {
 			g1.push(g1Defect(segments));
 			g2.push(g2Defect(segments, u));
 			energy.push(bendingEnergy(s, .25));
+			variation.push(curvatureVariation(s, .25));
+			deviation.push(curveDeviation(s, r.points, u / 4) / u);
 			length += polylineLength(s);
 			const normals = options.normals.has(curve.name);
 			const f = curveFaults({
@@ -26371,6 +26975,10 @@ function curveRuns(graph, result, curves, options) {
 			"C2.max": g2.reduce((m, x) => Math.max(m, x), 0),
 			"C3.median": quantile(energy, .5) || 0,
 			"C3.q95": quantile(energy, .95) || 0,
+			"C4.median": quantile(variation, .5) || 0,
+			"C4.q95": quantile(variation, .95) || 0,
+			"C8.median": quantile(deviation, .5) || 0,
+			"C8.max": deviation.reduce((m, x) => Math.max(m, x), 0),
 			"C6.length": ink > 0 ? length / ink : 1,
 			...rules
 		};
@@ -27261,7 +27869,17 @@ function stepRouterStrategy(strategy) {
 		level: strategy,
 		levelOptions: o
 	}).route(graph));
-	return own(strategy.maxNodes, (graph, o) => strategy.run(graph, o).result);
+	return own(strategy.maxNodes, (graph, o) => {
+		const out = strategy.run(graph, o);
+		WHOLE_BOARDS.set(out.result, out.graph);
+		return out.result;
+	});
+}
+/** The board of the output of each whole strategy that `stepRouterStrategy` runs, by its result. The screen reads it for the measures of the moved boxes. */
+const WHOLE_BOARDS = /* @__PURE__ */ new WeakMap();
+/** This function gives the board of the output of a whole strategy that `stepRouterStrategy` ran, or `undefined` for another result. A room strategy can move the boxes of this board. */
+function wholeBoard(result) {
+	return WHOLE_BOARDS.get(result);
 }
 /** This function gives a router for each strategy of one step of `RoutedStep` in a registry, in the order of the registry (`stepRouterStrategy`). */
 function stepRouters(registry, step) {
@@ -27454,6 +28072,7 @@ function graphInput(graph, head) {
 		h: num(n.box.h),
 		x: num(n.box.x),
 		y: num(n.box.y),
+		...n.parent !== void 0 ? { parent: n.parent } : {},
 		...n.ports ? { ports: n.ports.map((p) => portToFile(p, n)) } : {},
 		...n.data ? { data: n.data } : {}
 	}));
@@ -27519,7 +28138,7 @@ function regionBounds(region) {
 	};
 }
 /**
-* This function reads the graph of the router from an input file. The router reads the positions, the ports, the edges and the data.
+* This function reads the graph of the router from an input file. The router reads the positions, the ports, the parents, the edges and the data.
 * Each obstacle becomes a node without edges, with the bounding box of its region, after the boxes.
 * The router ignores the other fields of the packer: `container`, `gap`, `locked`, `rank`, the `shape` of a box and the `move` of an obstacle.
 * A box without `x` and `y` is an error.
@@ -27536,7 +28155,8 @@ function inputGraph(input) {
 				h: b.h
 			},
 			...b.ports ? { ports: b.ports.map(portToModel) } : {},
-			...b.data ? { data: b.data } : {}
+			...b.data ? { data: b.data } : {},
+			...b.parent !== void 0 ? { parent: b.parent } : {}
 		};
 	});
 	for (const o of input.obstacles ?? []) nodes.push({
@@ -28032,6 +28652,42 @@ const MEASURES = Object.freeze([
 		"lower",
 		true
 	],
+	[
+		"M2.order",
+		"M2",
+		"route.room.order",
+		"count",
+		"lower",
+		false,
+		"The number of pairs of boxes whose order or alignment on an axis changes when the boxes move. 0 is correct."
+	],
+	[
+		"M3.displacement",
+		"M3",
+		"route.room.displacement",
+		"no unit",
+		"lower",
+		false,
+		"The mean distance that the center of a box moves, divided by the unit of the board."
+	],
+	[
+		"M5.stress",
+		"M5",
+		"route.room.distortion",
+		"0 to 1",
+		"lower",
+		false,
+		"The stress of the distances from each box to its 4 nearest boxes, after the best change of scale. 0 is a board that only changes its scale."
+	],
+	[
+		"H3.share",
+		"H3",
+		"route.symmetry",
+		"0 to 1",
+		"higher",
+		true,
+		"The share of the routes that a mirror or a half turn of the board sends onto a route, for the best of the three maps."
+	],
 	[
 		"W3.crossings",
 		"W3",
@@ -28224,6 +28880,33 @@ const MEASURES = Object.freeze([
 		"higher",
 		true
 	],
+	[
+		"Z1.countsSum",
+		"Z1",
+		"route.level.counts-sum",
+		"count",
+		"lower",
+		false,
+		"The faults of the hard rule `counts-sum`: a level whose items miss a node, or whose links miss an edge. 0 is correct."
+	],
+	[
+		"Z5.max",
+		"Z5",
+		"route.level.ratio.max",
+		"ratio",
+		"lower",
+		true,
+		"The largest ratio of the item counts of two levels in sequence. A large ratio is a sudden jump of the zoom."
+	],
+	[
+		"Z5.spread",
+		"Z5",
+		"route.level.ratio.spread",
+		"no unit",
+		"lower",
+		true,
+		"The standard deviation of the log of the ratios of the item counts of the levels. 0 is a zoom with steps of equal size."
+	],
 	[
 		"G1.modularity",
 		"G1",
@@ -28264,6 +28947,33 @@ const MEASURES = Object.freeze([
 		"higher",
 		true
 	],
+	[
+		"G4.fill",
+		"G4",
+		"route.group.fill",
+		"0 to 1",
+		"higher",
+		true,
+		"The mean share of the box of a group of the far view that the boxes of its nodes fill. A full group box is 1."
+	],
+	[
+		"G5.overlaps",
+		"G5",
+		"route.group.overlaps",
+		"count",
+		"lower",
+		true,
+		"The number of pairs of items of one level whose boxes overlap. 0 is correct."
+	],
+	[
+		"G7.silhouette",
+		"G7",
+		"route.group.silhouette",
+		"-1 to 1",
+		"higher",
+		true,
+		"The mean silhouette of the nodes of the far view: how much nearer a node is to its group than to the nearest other group."
+	],
 	[
 		"C1.max",
 		"C1",
@@ -28312,6 +29022,42 @@ const MEASURES = Object.freeze([
 		"lower",
 		false
 	],
+	[
+		"C4.median",
+		"C4",
+		"route.curve.c4.median",
+		"no unit",
+		"lower",
+		false,
+		"The median curvature variation of the curves, without a unit. A circle or a straight line is 0. A sudden change of the curvature is large."
+	],
+	[
+		"C4.q95",
+		"C4",
+		"route.curve.c4.q95",
+		"no unit",
+		"lower",
+		false,
+		"The 0.95 quantile of the curvature variation of the curves. It shows the worst curves."
+	],
+	[
+		"C8.median",
+		"C8",
+		"route.curve.c8.median",
+		"no unit",
+		"lower",
+		false,
+		"The median Fréchet distance of a curve from the polyline of its route, divided by the unit of the board."
+	],
+	[
+		"C8.max",
+		"C8",
+		"route.curve.c8.max",
+		"no unit",
+		"lower",
+		false,
+		"The largest Fréchet distance of a curve from the polyline of its route, divided by the unit of the board."
+	],
 	[
 		"C5.peak",
 		"C5",
@@ -28360,7 +29106,7 @@ const MEASURES = Object.freeze([
 		"lower",
 		false
 	]
-].map(([key, id, name, unit, better, placementDependent]) => {
+].map(([key, id, name, unit, better, placementDependent, definition]) => {
 	const rule = MIN_EFFECT_BY_UNIT.get(unit);
 	if (!rule) throw new Error(`MEASURES: the unit "${unit}" of ${key} has no rule in MIN_EFFECTS`);
 	const info = {
@@ -28369,7 +29115,8 @@ const MEASURES = Object.freeze([
 		name,
 		unit,
 		better,
-		placementDependent
+		placementDependent,
+		...definition === void 0 ? {} : { definition }
 	};
 	return Object.freeze(rule.minEffect === void 0 ? info : {
 		...info,
@@ -30502,11 +31249,29 @@ function screenRegistry(step, strategies, baseline) {
 }
 /** This function tells if a step of the screen gives routes. The step `router` gives routes, and each step of `RoutedStep` gives routes as a router. */
 const givesRoutes = (step) => step === "router" || isRoutedStep(step);
+/** This function gives the measures of the shape of the groups and of the levels: G4, G5, G7 and Z5. A value without its data is not in the result. */
+function groupShapeValues(graph, levels) {
+	const values = {};
+	if (levels.length === 0) return values;
+	values["G5.overlaps"] = itemOverlaps(levels);
+	const far = farLevel(levels);
+	const fill = far && groupFill(graph, far);
+	if (fill !== void 0) values["G4.fill"] = fill;
+	const sil = far && silhouette(graph, far);
+	if (sil !== void 0) values["G7.silhouette"] = sil;
+	const ratio = levelRatio(levels);
+	if (ratio) {
+		values["Z5.max"] = ratio.max;
+		values["Z5.spread"] = ratio.spread;
+	}
+	return values;
+}
 /**
 * This function gives the values of a row of `compareStep`, with the measures of `measureQuality` for a router.
 * A router also gets the bundled share (B2), the merge angle (B6) and the bundle stretch (B3) against the routes `base` of `corners`.
 * It also gets the measures of MEAS3A: R12, R14, B5, B7, B8, B9, M1 and M4. The lane measures open each shared segment at `MEASURE_LANE_WIDTH`.
-* A result with zoom levels also gets the link agreement (Z9), for a router and for a grouping rule.
+* A result with zoom levels also gets the link agreement (Z9) and `groupShapeValues`, for a router and for a grouping rule.
+* A router also gets the symmetry of its routes (H3). A whole strategy also gets M2, M3 and M5 of the board of its output.
 */
 function rowValues(step, graph, row, base) {
 	const values = { ...row.values };
@@ -30540,10 +31305,20 @@ function rowValues(step, graph, row, base) {
 		}
 		values["M1.area"] = laneArea(graph, open);
 		values["M4.laneThrough"] = lanesThrough(graph, open);
+		const h3 = routeSymmetry(graph, routes);
+		if (h3 !== void 0) values["H3.share"] = h3;
 	}
 	if ((givesRoutes(step) || step === "group") && row.result?.levels) {
-		const la = linkAgreement(graph, row.result.levels, row.result.routes, boardUnit(graph));
+		const levels = row.result.levels;
+		const la = linkAgreement(graph, levels, row.result.routes, boardUnit(graph));
 		if (la !== void 0) values["Z9.mean"] = la;
+		Object.assign(values, groupShapeValues(graph, levels));
+	}
+	if (step === "whole" && row.result) {
+		const board = wholeBoard(row.result) ?? graph;
+		values["M2.order"] = roomOrderFaults(graph.nodes, board.nodes);
+		values["M3.displacement"] = boxDisplacement(graph.nodes, board.nodes, boardUnit(graph));
+		values["M5.stress"] = distanceDistortion(graph.nodes, board.nodes);
 	}
 	return values;
 }
@@ -30730,6 +31505,7 @@ function screen(step, strategies = [], options = {}) {
 			const { hard, deterministic } = rowRules(step, graph, row, again?.rows[i]);
 			const values = rowValues(step, graph, row, cornersBase);
 			if (hard["link-ends"] !== void 0) values["Z2.linkEnds"] = hard["link-ends"];
+			if (hard["counts-sum"] !== void 0) values["Z1.countsSum"] = hard["counts-sum"];
 			if (optima && withOptima.has(input.id) && row.result) Object.assign(values, gapValues(input, graph, row.result, cornersBase(), gapBase(), optima));
 			if (shuffles > 0 && row.result) {
 				const router = asRouter(strategy, own[row.strategy]);
@@ -31962,6 +32738,6 @@ const sharedStretchStrategy = defineStrategy({
 		name: "shared-stretch"
 	}).route(graph)
 });
-export { AMBIGUITY_GUARD_DEFAULTS, ARC_SOURCES, AREA_DEFAULTS, AREA_WIDTHS, ATTRACTION_DEFAULTS, ATTRACTION_SCHEMA, BACKTRACK_MIN, BACKTRACK_SHARE, BREAK, BREAK_EVEN, BREAK_EVEN_DEFAULTS, BUILT_IN_STRATEGIES, BoundaryWalk, CANDIDATE_SOURCES, CAP_SWEEP, CASES, CHANNEL_REACH, CLEARANCE_CAP, COMPARE_ALL_STEPS, COMPARE_STEPS, CONFLUENT_DEFAULTS, CONSENSUS_DEFAULTS, CONSENSUS_LINKAGES, CORRIDOR_DEFAULTS, CROSSBAR_DEFAULTS, CUBU_DEFAULTS, CURVE_TYPES, CUT_DEFAULTS, CornerGraph, DEFAULT_RNG, DENSE_GROUPS, DENSITY_KERNELS, DIFFUSION_DEFAULTS, DIVIDED_DEFAULTS, EDGE_DISTANCES, EDGE_PATH_DEFAULTS, EXACT_CLASSES, EXACT_EDGES_PER_NODE, EXACT_V1, EXACT_V1_BOUNDS, EXACT_V1_BOUNDS_SIZES, EXACT_V1_SEEDS, EXACT_V1_SIZES, FDEB_DEFAULTS, FIXTURES, FIXTURE_LAYOUTS, FIXTURE_LOCALITY, FLOW_CLUSTER_DEFAULTS, FLOW_FIELD_DEFAULTS, FRECHET_DEFAULTS, FRONT_OBJECTIVES, GAP_BASELINES, GAP_BOOTSTRAP, GAP_CAPS, GAP_DEFAULTS, GAP_RULES, GAP_VIEWS, GROUP_SCOPES, GROUP_SPINES, GROWTH_DEFAULTS, GROWTH_SWEEP, Grid, HDBSCAN_DEFAULTS, HIERARCHY_DEFAULTS, HIERARCHY_GROUPS, HIGHWAYS_ENGINE, HIGHWAYS_FAMILIES, HIGHWAY_BASES, HIGHWAY_BASE_ROUTERS, HOUGH_DEFAULTS, HUB_ALLOCATIONS, HUB_ARC_DEFAULTS, HUB_CANDIDATES, HUB_CHAIN, HYSTERESIS_DEFAULTS, INTERCHANGE_BASES, INTERCHANGE_DEFAULTS, KDEEB_DEFAULTS, KD_DEFAULTS, KENDALL_EXACT, LANES_DEFAULTS, LANE_ORDERS, LANE_STRETCH_DEFAULTS, LANE_STRETCH_ORDERS, LANE_TRACKS, LEVEL_HIGHWAY_DEFAULTS, LINKAGES, LINK_COMMUNITY_DEFAULTS, MANY_GROUPS, MEASURES, MEASURE_LANE_WIDTH, MEET_DEFAULTS, MEMBER_FORMS, MESH_DEFAULTS, MINGLE_DEFAULTS, MIN_EFFECTS, MLSEB_DEFAULTS, MLS_FITS, MODULE_RULES, MOVE_NAMES, NESTED_DEFAULTS, OD_CELL_DEFAULTS, OUTSIDE_SLACK, Obstacles, PACKED_GRID, PICK, PLAN_CHANGERS, PORTFOLIO_B1, PORTFOLIO_BANDS, PORTFOLIO_BASE_MEMBER, PORTFOLIO_CAPS, PORTFOLIO_FIT, PORTFOLIO_HASHES, PORTFOLIO_KS_API, PORTFOLIO_RULES, PORTFOLIO_SETS, POWER_DEFAULTS, PROPOSED_RULES, P_HUB_DEFAULTS, QUICKBUNDLES_DEFAULTS, RECORD_EPS, RESISTANCE_DEFAULTS, RIDGE_DEFAULTS, ROAD_CLASS_DEFAULTS, ROOM_FAMILIES, ROUTED_STEPS, ROUTERS, SAME_HIGHWAY, SBEB_DEFAULTS, SCALE_SPACE_DEFAULTS, SCREEN_FAMILY_BY, SCREEN_RULES, SCREEN_SETS, SCREEN_STEPS, SCREEN_V1, SCREEN_V2, SCREEN_V2_HELD_OUT, SCREEN_WRAPS, SEARCH_DEFAULTS, SEARCH_MOVES, SECTION_DEFAULTS, SELECT_DEFAULTS, SIDE_NORMAL, SKELETON_GROUPS, SKELETON_TARGETS, SLACK_SWEEP, SMALL_CLUSTERED, SOFT_KEY_DEFAULTS, SPACING_LIMIT, SPECTRAL_DEFAULTS, SPIRAL_DEFAULTS, STABLE_ID_DEFAULTS, STEINER_DEFAULTS, STEINER_GROUPS, STEINER_METHODS, STEINER_METRICS, STEPS, STRATEGIES, STREET_DEFAULTS, STREET_SOURCES, STRETCH_DEFAULTS, STRETCH_SWEEP, STUB_DEFAULTS, SUITE_COLUMNS, SoftGraph, SplitTree, TERRITORY_DEFAULTS, TERRITORY_POINTS, TINY_UNIFORM, TOLERANCE, TRACLUS_DEFAULTS, TRAFFIC_RULES, WEISZFELD_DEFAULTS, WSPD_DEFAULTS, WayFinder, ZIPPER_DEFAULTS, activationBase, activationReport, adjustedRandIndex, allSections, ambiguity, ambiguityGate, ambiguityPlan, arcCurve, areaPlan, asRouter, attractionRouter, attractionStrategy, backtrackOf, balance, basePlan, benchBendRoom, benchCurveStrategies, benchCurves, benchHighways, benchLevelRoom, benchOne, benchRoom, benchRun, benchTracks, bendCount, bendingEnergy, bicliqueGroups, bigGroups, boardGaps, boardUnit, boardWins, bootstrapMedian, boundsFamilyName, boxExit, boxPush, boxUnit, boxesOverlap, breakEvenGate, breakEvenPlan, buildSections, bundleStretch, bundledShare, byCollection, byDataGroup, candidateArcs, candidatePlan, candidateScore, canonicalJson, capSettings, caseSeed, cellSteps, center, chainClusters, changeGraph, changedDimensions, channelOverflows, channelWidth, characteristicPoints, checkFamilies, checkLevels, checkOptions, checkPlan, checkPort, checkProperties, checkSchema, checkSections, clampOptions, clothoidCurve, clusters1d, coAssociation, commonEdges, compareAnyStep, compareMeasure, compareSpec, compareStep, compatibility, compatibilityMatrix, confluentPlan, consensusGroups, consensusLabels, consensusPlan, controlChain, cornersRouter, corpusManifest, corridorPlan, countCrossings, countOverlaps, createFamilyRegistry, createRegistry, crossbarPlan, crossesItself, crossingAngle, crossingAngles, cubicAt, cubuPlan, curveFaults, curveJoints, curveOf, curveRuns, curveSpace, curveStrategies, curvesHash, cutGroups, cutShare, declaresFamily, defineStrategy, denseGroupsBoard, densityPlan, densityRidges, depthLevels, detourSpread, diffusionPlan, dimensionAt, dimensionUnit, dist, distinctPoints, divideHighway, dividedPlan, documentHash, dominates, drawnSegments, edgeBlocks, edgeEnds, edgeLengths, edgePathPlan, edgePaths, edgePlugs, edgeResistance, enumDimension, exactBoard, exactFamily, exactGenerator, exactSeed, exactStretch, exactStretches, exercised, facingEnds, familyCell, familyKind, familyOf, familySeed, farLevel, farLinks, fdebLines, fdebPlan, fft, findStrategy, finderOf, firstLines, fixedPortPoint, fixtureGroupOptions, fixtureParams, fixtureRngSeed, fixtureSpecOf, flowClusterPlan, flowClusters, flowDistance, flowFieldPlan, fnv1a32, follow, formatActivation, formatBendRoom, formatCapped, formatCurves, formatFaults, formatFronts, formatGap, formatHighways, formatInput, formatLevelRoom, formatLevels, formatMeasureTime, formatPaired, formatRoom, formatRules, formatScreen, formatSections, formatSummaries, formatTable, formatTracks, frechet, frechetBundles, frechetPlan, freeLines, g1Defect, g2Defect, gapBaselines, gapCap, gapClosed, gapLaneCounts, gapLanes, gapNames, gapPlan, gapValues, gateStrategy, getStrategy, goesOutAndBack, graphInput, greedyBicliques, greedyCrossbars, groupEdges, groupRun, groupSettings, groupStability, groupStrategies, groupedPlan, growthPlan, growthSettings, guardBreaks, hasCusp, hdbscanClusters, hdbscanLabels, hdbscanPlan, hierarchyPlan, highwayChurn, highwayCurve, highwayCurves, highwayEdits, highwayIdKeep, highwayMoves, highwayRouter, highwayRouterStrategy, highwayRouters, highwayStrategies, highwaysRegistry, houghLines, houghPeaks, houghPlan, hubArcPlan, hubCandidates, hubChainBoard, hysteresisGate, hysteresisPlan, inflate, inflectionCount, inflectionCurve, inflectionSector, inkSaved, innerPoints, inputGraph, inputId, interchangeCandidates, interchangePlan, isRoutedStep, itemSizes, jaccard, jaccardIndex, jogPeaks, joinReports, jsonSafe, kMeans, kdGroups, kdeebLines, kdeebPlan, keepMembers, kendallTau, keyGroups, keyedSections, keysPlan, labelGroups, laneArea, laneCrossings, laneFidelity, laneOrder, laneRoutes, laneSeparation, laneSettings, laneStretches, lanesPlan, lanesThrough, leafGroups, lengthBetween, levelCut, levelGrouping, levelHighwayPlan, levelMeasures, levelPairs, levelRoom, levelStrategies, levelsOf, lineDensity, linePoint, linkAgreement, linkCommunities, linkCommunityGroups, linkCommunityPlan, linkDensity, listOptions, listStrategies, makeFixture, makeRoom, manifestHash, manyGroupsBoard, matchHighways, maxStretch, mdf, meanLine, measureBoard, measureByKey, measureByName, measureHighways, measureJogs, measureLevel, measureLevelFaults, measureLinks, measureName, measureQuality, measureRouteFaults, measureStability, meetMember, meetPlan, meetingPoints, memberAt, memberStrategy, mergeAngle, meshPlan, meshWaypoints, minEffectOf, minHash, mingleBundles, minglePlan, mixedSegments, mixesCollections, mlsPoint, mlsebLines, mlsebPlan, modularity, modulesOf, mulberry32, namedObjectives, nearestCentre, nearestOnBoundary, nearestOnLine, nearestSide, nearestSkeleton, nestedGridBoard, nestedGroups, nestedPlan, nestingFaults, nestingViolations, nextRow, nodeAmbiguity, nodeIndex, nodeLinks, numberDimension, numberOf, occupiedArea, odCellPlan, odGroups, offsetLine, offsetPolyline, oneSteiner, openGaps, openLanes, optimaFile, optimumKey, optionDefaults, orderChanges, orderFragility, orderLanes, orderRows, orderStability, orderSuiteRows, orthogonality, outOfBoxes, outputGroups, outputHash, pHubPlan, pMedian, packedGridBoard, paramProblem, paretoFront, parseLines, partWithin, passSettings, pathPoints, peakCurvature, pickLevel, pickMoves, placePlug, planMoves, planOfResult, plugSpacing, plugStrategies, plugsRouter, pointAt, pointBoxDistance, pointDensity, pointGroups, pointOnSide, pointSegmentDistance, polylineLength, portOffset, portfolio, portfolioB1Spec, portfolioBand, portfolioFacts, portfolioKey, portfolioMember, portfolioMembers, portfolioName, portfolioRouter, portfolioStrategy, positionStability, powerPlan, pullApart, quadtreeGroups, quantile, quickBundles, quickBundlesPlan, randomInt, rayToBox, recordLines, recordMoves, rectScattered, regionBounds, register, repairResult, repairStrategy, representative, resample, resistanceClusters, resistancePlan, resolvePorts, resultForm, resultHash, ridgeLines, ridgePlan, rng, roadClassPlan, roomDemand, roomLinks, roomOrderFaults, roomStrategies, roomValues, round3, roundCorners, roundedCurve, routeCrossings, routeInStableOrder, routeMeasures, routePortfolio, routeSeparation, routeStability, routerStrategies, routersOf, ruleCounts, runBenchmark, runKey, runPipeline, runProfile, runSuite, sameData, sampleCurve, samplesOf, sbebLines, sbebPlan, scaleClusters, scaleSpaceGroups, scaleSpacePlan, screen, screenInputs, screenSplit, searchPlan, searchScore, sectionsRouter, segmentBounds, segmentBoxDistance, segmentClusters, segmentDistance, segmentHitsBox, segmentHitsRect, segmentKey, segmentsCross, segmentsOf, selectBest, selectPlan, setManifest, sha256Hex, shapeSkeleton, sharedRouter, sharedStretchStrategy, sharedStretches, sharedWaysAll, sharedWaysPlan, shuffleEdges, sideAngle, sideToward, skeletonGroups, skeletonPath, slackSettings, smoothCurve, snapPlan, softDistance, softKeyClusters, softKeyPlan, spanningTree, spectralClusters, spectralLabels, spectralPlan, spinePart, spiralJoin, spiralPlan, spiralTree, splineCurve, splitPath, splitPoint, stableIdGate, stableIdPlan, stableOrder, stableOrderStrategy, steinerPlan, stepRouterStrategy, stepRouters, stepSeed, straightCurve, straightRouter, strategyKey, streetEdges, streetPlan, streetPoint, streetRide, stretchGate, stretchLaneOrders, stretchPlan, stretchSettings, stubPlan, suiteFronts, sumFaults, summarize, summarizeGap, summarizeRows, sweepGrid, sweepOf, sweepRoom, sweepSections, sweepValues, symmetricEigen, territoryPlan, toSvgPath, totalTurn, tracePlan, traclusPlan, treeCost, treeDepth, trunksRouter, turns, unwrappedName, utf8, waypointWay, weberPoint, weiszfeldPlan, wholeStrategies, withBends, withRepair, withStableOrder, wspdGroups, wspdPlan, zipLegs, zipperPlan };
+export { AMBIGUITY_GUARD_DEFAULTS, ARC_SOURCES, AREA_DEFAULTS, AREA_WIDTHS, ATTRACTION_DEFAULTS, ATTRACTION_SCHEMA, BACKTRACK_MIN, BACKTRACK_SHARE, BREAK, BREAK_EVEN, BREAK_EVEN_DEFAULTS, BUILT_IN_STRATEGIES, BoundaryWalk, CANDIDATE_SOURCES, CAP_SWEEP, CASES, CHANNEL_REACH, CLEARANCE_CAP, COMPARE_ALL_STEPS, COMPARE_STEPS, CONFLUENT_DEFAULTS, CONSENSUS_DEFAULTS, CONSENSUS_LINKAGES, CORRIDOR_DEFAULTS, CROSSBAR_DEFAULTS, CUBU_DEFAULTS, CURVE_TYPES, CUT_DEFAULTS, CornerGraph, DEFAULT_RNG, DENSE_GROUPS, DENSITY_KERNELS, DIFFUSION_DEFAULTS, DISTORTION_NEIGHBOURS, DIVIDED_DEFAULTS, EDGE_DISTANCES, EDGE_PATH_DEFAULTS, EXACT_CLASSES, EXACT_EDGES_PER_NODE, EXACT_V1, EXACT_V1_BOUNDS, EXACT_V1_BOUNDS_SIZES, EXACT_V1_SEEDS, EXACT_V1_SIZES, FDEB_DEFAULTS, FIXTURES, FIXTURE_LAYOUTS, FIXTURE_LOCALITY, FLOW_CLUSTER_DEFAULTS, FLOW_FIELD_DEFAULTS, FRECHET_DEFAULTS, FRONT_OBJECTIVES, GAP_BASELINES, GAP_BOOTSTRAP, GAP_CAPS, GAP_DEFAULTS, GAP_RULES, GAP_VIEWS, GROUP_SCOPES, GROUP_SPINES, GROWTH_DEFAULTS, GROWTH_SWEEP, Grid, HDBSCAN_DEFAULTS, HIERARCHY_DEFAULTS, HIERARCHY_GROUPS, HIGHWAYS_ENGINE, HIGHWAYS_FAMILIES, HIGHWAY_BASES, HIGHWAY_BASE_ROUTERS, HOUGH_DEFAULTS, HUB_ALLOCATIONS, HUB_ARC_DEFAULTS, HUB_CANDIDATES, HUB_CHAIN, HYSTERESIS_DEFAULTS, INTERCHANGE_BASES, INTERCHANGE_DEFAULTS, KDEEB_DEFAULTS, KD_DEFAULTS, KENDALL_EXACT, LANES_DEFAULTS, LANE_ORDERS, LANE_STRETCH_DEFAULTS, LANE_STRETCH_ORDERS, LANE_TRACKS, LEVEL_HIGHWAY_DEFAULTS, LINKAGES, LINK_COMMUNITY_DEFAULTS, MANY_GROUPS, MEASURES, MEASURE_LANE_WIDTH, MEET_DEFAULTS, MEMBER_FORMS, MESH_DEFAULTS, MINGLE_DEFAULTS, MIN_EFFECTS, MLSEB_DEFAULTS, MLS_FITS, MODULE_RULES, MOVE_NAMES, NESTED_DEFAULTS, OD_CELL_DEFAULTS, OUTSIDE_SLACK, Obstacles, PACKED_GRID, PICK, PLAN_CHANGERS, PORTFOLIO_B1, PORTFOLIO_BANDS, PORTFOLIO_BASE_MEMBER, PORTFOLIO_CAPS, PORTFOLIO_FIT, PORTFOLIO_HASHES, PORTFOLIO_KS_API, PORTFOLIO_RULES, PORTFOLIO_SETS, POWER_DEFAULTS, PROPOSED_RULES, P_HUB_DEFAULTS, QUICKBUNDLES_DEFAULTS, RECORD_EPS, RESISTANCE_DEFAULTS, RIDGE_DEFAULTS, ROAD_CLASS_DEFAULTS, ROOM_FAMILIES, ROUTED_STEPS, ROUTERS, SAME_HIGHWAY, SBEB_DEFAULTS, SCALE_SPACE_DEFAULTS, SCREEN_FAMILY_BY, SCREEN_RULES, SCREEN_SETS, SCREEN_STEPS, SCREEN_V1, SCREEN_V2, SCREEN_V2_HELD_OUT, SCREEN_WRAPS, SEARCH_DEFAULTS, SEARCH_MOVES, SECTION_DEFAULTS, SELECT_DEFAULTS, SIDE_NORMAL, SKELETON_GROUPS, SKELETON_TARGETS, SLACK_SWEEP, SMALL_CLUSTERED, SOFT_KEY_DEFAULTS, SPACING_LIMIT, SPECTRAL_DEFAULTS, SPIRAL_DEFAULTS, STABLE_ID_DEFAULTS, STEINER_DEFAULTS, STEINER_GROUPS, STEINER_METHODS, STEINER_METRICS, STEPS, STRATEGIES, STREET_DEFAULTS, STREET_SOURCES, STRETCH_DEFAULTS, STRETCH_SWEEP, STUB_DEFAULTS, SUITE_COLUMNS, SoftGraph, SplitTree, TERRITORY_DEFAULTS, TERRITORY_POINTS, TINY_UNIFORM, TOLERANCE, TRACLUS_DEFAULTS, TRAFFIC_RULES, WEISZFELD_DEFAULTS, WSPD_DEFAULTS, WayFinder, ZIPPER_DEFAULTS, activationBase, activationReport, adjustedRandIndex, allSections, ambiguity, ambiguityGate, ambiguityPlan, arcCurve, areaPlan, asRouter, attractionRouter, attractionStrategy, backtrackOf, balance, basePlan, benchBendRoom, benchCurveStrategies, benchCurves, benchHighways, benchLevelRoom, benchOne, benchRoom, benchRun, benchTracks, bendCount, bendingEnergy, bicliqueGroups, bigGroups, boardGaps, boardUnit, boardWins, bootstrapMedian, boundsFamilyName, boxDisplacement, boxExit, boxPush, boxUnit, boxesOverlap, breakEvenGate, breakEvenPlan, buildSections, bundleStretch, bundledShare, byCollection, byDataGroup, candidateArcs, candidatePlan, candidateScore, canonicalJson, capSettings, caseSeed, cellSteps, center, chainClusters, changeGraph, changedDimensions, channelOverflows, channelWidth, characteristicPoints, checkFamilies, checkLevels, checkOptions, checkParents, checkPlan, checkPort, checkProperties, checkSchema, checkSections, clampOptions, clothoidCurve, clusters1d, coAssociation, commonEdges, compareAnyStep, compareMeasure, compareSpec, compareStep, compatibility, compatibilityMatrix, confluentPlan, consensusGroups, consensusLabels, consensusPlan, controlChain, cornersRouter, corpusManifest, corridorPlan, countCrossings, countOverlaps, createFamilyRegistry, createRegistry, crossbarPlan, crossesItself, crossingAngle, crossingAngles, cubicAt, cubuPlan, curvatureVariation, curveDeviation, curveFaults, curveJoints, curveOf, curveRuns, curveSpace, curveStrategies, curvesHash, cutGroups, cutShare, declaresFamily, defineStrategy, denseGroupsBoard, densityPlan, densityRidges, depthLevels, detourSpread, diffusionPlan, dimensionAt, dimensionUnit, dist, distanceDistortion, distinctPoints, divideHighway, dividedPlan, documentHash, dominates, drawnSegments, edgeBlocks, edgeEnds, edgeLengths, edgePathPlan, edgePaths, edgePlugs, edgeResistance, enumDimension, exactBoard, exactFamily, exactGenerator, exactSeed, exactStretch, exactStretches, exercised, facingEnds, familyCell, familyKind, familyOf, familySeed, farLevel, farLinks, fdebLines, fdebPlan, fft, findStrategy, finderOf, firstLines, fixedPortPoint, fixtureGroupOptions, fixtureParams, fixtureRngSeed, fixtureSpecOf, flowClusterPlan, flowClusters, flowDistance, flowFieldPlan, fnv1a32, follow, formatActivation, formatBendRoom, formatCapped, formatCurves, formatFaults, formatFronts, formatGap, formatHighways, formatInput, formatLevelRoom, formatLevels, formatMeasureTime, formatPaired, formatRoom, formatRules, formatScreen, formatSections, formatSummaries, formatTable, formatTracks, frameRoutes, frechet, frechetBundles, frechetPlan, freeLines, g1Defect, g2Defect, gapBaselines, gapCap, gapClosed, gapLaneCounts, gapLanes, gapNames, gapPlan, gapValues, gateStrategy, getStrategy, goesOutAndBack, graphInput, greedyBicliques, greedyCrossbars, groupEdges, groupFill, groupRun, groupSettings, groupStability, groupStrategies, groupedPlan, growthPlan, growthSettings, guardBreaks, hasCusp, hdbscanClusters, hdbscanLabels, hdbscanPlan, hierarchyPlan, highwayChurn, highwayCurve, highwayCurves, highwayEdits, highwayIdKeep, highwayMoves, highwayRouter, highwayRouterStrategy, highwayRouters, highwayStrategies, highwaysRegistry, houghLines, houghPeaks, houghPlan, hubArcPlan, hubCandidates, hubChainBoard, hysteresisGate, hysteresisPlan, inflate, inflectionCount, inflectionCurve, inflectionSector, inkSaved, innerPoints, inputGraph, inputId, interchangeCandidates, interchangePlan, isRoutedStep, itemOverlaps, itemSizes, jaccard, jaccardIndex, jogPeaks, joinReports, jsonSafe, kMeans, kdGroups, kdeebLines, kdeebPlan, keepMembers, kendallTau, keyGroups, keyedSections, keysPlan, labelGroups, laneArea, laneCrossings, laneFidelity, laneOrder, laneRoutes, laneSeparation, laneSettings, laneStretches, lanesPlan, lanesThrough, leafGroups, lengthBetween, levelCut, levelGrouping, levelHighwayPlan, levelMeasures, levelPairs, levelRatio, levelRoom, levelStrategies, levelsOf, lineDensity, linePoint, linkAgreement, linkCommunities, linkCommunityGroups, linkCommunityPlan, linkDensity, listOptions, listStrategies, makeFixture, makeRoom, manifestHash, manyGroupsBoard, matchHighways, maxStretch, mdf, meanLine, measureBoard, measureByKey, measureByName, measureHighways, measureJogs, measureLevel, measureLevelFaults, measureLinks, measureName, measureQuality, measureRouteFaults, measureStability, meetMember, meetPlan, meetingPoints, memberAt, memberStrategy, mergeAngle, meshPlan, meshWaypoints, minEffectOf, minHash, mingleBundles, minglePlan, mixedSegments, mixesCollections, mlsPoint, mlsebLines, mlsebPlan, modularity, modulesOf, mulberry32, namedObjectives, nearestCentre, nearestOnBoundary, nearestOnLine, nearestSide, nearestSkeleton, nestedGridBoard, nestedGroups, nestedPlan, nestingFaults, nestingViolations, nextRow, nodeAmbiguity, nodeIndex, nodeLinks, numberDimension, numberOf, occupiedArea, odCellPlan, odGroups, offsetLine, offsetPolyline, oneSteiner, openGaps, openLanes, optimaFile, optimumKey, optionDefaults, orderChanges, orderFragility, orderLanes, orderRows, orderStability, orderSuiteRows, orthogonality, outOfBoxes, outerGraph, outputGroups, outputHash, pHubPlan, pMedian, packedGridBoard, paramProblem, paretoFront, parseLines, partWithin, passSettings, pathPoints, peakCurvature, pickLevel, pickMoves, placePlug, planMoves, planOfResult, plugSpacing, plugStrategies, plugsRouter, pointAt, pointBoxDistance, pointDensity, pointGroups, pointOnSide, pointSegmentDistance, polylineLength, portOffset, portfolio, portfolioB1Spec, portfolioBand, portfolioFacts, portfolioKey, portfolioMember, portfolioMembers, portfolioName, portfolioRouter, portfolioStrategy, positionStability, powerPlan, pullApart, quadtreeGroups, quantile, quickBundles, quickBundlesPlan, randomInt, rayToBox, recordLines, recordMoves, rectScattered, regionBounds, register, repairResult, repairStrategy, representative, resample, resistanceClusters, resistancePlan, resolvePorts, resultForm, resultHash, ridgeLines, ridgePlan, rng, roadClassPlan, roomDemand, roomLinks, roomOrderFaults, roomStrategies, roomValues, round3, roundCorners, roundedCurve, routeCrossings, routeInStableOrder, routeMeasures, routePortfolio, routeSeparation, routeStability, routeSymmetry, routerStrategies, routersOf, ruleCounts, runBenchmark, runKey, runPipeline, runProfile, runSuite, sameData, sampleCurve, samplesOf, sbebLines, sbebPlan, scaleClusters, scaleSpaceGroups, scaleSpacePlan, screen, screenInputs, screenSplit, searchPlan, searchScore, sectionsRouter, segmentBounds, segmentBoxDistance, segmentClusters, segmentDistance, segmentHitsBox, segmentHitsRect, segmentKey, segmentsCross, segmentsOf, selectBest, selectPlan, setManifest, sha256Hex, shapeSkeleton, sharedRouter, sharedStretchStrategy, sharedStretches, sharedWaysAll, sharedWaysPlan, shuffleEdges, sideAngle, sideToward, silhouette, skeletonGroups, skeletonPath, slackSettings, smoothCurve, snapPlan, softDistance, softKeyClusters, softKeyPlan, spanningTree, spectralClusters, spectralLabels, spectralPlan, spinePart, spiralJoin, spiralPlan, spiralTree, splineCurve, splitFrames, splitPath, splitPoint, stableIdGate, stableIdPlan, stableOrder, stableOrderStrategy, steinerPlan, stepRouterStrategy, stepRouters, stepSeed, straightCurve, straightRouter, strategyKey, streetEdges, streetPlan, streetPoint, streetRide, stretchGate, stretchLaneOrders, stretchPlan, stretchSettings, stubPlan, suiteFronts, sumFaults, summarize, summarizeGap, summarizeRows, sweepGrid, sweepOf, sweepRoom, sweepSections, sweepValues, symmetricEigen, territoryPlan, toSvgPath, totalTurn, tracePlan, traclusPlan, treeCost, treeDepth, trunksRouter, turns, unwrappedName, utf8, waypointWay, weberPoint, weiszfeldPlan, wholeBoard, wholeStrategies, withBends, withRepair, withStableOrder, wspdGroups, wspdPlan, zipLegs, zipperPlan };
 
 //# sourceMappingURL=index.js.map