@mark1russell7/highways 0.1.2 → 0.1.4

package/build/index.js

@@ -228,6 +228,53 @@ var Grid = class {
 			}
 		}
 	}
+	/**
+	* This method gives each item in the buckets along the segment `ab`, widened by `margin`, to `visit`, one time each.
+	* The buckets are those of `#segment`, in the same order, so the items come in the same order.
+	* A bucket in the range of the step before has no new item, so the walk skips it.
+	* The walk stops when `visit` gives true, and then the method gives true.
+	*/
+	#walk(a, b, margin, visit) {
+		const stamp = ++this.#stamp;
+		const c = this.#cell;
+		const items = this.#items;
+		const n = Math.max(1, Math.ceil(Math.hypot(b.x - a.x, b.y - a.y) / (c / 2)));
+		let px = a.x;
+		let py = a.y;
+		let pi0 = 1;
+		let pi1 = 0;
+		let pj0 = 1;
+		let pj1 = 0;
+		for (let k = 1; k <= n; k++) {
+			const qx = k === n ? b.x : a.x + (b.x - a.x) * k / n;
+			const qy = k === n ? b.y : a.y + (b.y - a.y) * k / n;
+			const i0 = Math.floor((Math.min(px, qx) - margin) / c);
+			const j0 = Math.floor((Math.min(py, qy) - margin) / c);
+			const i1 = Math.floor((Math.max(px, qx) + margin) / c);
+			const j1 = Math.floor((Math.max(py, qy) + margin) / c);
+			const seen = this.#seen;
+			for (let i = i0; i <= i1; i++) {
+				const before = i >= pi0 && i <= pi1;
+				for (let j = j0; j <= j1; j++) {
+					if (before && j >= pj0 && j <= pj1) continue;
+					const list = this.#buckets.get(this.#key(i, j));
+					if (list === void 0) continue;
+					for (const id of list) {
+						if (seen[id] === stamp) continue;
+						seen[id] = stamp;
+						if (visit(items[id]) === true) return true;
+					}
+				}
+			}
+			pi0 = i0;
+			pi1 = i1;
+			pj0 = j0;
+			pj1 = j1;
+			px = qx;
+			py = qy;
+		}
+		return false;
+	}
 	#segment(a, b, margin, each) {
 		const n = Math.max(1, Math.ceil(Math.hypot(b.x - a.x, b.y - a.y) / (this.#cell / 2)));
 		let px = a.x;
@@ -255,8 +302,16 @@ var Grid = class {
 	}
 	/** This method gives each item whose buckets come within `margin` of the segment `ab` to `visit`, one time each. */
 	querySegment(a, b, margin, visit) {
-		const stamp = ++this.#stamp;
-		this.#segment(a, b, margin, (x0, y0, x1, y1) => this.#take(stamp, x0, y0, x1, y1, visit));
+		this.#walk(a, b, margin, (item) => {
+			visit(item);
+		});
+	}
+	/**
+	* This method tells if `test` gives true for an item whose buckets come within `margin` of the segment `ab`.
+	* It gives the items in the order of `querySegment`, and it stops at the first item that passes the test.
+	*/
+	someSegment(a, b, margin, test) {
+		return this.#walk(a, b, margin, test);
 	}
 };
 /** This function gives the bounding box of the segment `ab`. */
@@ -546,6 +601,151 @@ function makeEdges(spec, nodes, clusterOf, R) {
 	}
 	return edges;
 }
+// src/cases.ts
+/** A board while it grows: the functions add nodes and edges in order. */
+var Board = class {
+	nodes = [];
+	edges = [];
+	#pairs = /* @__PURE__ */ new Set();
+	node(id, x, y, w, h) {
+		this.nodes.push({
+			id,
+			box: {
+				x,
+				y,
+				w,
+				h
+			}
+		});
+		return id;
+	}
+	/** This method adds an edge. It adds nothing for a loop or for a second edge between the same two nodes. */
+	link(source, target) {
+		const key = source < target ? `${source}|${target}` : `${target}|${source}`;
+		if (source === target || this.#pairs.has(key)) return;
+		this.#pairs.add(key);
+		this.edges.push({
+			id: `e${this.edges.length}`,
+			source: { node: source },
+			target: { node: target }
+		});
+	}
+	graph() {
+		return {
+			nodes: this.nodes,
+			edges: this.edges
+		};
+	}
+};
+/**
+* This function makes a dense board: 150 nodes in tight clusters. At the far view, the boxes of the groups overlap.
+* Then a level link starts or ends in a group that another group covers.
+*/
+function denseGroupsBoard() {
+	return makeFixture({
+		name: "dense-groups",
+		kind: "clustered",
+		nodes: 150,
+		edgesPerNode: 2,
+		seed: 3
+	});
+}
+/**
+* This function makes a board of three rows of 32 cards. Each card links to the next card of its row.
+* Forty long links join cards far apart. The hub of a section is near the middle of its cards.
+* So a long link climbs to hubs behind its source or past its target, and comes back.
+*/
+function hubChainBoard() {
+	const R = rng(3);
+	const b = new Board();
+	const rows = 3;
+	const cols = 32;
+	const id = (r, c) => `c${r}-${c}`;
+	for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) b.node(id(r, c), c * 128, r * 84, 80, 36);
+	for (let r = 0; r < rows; r++) for (let c = 0; c + 1 < cols; c++) b.link(id(r, c), id(r, c + 1));
+	for (let n = 0; n < 40; n++) {
+		const r = Math.floor(R() * rows);
+		const c = Math.floor(R() * cols);
+		const span = Math.floor(cols / 8 + R() * cols / 2);
+		if (c + span < cols) b.link(id(r, c), id((r + 1) % rows, c + span));
+	}
+	return b.graph();
+}
+/**
+* This function makes a board of 32 groups in 8 columns and 4 rows. Each group has 4 cards in a square.
+* The cards of a group link in a chain, and 96 random links join cards of two groups.
+* On a level with many groups, some level links go around the outer edge of the board.
+*/
+function manyGroupsBoard() {
+	const R = rng(7);
+	const b = new Board();
+	const cols = 8;
+	const rows = 4;
+	const per = 4;
+	const w = 60;
+	const h = 30;
+	const cardGap = 12;
+	const side = Math.ceil(Math.sqrt(per));
+	Math.ceil(per / side) * h + (Math.ceil(per / side) - 1) * cardGap;
+	const groups = [];
+	for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
+		const list = [];
+		for (let i = 0; i < per; i++) {
+			const x = c * 192 + i % side * 72;
+			const y = r * 132 + Math.floor(i / side) * 42;
+			list.push(b.node(`g${r}-${c}-${i}`, x, y, w, h));
+		}
+		groups.push(list);
+	}
+	for (const list of groups) for (let i = 1; i < list.length; i++) b.link(list[i - 1], list[i]);
+	const pick = (list) => list[Math.floor(R() * list.length)];
+	for (let n = 0; n < groups.length * 3; n++) b.link(pick(groups[Math.floor(R() * groups.length)]), pick(groups[Math.floor(R() * groups.length)]));
+	return b.graph();
+}
+/**
+* This function makes the far view of a board after a host layout packs it.
+* The board has 96 boxes of one size in a grid of 12 columns and 8 rows.
+* The boxes touch, with no gap between them. Each box links to a box near it, and 48 long links join boxes far apart.
+* The links have no channel between the boxes. The roadmap item ROOM measures this board before and after `makeRoom`.
+*
+* The board is not in `CASES`, because the digests of the router fix the output on each board of `CASES`.
+*/
+function packedGridBoard() {
+	const R = rng(11);
+	const b = new Board();
+	const cols = 12;
+	const rows = 8;
+	const w = 140;
+	const h = 90;
+	const id = (r, c) => `p${r}-${c}`;
+	for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) b.node(id(r, c), c * w, r * h, w, h);
+	const step = () => Math.floor(R() * 5) - 2;
+	for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
+		const rr = Math.max(0, Math.min(7, r + step()));
+		const cc = Math.max(0, Math.min(11, c + step()));
+		b.link(id(r, c), id(rr, cc));
+	}
+	for (let n = 0; n < 48; n++) b.link(id(Math.floor(R() * rows), Math.floor(R() * cols)), id(Math.floor(R() * rows), Math.floor(R() * cols)));
+	return b.graph();
+}
+/** The case boards of the benchmark. Each board has a few hundred nodes at most, so the benchmark races them on each run. */
+const CASES = [
+	{
+		name: "case-dense-groups",
+		defect: "Groups overlap at the far view, and level links go through other groups.",
+		make: denseGroupsBoard
+	},
+	{
+		name: "case-hub-chain",
+		defect: "A route climbs a chain of hubs away from its target and comes back.",
+		make: hubChainBoard
+	},
+	{
+		name: "case-many-groups",
+		defect: "On a level with many groups, links go around the outer edge of the board.",
+		make: manyGroupsBoard
+	}
+];
 // src/plugs.ts
 /** The outward normal of each side, in a frame with the y axis down. */
 const SIDE_NORMAL = {
@@ -714,6 +914,582 @@ function roundCorners(p, radius, steps = 4) {
 	out.push(p[p.length - 1]);
 	return out;
 }
+// src/curves/model.ts
+/** The curve types, in the order of the benchmark. */
+const CURVE_TYPES = [
+	"straight",
+	"rounded",
+	"spline",
+	"arc"
+];
+/** This function gives the points of a polyline without the points that are nearer than `eps` to the point before them. */
+function distinctPoints(points, eps = 1e-9) {
+	const out = [];
+	for (const p of points) {
+		const q = out[out.length - 1];
+		if (q === void 0 || Math.hypot(p.x - q.x, p.y - q.y) > eps) out.push(p);
+	}
+	return out;
+}
+// src/bench/properties.ts
+/** The tolerance of the hard rules, in units of the plane. */
+const TOLERANCE = .5;
+/**
+* This function checks the hard rules of a result. Each edge has one route, and each route starts and ends at its nodes.
+* Fixed plugs stay in place. No route goes through a node that is not one of its ends. The counts of each level add up.
+* Each link of a level starts on the box of its source and ends on the box of its target.
+*
+* Each route of a bundle starts with its trunk, and an edge is in one bundle at most.
+* Each run has two edges or more, and the route of each edge holds the points of the run in a row.
+* The function gives at most `limit` violations.
+*/
+function checkProperties(graph, result, limit = 100) {
+	const out = [];
+	const add = (v) => {
+		out.push(v);
+		return out.length >= limit;
+	};
+	const byId = nodeIndex(graph);
+	const grid = new Grid(180);
+	for (const n of graph.nodes) grid.add(n, n.box);
+	const routes = /* @__PURE__ */ new Map();
+	for (const r of result.routes) routes.set(r.edge, r);
+	for (const e of graph.edges) {
+		const r = routes.get(e.id);
+		const s = byId.get(e.source.node);
+		const t = byId.get(e.target.node);
+		if (!s || !t) continue;
+		if (!r || r.points.length < 2) {
+			if (add({
+				rule: "complete",
+				edge: e.id,
+				detail: "no route"
+			})) return out;
+			continue;
+		}
+		const a = r.points[0];
+		const b = r.points[r.points.length - 1];
+		if (pointBoxDistance(a, s.box) > .5 || pointBoxDistance(b, t.box) > .5) {
+			if (add({
+				rule: "ends-at-plugs",
+				edge: e.id,
+				detail: "an end of the route is away from its node"
+			})) return out;
+		}
+		const fs = fixedPortPoint(s, e.source);
+		const ft = fixedPortPoint(t, e.target);
+		if (fs && dist(fs, a) > .5 || ft && dist(ft, b) > .5) {
+			if (add({
+				rule: "fixed-plugs",
+				edge: e.id,
+				detail: "the route does not start or end at its fixed plug"
+			})) return out;
+		}
+		for (let i = 1; i < r.points.length; i++) {
+			const p = r.points[i - 1];
+			const q = r.points[i];
+			let hit;
+			grid.querySegment(p, q, 0, (n) => {
+				if (!hit && n !== s && n !== t && segmentHitsBox(p, q, inflate(n.box, -.5))) hit = n;
+			});
+			if (hit) {
+				if (add({
+					rule: "no-pass-through",
+					edge: e.id,
+					detail: `segment ${i} goes through ${hit.id}`
+				})) return out;
+				break;
+			}
+		}
+	}
+	const bundled = /* @__PURE__ */ new Set();
+	for (const b of result.bundles ?? []) for (const id of b.edges) {
+		const r = routes.get(id);
+		const shares = r !== void 0 && r.points.length >= b.trunk.length && b.trunk.every((p, i) => dist(p, r.points[i]) <= .5);
+		if (bundled.has(id) || !shares) {
+			if (add({
+				rule: "bundle-trunk",
+				edge: id,
+				detail: `bundle ${b.id}: the route is in two bundles or does not start with the trunk`
+			})) return out;
+		}
+		bundled.add(id);
+	}
+	for (const run of result.runs ?? []) {
+		if (run.edges.length < 2) {
+			if (add({
+				rule: "run-shared",
+				detail: `run ${run.id} has fewer than two edges`
+			})) return out;
+		}
+		for (const id of run.edges) {
+			const r = routes.get(id);
+			if (!r || !(holds(r.points, run.points) || holds(r.points, [...run.points].reverse()))) {
+				if (add({
+					rule: "run-shared",
+					edge: id,
+					detail: `run ${run.id}: the route does not hold the points of the run in a row`
+				})) return out;
+			}
+		}
+	}
+	for (const level of result.levels ?? []) {
+		const itemOf = /* @__PURE__ */ new Map();
+		for (const it of level.items) for (const n of it.nodes) itemOf.set(n, it.id);
+		if (itemOf.size !== graph.nodes.length) {
+			if (add({
+				rule: "counts-sum",
+				detail: `level ${level.depth}: the items hold ${itemOf.size} of ${graph.nodes.length} nodes`
+			})) return out;
+		}
+		let between = 0;
+		for (const e of graph.edges) if (itemOf.get(e.source.node) !== itemOf.get(e.target.node)) between++;
+		const sum = level.links.reduce((s, l) => s + l.count, 0);
+		if (sum !== between) {
+			if (add({
+				rule: "counts-sum",
+				detail: `level ${level.depth}: the links count ${sum} edges, not ${between}`
+			})) return out;
+		}
+		const boxOf = new Map(level.items.map((it) => [it.id, it.box]));
+		for (const l of level.links) {
+			const s = boxOf.get(l.source);
+			const t = boxOf.get(l.target);
+			const p = l.points;
+			if (!s || !t || p.length < 2 || !onBoundary(p[0], s) || !onBoundary(p[p.length - 1], t)) {
+				if (add({
+					rule: "link-ends",
+					detail: `level ${level.depth}: the link ${l.source} to ${l.target} does not start and end on the boundaries of its items`
+				})) return out;
+			}
+		}
+	}
+	return out;
+}
+/** This function tells if the point is on the boundary of the box, within `TOLERANCE`. */
+function onBoundary(p, b) {
+	const inner = inflate(b, -.5);
+	return !(p.x > inner.x && p.x < inner.x + inner.w && p.y > inner.y && p.y < inner.y + inner.h) && pointBoxDistance(p, b) <= .5;
+}
+/** This function tells if the polyline `p` holds the points of `part` in a row. */
+function holds(p, part) {
+	if (part.length === 0) return true;
+	for (let i = 0; i + part.length <= p.length; i++) if (part.every((q, j) => dist(q, p[i + j]) <= .5)) return true;
+	return false;
+}
+// src/curves/sample.ts
+/** The largest number of points that `sampleCurve` gives for one segment. */
+const MAX_STEPS = 1024;
+/**
+* This function gives a polyline that follows the curve. The distance from each part of the curve to the polyline is `tolerance` or less.
+* The polyline starts at the point of the `move` and goes through the end of each segment.
+* Hit tests, measures and renderers that draw only lines use this polyline.
+*/
+function sampleCurve(segments, tolerance = .5) {
+	const tol = Math.max(1e-6, tolerance);
+	const out = [];
+	let at;
+	for (const s of segments) {
+		if (s.kind === "move" || at === void 0) {
+			out.push(s.to);
+			at = s.to;
+			continue;
+		}
+		if (s.kind === "cubic") {
+			const d = Math.max(Math.hypot(at.x - 2 * s.c1.x + s.c2.x, at.y - 2 * s.c1.y + s.c2.y), Math.hypot(s.c1.x - 2 * s.c2.x + s.to.x, s.c1.y - 2 * s.c2.y + s.to.y));
+			const n = Math.min(MAX_STEPS, Math.max(1, Math.ceil(Math.sqrt(3 * d / (4 * tol)))));
+			for (let k = 1; k < n; k++) out.push(cubicAt(at, s.c1, s.c2, s.to, k / n));
+		} else if (s.kind === "arc") {
+			const step = s.radius <= tol ? Math.PI : 2 * Math.acos(1 - tol / s.radius);
+			const n = Math.min(MAX_STEPS, Math.max(1, Math.ceil(Math.abs(s.sweep) / step)));
+			for (let k = 1; k < n; k++) {
+				const a = s.start + s.sweep * k / n;
+				out.push({
+					x: s.center.x + s.radius * Math.cos(a),
+					y: s.center.y + s.radius * Math.sin(a)
+				});
+			}
+		}
+		out.push(s.to);
+		at = s.to;
+	}
+	return out;
+}
+/** This function gives the point at the parameter `t` of the cubic Bezier curve with the control points `p0`, `p1`, `p2` and `p3`. */
+function cubicAt(p0, p1, p2, p3, t) {
+	const u = 1 - t;
+	const a = u * u * u;
+	const b = 3 * u * u * t;
+	const c = 3 * u * t * t;
+	const d = t * t * t;
+	return {
+		x: a * p0.x + b * p1.x + c * p2.x + d * p3.x,
+		y: a * p0.y + b * p1.y + c * p2.y + d * p3.y
+	};
+}
+/**
+* This function writes the segments as the data of an SVG path: the commands `M`, `L`, `C` and `A`.
+* Each number has at most `digits` digits after the point.
+*/
+function toSvgPath(segments, digits = 2) {
+	const n = (v) => {
+		const s = String(Number(v.toFixed(digits)));
+		return s === "-0" ? "0" : s;
+	};
+	const p = (q) => `${n(q.x)} ${n(q.y)}`;
+	const parts = [];
+	for (const s of segments) if (s.kind === "move") parts.push(`M ${p(s.to)}`);
+	else if (s.kind === "line") parts.push(`L ${p(s.to)}`);
+	else if (s.kind === "cubic") parts.push(`C ${p(s.c1)} ${p(s.c2)} ${p(s.to)}`);
+	else parts.push(`A ${n(s.radius)} ${n(s.radius)} 0 ${Math.abs(s.sweep) > Math.PI ? 1 : 0} ${s.sweep > 0 ? 1 : 0} ${p(s.to)}`);
+	return parts.join(" ");
+}
+// src/curves/space.ts
+/**
+* This function makes the free space of a board from its boxes. The boxes are the nodes, or the items of a zoom level.
+* The curves sample each piece within `tolerance` of the curve for the test.
+*/
+function curveSpace(boxes, tolerance = .25) {
+	const inner = boxes.map((b) => inflate(b, -.5));
+	let size = 0;
+	for (const b of boxes) size += Math.max(b.w, b.h);
+	const grid = new Grid(Math.max(180, 2 * size / Math.max(1, boxes.length)));
+	inner.forEach((b, i) => grid.add(i, b));
+	const hits = (p) => {
+		const out = /* @__PURE__ */ new Set();
+		for (let i = 1; i < p.length; i++) {
+			const a = p[i - 1];
+			const b = p[i];
+			grid.querySegment(a, b, 0, (id) => {
+				if (!out.has(id) && segmentHitsBox(a, b, inner[id], .5)) out.add(id);
+			});
+		}
+		return out;
+	};
+	return {
+		boxes,
+		tolerance,
+		addsHit(q, p) {
+			let before;
+			for (let i = 1; i < q.length; i++) {
+				const a = q[i - 1];
+				const b = q[i];
+				if (grid.someSegment(a, b, 0, (id) => {
+					if (!segmentHitsBox(a, b, inner[id], .5)) return false;
+					before ??= hits(p);
+					return !before.has(id);
+				})) return true;
+			}
+			return false;
+		}
+	};
+}
+/**
+* This function finds the largest size from `max` down to 0 that keeps a piece of a curve clear.
+* A clear piece goes through no box that its polyline avoids.
+*
+* The function `piece` gives the segments of the piece at a size. They start with a `move`.
+* The polyline `chord` is the part of the original polyline that the piece replaces.
+* The function tries `max` first, then it halves the interval `steps` times. The result is 0 when no size of the search is clear.
+*/
+function fitSize(space, max, chord, piece, steps = 8) {
+	if (space === void 0 || max <= 0) return Math.max(0, max);
+	const clear = (size) => !space.addsHit(sampleCurve(piece(size), space.tolerance), chord(size));
+	if (clear(max)) return max;
+	let lo = 0;
+	let hi = max;
+	for (let i = 0; i < steps; i++) {
+		const mid = (lo + hi) / 2;
+		if (clear(mid)) lo = mid;
+		else hi = mid;
+	}
+	return lo;
+}
+// src/curves/arc/index.ts
+/** A turn smaller than this angle, in radians, is no corner. A turn nearer to a half turn than this angle stays sharp. */
+const FLAT = 1e-6;
+/**
+* This function puts a circular arc at each inner vertex of a polyline. The arc is tangent to the two legs of its corner.
+* The tangent points stay on the first half of each leg, so the ends of the polyline stay.
+* With `space`, the function makes the radius of a corner smaller until the arc goes through no box that the polyline avoids.
+* On a polyline with only horizontal and vertical legs, each arc is a quarter circle.
+*/
+function arcCurve(points, options = {}) {
+	const p = distinctPoints(points);
+	if (p.length === 0) return [];
+	const radius = options.radius ?? 12;
+	const out = [{
+		kind: "move",
+		to: p[0]
+	}];
+	for (let i = 1; i + 1 < p.length; i++) {
+		const a = p[i - 1];
+		const v = p[i];
+		const b = p[i + 1];
+		const la = dist(a, v);
+		const lb = dist(v, b);
+		const ux = (v.x - a.x) / la;
+		const uy = (v.y - a.y) / la;
+		const wx = (b.x - v.x) / lb;
+		const wy = (b.y - v.y) / lb;
+		const turn = Math.atan2(ux * wy - uy * wx, ux * wx + uy * wy);
+		if (Math.abs(turn) < FLAT || Math.PI - Math.abs(turn) < FLAT) {
+			out.push({
+				kind: "line",
+				to: v
+			});
+			continue;
+		}
+		const k = Math.tan(Math.abs(turn) / 2);
+		const side = Math.sign(turn);
+		const ends = (r) => [{
+			x: v.x - ux * r * k,
+			y: v.y - uy * r * k
+		}, {
+			x: v.x + wx * r * k,
+			y: v.y + wy * r * k
+		}];
+		const piece = (r) => {
+			const [p1, p2] = ends(r);
+			const center = {
+				x: p1.x - side * uy * r,
+				y: p1.y + side * ux * r
+			};
+			return [{
+				kind: "arc",
+				center,
+				radius: r,
+				start: Math.atan2(p1.y - center.y, p1.x - center.x),
+				sweep: turn,
+				to: p2
+			}];
+		};
+		const r = fitSize(options.space, Math.min(radius, Math.min(la, lb) / (2 * k)), (s) => [
+			ends(s)[0],
+			v,
+			ends(s)[1]
+		], (s) => [{
+			kind: "move",
+			to: ends(s)[0]
+		}, ...piece(s)]);
+		if (r <= 0) {
+			out.push({
+				kind: "line",
+				to: v
+			});
+			continue;
+		}
+		const [p1] = ends(r);
+		if (dist(p1, out[out.length - 1].to) > 1e-9) out.push({
+			kind: "line",
+			to: p1
+		});
+		out.push(...piece(r));
+	}
+	if (p.length > 1) out.push({
+		kind: "line",
+		to: p[p.length - 1]
+	});
+	return out;
+}
+// src/curves/rounded/index.ts
+/**
+* This function rounds each inner vertex of a polyline with a quadratic Bezier curve, as `roundCorners` does.
+* The curve of a corner starts and ends at most `radius` from the vertex, and at most half of each leg. The ends of the polyline stay.
+* The function gives each quadratic curve as the same cubic curve. With `space`, it makes the radius of a corner smaller until the curve
+* goes through no box that the polyline avoids.
+*/
+function roundedCurve(points, options = {}) {
+	const p = distinctPoints(points);
+	if (p.length === 0) return [];
+	const radius = options.radius ?? 12;
+	const out = [{
+		kind: "move",
+		to: p[0]
+	}];
+	for (let i = 1; i + 1 < p.length; i++) {
+		const a = p[i - 1];
+		const v = p[i];
+		const b = p[i + 1];
+		const la = dist(a, v);
+		const lb = dist(v, b);
+		const ends = (r) => [{
+			x: v.x + (a.x - v.x) * r / la,
+			y: v.y + (a.y - v.y) * r / la
+		}, {
+			x: v.x + (b.x - v.x) * r / lb,
+			y: v.y + (b.y - v.y) * r / lb
+		}];
+		const piece = (r) => {
+			const [p1, p2] = ends(r);
+			return [{
+				kind: "cubic",
+				c1: {
+					x: p1.x + 2 * (v.x - p1.x) / 3,
+					y: p1.y + 2 * (v.y - p1.y) / 3
+				},
+				c2: {
+					x: p2.x + 2 * (v.x - p2.x) / 3,
+					y: p2.y + 2 * (v.y - p2.y) / 3
+				},
+				to: p2
+			}];
+		};
+		const r = fitSize(options.space, Math.min(radius, la / 2, lb / 2), (s) => [
+			ends(s)[0],
+			v,
+			ends(s)[1]
+		], (s) => [{
+			kind: "move",
+			to: ends(s)[0]
+		}, ...piece(s)]);
+		if (r <= 0) {
+			out.push({
+				kind: "line",
+				to: v
+			});
+			continue;
+		}
+		const [p1] = ends(r);
+		if (dist(p1, at(out)) > 1e-9) out.push({
+			kind: "line",
+			to: p1
+		});
+		out.push(...piece(r));
+	}
+	if (p.length > 1) out.push({
+		kind: "line",
+		to: p[p.length - 1]
+	});
+	return out;
+}
+/** This function gives the end of the last segment. */
+function at(segments) {
+	return segments[segments.length - 1].to;
+}
+// src/curves/spline/index.ts
+/**
+* This function draws a centripetal Catmull-Rom spline through the points of a polyline (Yuksel, Schaefer and Keyser, 2011).
+* Each piece between two points is one cubic Bezier curve. The centripetal knots keep the curve free of cusps and loops in a piece.
+* The curve goes through each point. Its tangent at a point keeps one direction on the two sides of the point.
+*
+* With `space`, the function makes the tangents of a piece shorter until the piece goes through no box that its leg avoids.
+* A piece with no tangent is the straight leg.
+*/
+function splineCurve(points, options = {}) {
+	const p = distinctPoints(points);
+	if (p.length === 0) return [];
+	const out = [{
+		kind: "move",
+		to: p[0]
+	}];
+	const n = p.length;
+	if (n === 1) return out;
+	const scale = 1 - Math.max(0, Math.min(1, options.tension ?? 0));
+	const dt = Array.from({ length: n - 1 }, (_, i) => Math.sqrt(dist(p[i], p[i + 1])));
+	const unit = (q) => {
+		const l = Math.hypot(q.x, q.y);
+		return l === 0 ? {
+			x: 0,
+			y: 0
+		} : {
+			x: q.x / l,
+			y: q.y / l
+		};
+	};
+	const m = p.map((v, i) => {
+		if (i === 0) {
+			const leg = {
+				x: p[1].x - v.x,
+				y: p[1].y - v.y
+			};
+			if (!options.startNormal) return {
+				x: leg.x / dt[0],
+				y: leg.y / dt[0]
+			};
+			const u = unit(options.startNormal);
+			return {
+				x: u.x * dt[0],
+				y: u.y * dt[0]
+			};
+		}
+		if (i === n - 1) {
+			const a = p[i - 1];
+			const leg = {
+				x: v.x - a.x,
+				y: v.y - a.y
+			};
+			if (!options.endNormal) return {
+				x: leg.x / dt[i - 1],
+				y: leg.y / dt[i - 1]
+			};
+			const u = unit(options.endNormal);
+			return {
+				x: -u.x * dt[i - 1],
+				y: -u.y * dt[i - 1]
+			};
+		}
+		const a = p[i - 1];
+		const b = p[i + 1];
+		const t0 = dt[i - 1];
+		const t1 = dt[i];
+		return {
+			x: (v.x - a.x) / t0 - (b.x - a.x) / (t0 + t1) + (b.x - v.x) / t1,
+			y: (v.y - a.y) / t0 - (b.y - a.y) / (t0 + t1) + (b.y - v.y) / t1
+		};
+	});
+	for (let i = 0; i + 1 < n; i++) {
+		const a = p[i];
+		const b = p[i + 1];
+		const h = dt[i] / 3;
+		const piece = (s) => [{
+			kind: "move",
+			to: a
+		}, {
+			kind: "cubic",
+			c1: {
+				x: a.x + m[i].x * h * s,
+				y: a.y + m[i].y * h * s
+			},
+			c2: {
+				x: b.x - m[i + 1].x * h * s,
+				y: b.y - m[i + 1].y * h * s
+			},
+			to: b
+		}];
+		const s = fitSize(options.space, scale, () => [a, b], piece);
+		out.push(s > 0 ? piece(s)[1] : {
+			kind: "line",
+			to: b
+		});
+	}
+	return out;
+}
+// src/curves/straight/index.ts
+/** This function gives the polyline as it is: one `move` to the first point and one `line` to each other point. */
+function straightCurve(points) {
+	return points.map((to, i) => i === 0 ? {
+		kind: "move",
+		to
+	} : {
+		kind: "line",
+		to
+	});
+}
+// src/curves/index.ts
+/**
+* This function gives the curve of a route: a polyline of a router, a lane of `laneRoutes` or a link of a zoom level.
+* The curve starts at the first point and ends at the last point of the polyline.
+* The output is a list of segments for any renderer. `toSvgPath` writes it as SVG path data, and `sampleCurve` gives points.
+*/
+function curveOf(points, options) {
+	switch (options.type) {
+		case "straight": return straightCurve(points);
+		case "rounded": return roundedCurve(points, options);
+		case "spline": return splineCurve(points, options);
+		case "arc": return arcCurve(points, options);
+	}
+}
 // src/visibility.ts
 /** The nodes as obstacles, with a grid for fast tests. */
 var Obstacles = class {
@@ -725,20 +1501,30 @@ var Obstacles = class {
 	}
 	/** This method tells if the segment `ab` stays out of each box, made larger by `pad`. The nodes in `skip` do not count. */
 	clear(a, b, pad, skip) {
-		let ok = true;
-		this.#grid.querySegment(a, b, pad, (n) => {
-			if (ok && !skip?.has(n)) {
-				const x = n.box;
-				if (segmentHitsRect(a, b, x.x - pad, x.y - pad, x.x + x.w + pad, x.y + x.h + pad)) ok = false;
-			}
+		return this.hit(a, b, pad, skip) === void 0;
+	}
+	/**
+	* This method gives a node whose box, made larger by `pad`, the segment `ab` goes into, or `undefined` when the segment is clear.
+	* The nodes in `skip` do not count. The test stops at the first such node.
+	*/
+	hit(a, b, pad, skip) {
+		let found;
+		this.#grid.someSegment(a, b, pad, (n) => {
+			if (skip?.has(n) || !hits(a, b, n, pad)) return false;
+			found = n;
+			return true;
 		});
-		return ok;
+		return found;
 	}
 	/** This method tells if the polyline stays out of each box, made larger by `pad`. The nodes in `skip` do not count. */
 	clearPath(p, pad, skip) {
 		for (let i = 1; i < p.length; i++) if (!this.clear(p[i - 1], p[i], pad, skip)) return false;
 		return true;
 	}
+	/** This method gives each node whose bucket the box touches to `visit`. A node can be outside the box. */
+	query(box, visit) {
+		this.#grid.query(box, visit);
+	}
 	/** This method tells if the point is inside a box, made larger by `pad`. The node `skip` does not count. */
 	inside(p, pad, skip) {
 		let hit = false;
@@ -756,6 +1542,11 @@ var Obstacles = class {
 		return hit;
 	}
 };
+/** This function tells if the segment `ab` goes into the box of the node, made larger by `pad`. */
+function hits(a, b, n, pad) {
+	const x = n.box;
+	return segmentHitsRect(a, b, x.x - pad, x.y - pad, x.x + x.w + pad, x.y + x.h + pad);
+}
 /**
 * A sparse visibility graph. Its vertices are the corners of the boxes, made larger by `margin`.
 * Each corner links to its `k` nearest corners that it can see. A lattice of free points links the groups of nodes.
@@ -776,9 +1567,12 @@ var CornerGraph = class {
 	#open = /* @__PURE__ */ new Int32Array(0);
 	#closed = /* @__PURE__ */ new Int32Array(0);
 	#stamp = 0;
-	#tested = /* @__PURE__ */ new Int32Array(0);
-	#testStamp = 0;
+	#buckets = /* @__PURE__ */ new Map();
+	#dist = /* @__PURE__ */ new Float64Array(0);
+	#near = new MinHeap();
 	#endCache = /* @__PURE__ */ new Map();
+	#fewCache = /* @__PURE__ */ new Map();
+	#part;
 	/** This constructor makes the graph of the nodes. */
 	constructor(nodes, obstacles, options) {
 		this.#obstacles = obstacles;
@@ -830,7 +1624,7 @@ var CornerGraph = class {
 			}
 		}
 		const links = this.points.map(() => /* @__PURE__ */ new Set());
-		for (let i = 0; i < this.points.length; i++) for (const j of this.nearestVisible(this.points[i], this.#k, i)) {
+		for (let i = 0; i < this.points.length; i++) for (const j of this.#nearestVisible(this.points[i], this.#k, i, this.#pad, options.cones ?? false)) {
 			links[i].add(j);
 			links[j].add(i);
 		}
@@ -841,12 +1635,17 @@ var CornerGraph = class {
 		});
 	}
 	#addPoint(c) {
-		this.#pointGrid.add(this.points.length, {
+		const j = this.points.length;
+		this.#pointGrid.add(j, {
 			x: c.x,
 			y: c.y,
 			w: 0,
 			h: 0
 		});
+		const key = bucketKey(Math.floor(c.x / this.#cell), Math.floor(c.y / this.#cell));
+		const list = this.#buckets.get(key);
+		if (list === void 0) this.#buckets.set(key, [j]);
+		else list.push(j);
 		this.points.push(c);
 	}
 	/** This method gives the number of links of the graph. */
@@ -880,28 +1679,80 @@ var CornerGraph = class {
 	nearestVisible(p, k, self = -1) {
 		return this.#nearestVisible(p, k, self, this.#pad);
 	}
-	#nearestVisible(p, k, self, pad) {
+	/**
+	* This method tests the corners in rings of radius `r` = 1, 2, 4 and 8 cells. In each ring, it tests the corners
+	* within `r` that an earlier ring did not test, nearest first, and equal distances by index.
+	* The ring of `r` takes the corners of the buckets that the square of side `2r` around `p` touches.
+	* A corner of these buckets beyond `r` waits for the next ring. So the method visits each bucket one time.
+	* With `cones`, the method also gives the nearest visible corner of each of four cones around the axes that the `k` nearest corners leave empty.
+	*/
+	#nearestVisible(p, k, self, pad, cones = false) {
 		const out = [];
-		if (this.#tested.length < this.points.length) this.#tested = new Int32Array(this.points.length);
-		const tested = this.#tested;
-		const stamp = ++this.#testStamp;
-		for (let r = this.#cell; r <= this.#cell * 8; r *= 2) {
-			const cands = [];
-			this.#pointGrid.query({
-				x: p.x - r,
-				y: p.y - r,
-				w: 2 * r,
-				h: 2 * r
-			}, (j) => {
-				if (j !== self && tested[j] !== stamp) cands.push([dist(p, this.points[j]), j]);
-			});
-			cands.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
-			for (const [d, j] of cands) {
-				if (d > r) break;
-				tested[j] = stamp;
-				if (this.#obstacles.clear(p, this.points[j], pad)) out.push(j);
-				if (out.length >= k) return out;
+		let full = 0;
+		if (this.#dist.length < this.points.length) this.#dist = new Float64Array(this.points.length);
+		const dd = this.#dist;
+		const points = this.points;
+		const cell = this.#cell;
+		const reach = CONE_CELLS * cell;
+		const blockers = [];
+		const now = this.#near;
+		let wait = [];
+		let pi0 = 1;
+		let pi1 = 0;
+		let pj0 = 1;
+		let pj1 = 0;
+		for (let r = cell; r <= cell * 8; r *= 2) {
+			if (out.length >= k && r / 2 >= reach) return out;
+			const x0 = p.x - r;
+			const y0 = p.y - r;
+			const i0 = Math.floor(x0 / cell);
+			const j0 = Math.floor(y0 / cell);
+			const i1 = Math.floor((x0 + 2 * r) / cell);
+			const j1 = Math.floor((y0 + 2 * r) / cell);
+			const later = [];
+			now.clear();
+			for (const j of wait) if (dd[j] > r) later.push(j);
+			else now.add(dd[j], j);
+			for (let bi = i0; bi <= i1; bi++) {
+				const before = bi >= pi0 && bi <= pi1;
+				for (let bj = j0; bj <= j1; bj++) {
+					if (before && bj >= pj0 && bj <= pj1) continue;
+					const list = this.#buckets.get(bucketKey(bi, bj));
+					if (list === void 0) continue;
+					for (const j of list) {
+						if (j === self) continue;
+						const d = dist(p, points[j]);
+						dd[j] = d;
+						if (d > r) later.push(j);
+						else now.add(d, j);
+					}
+				}
 			}
+			now.build();
+			while (now.size > 0) {
+				const j = now.pop();
+				const q = points[j];
+				const cone = cones ? coneOf(q.x - p.x, q.y - p.y) : 0;
+				if (out.length >= k) {
+					if (dd[j] > reach) return out;
+					if ((full & cone) !== 0) continue;
+				}
+				let blocked = false;
+				for (let b = 0; b < blockers.length && !blocked; b++) blocked = hits(p, q, blockers[b], pad);
+				if (blocked) continue;
+				const hit = this.#obstacles.hit(p, q, pad);
+				if (hit !== void 0) blockers.push(hit);
+				else {
+					out.push(j);
+					full |= cone;
+					if (out.length >= k && (!cones || full === 15)) return out;
+				}
+			}
+			wait = later;
+			pi0 = i0;
+			pi1 = i1;
+			pj0 = j0;
+			pj1 = j1;
 		}
 		return out;
 	}
@@ -913,6 +1764,35 @@ var CornerGraph = class {
 	*/
 	path(from, to, cost, floor = 1) {
 		if (this.#obstacles.clear(from, to, this.#pad)) return [from, to];
+		return this.#search([{
+			point: from,
+			cost: 0
+		}], [{
+			point: to,
+			cost: 0
+		}], cost, floor, this.#k * 2)?.points;
+	}
+	/**
+	* This method gives the shortest path from a point of `from` to a point of `to`, or `undefined` when the graph has none.
+	* The cost of a path includes the costs of its two points. One search finds the path, so this method is faster than a call of `path` for each pair.
+	*/
+	pathAmong(from, to) {
+		const found = this.#search(from, to, void 0, 1, this.#k);
+		const lines = [];
+		from.forEach((a, i) => to.forEach((b, k) => {
+			const c = a.cost + dist(a.point, b.point) + b.cost;
+			if (!found || c < found.cost) lines.push({
+				points: [a.point, b.point],
+				from: i,
+				to: k,
+				cost: c
+			});
+		}));
+		lines.sort((u, v) => u.cost - v.cost);
+		return lines.find((l) => this.#obstacles.clear(l.points[0], l.points[1], this.#pad)) ?? found;
+	}
+	/** This method is the search (A*) of `path` and `pathAmong`. */
+	#search(from, to, cost, floor, count) {
 		const n = this.points.length;
 		if (this.#g.length < n) {
 			this.#g = new Float64Array(n);
@@ -921,28 +1801,51 @@ var CornerGraph = class {
 			this.#closed = new Int32Array(n);
 		}
 		const stamp = ++this.#stamp;
+		const points = this.points;
 		const goal = /* @__PURE__ */ new Map();
-		for (const j of this.#ends(to)) goal.set(j, dist(this.points[j], to));
+		const goalOf = /* @__PURE__ */ new Map();
+		to.forEach((b, k) => {
+			for (const j of this.#ends(b.point, count)) {
+				const tail = dist(points[j], b.point) + b.cost;
+				const now = goal.get(j);
+				if (now === void 0 || tail < now) {
+					goal.set(j, tail);
+					goalOf.set(j, k);
+				}
+			}
+		});
 		if (goal.size === 0) return void 0;
+		const starts = from.map((a) => this.#ends(a.point, count));
+		if (!starts.some((list) => this.#joined(list, goal))) return void 0;
 		const heap = new MinHeap();
-		const h = (i) => floor * dist(this.points[i], to);
+		const G = this.#g;
+		const parentOf = this.#parent;
+		const open = this.#open;
+		const closed = this.#closed;
+		const estimate = (p) => {
+			let h = Infinity;
+			for (const b of to) h = Math.min(h, dist(p, b.point));
+			return floor * h;
+		};
 		const relax = (j, g, parent) => {
-			if (this.#closed[j] === stamp) return;
-			if (this.#open[j] === stamp && this.#g[j] <= g) return;
-			this.#open[j] = stamp;
-			this.#g[j] = g;
-			this.#parent[j] = parent;
-			heap.push(g + h(j), j);
+			if (closed[j] === stamp) return;
+			if (open[j] === stamp && G[j] <= g) return;
+			open[j] = stamp;
+			G[j] = g;
+			parentOf[j] = parent;
+			heap.push(g + estimate(points[j]), j);
 		};
-		for (const j of this.#ends(from)) relax(j, dist(from, this.points[j]), -1);
+		from.forEach((a, i) => {
+			for (const j of starts[i]) relax(j, a.cost + dist(a.point, points[j]), -1 - i);
+		});
 		let best = Infinity;
 		let bestEnd = -1;
 		while (heap.size > 0) {
 			if (heap.topKey >= best) break;
 			const i = heap.pop();
-			if (this.#closed[i] === stamp) continue;
-			this.#closed[i] = stamp;
-			const gi = this.#g[i];
+			if (closed[i] === stamp) continue;
+			closed[i] = stamp;
+			const gi = G[i];
 			const tail = goal.get(i);
 			if (tail !== void 0 && gi + tail < best) {
 				best = gi + tail;
@@ -952,28 +1855,67 @@ var CornerGraph = class {
 			const len = this.#len[i];
 			for (let m = 0; m < adj.length; m++) {
 				const j = adj[m];
+				if (closed[j] === stamp) continue;
 				const d = len[m];
 				relax(j, gi + (cost ? cost(i, j, d) : d), i);
 			}
 		}
 		if (bestEnd < 0) return void 0;
-		const out = [to];
-		for (let i = bestEnd; i >= 0; i = this.#parent[i]) out.push(this.points[i]);
-		out.push(from);
-		return out.reverse();
+		const k = goalOf.get(bestEnd);
+		const out = [to[k].point];
+		for (let i = bestEnd;; i = parentOf[i]) {
+			out.push(points[i]);
+			if (parentOf[i] < 0) {
+				const f = -1 - parentOf[i];
+				out.push(from[f].point);
+				return {
+					points: out.reverse(),
+					from: f,
+					to: k,
+					cost: best
+				};
+			}
+		}
+	}
+	/** This method tells if a corner of `starts` and a corner of `goal` are in one connected part of the graph. */
+	#joined(starts, goal) {
+		const part = this.#part ??= this.#parts();
+		const goals = /* @__PURE__ */ new Set();
+		for (const j of goal.keys()) goals.add(part[j]);
+		for (const j of starts) if (goals.has(part[j])) return true;
+		return false;
+	}
+	/** This method gives the number of the connected part of each corner. */
+	#parts() {
+		const part = new Int32Array(this.points.length).fill(-1);
+		const stack = [];
+		let count = 0;
+		for (let i = 0; i < part.length; i++) {
+			if (part[i] !== -1) continue;
+			part[i] = count;
+			stack.push(i);
+			while (stack.length > 0) for (const j of this.#adj[stack.pop()]) {
+				if (part[j] !== -1) continue;
+				part[j] = count;
+				stack.push(j);
+			}
+			count++;
+		}
+		return part;
 	}
 	/**
-	* This method gives the corners that an end of a path can see. An end near a box sees no corner with the clearance.
+	* This method gives at most `count` corners that an end of a path can see. An end near a box sees no corner with the clearance.
 	* Then the end takes the corners that it sees without the clearance, so the path does not cut through the boxes.
 	* The graph does not change, so the method keeps the corners of each end.
 	*/
-	#ends(p) {
+	#ends(p, count) {
+		const cache = count === this.#k * 2 ? this.#endCache : this.#fewCache;
 		const key = `${p.x},${p.y}`;
-		let out = this.#endCache.get(key);
+		let out = cache.get(key);
 		if (!out) {
-			out = this.nearestVisible(p, this.#k * 2);
-			if (out.length === 0) out = this.#nearestVisible(p, this.#k * 2, -1, 0);
-			this.#endCache.set(key, out);
+			out = this.nearestVisible(p, count);
+			if (out.length === 0) out = this.#nearestVisible(p, count, -1, 0);
+			cache.set(key, out);
 		}
 		return out;
 	}
@@ -991,61 +1933,89 @@ var CornerGraph = class {
 		return out;
 	}
 };
-/** A binary min-heap of (key, value) pairs. Equal keys come out by the smaller value, so the order is deterministic. */
+/** A link of a cone is at most this number of cells long. A longer search costs time on a dense level and finds few new links. */
+const CONE_CELLS = 3;
+/** This function gives the bit of the cone of the offset (`dx`, `dy`): 1 is +x, 2 is +y, 4 is -x and 8 is -y. A diagonal offset is in a cone of the x axis. */
+const coneOf = (dx, dy) => Math.abs(dx) >= Math.abs(dy) ? dx > 0 ? 1 : 4 : dy > 0 ? 2 : 8;
+/** This function packs the two indices of a bucket into one number. Each index stays within ±2^20. */
+const bucketKey = (i, j) => (i + 1048576) * 2097152 + (j + 1048576);
+/**
+* A binary min-heap of (key, value) pairs in typed arrays. The pairs come out by key, and equal keys by value, so the order is deterministic.
+* The method `push` adds a pair to the heap. The method `add` only appends a pair, and the method `build` then makes the heap of all the pairs.
+*/
 var MinHeap = class {
-	#k = [];
-	#v = [];
-	get size() {
-		return this.#k.length;
-	}
-	#less(a, b) {
-		return this.#k[a] < this.#k[b] || this.#k[a] === this.#k[b] && this.#v[a] < this.#v[b];
-	}
-	#swap(a, b) {
-		const k = this.#k[a];
-		this.#k[a] = this.#k[b];
-		this.#k[b] = k;
-		const v = this.#v[a];
-		this.#v[a] = this.#v[b];
-		this.#v[b] = v;
-	}
+	#d = /* @__PURE__ */ new Float64Array(64);
+	#j = /* @__PURE__ */ new Int32Array(64);
+	size = 0;
 	/** The smallest key. */
 	get topKey() {
-		return this.#k[0];
+		return this.#d[0];
 	}
 	push(key, value) {
-		this.#k.push(key);
-		this.#v.push(value);
-		let i = this.#k.length - 1;
+		this.add(key, value);
+		const d = this.#d;
+		const jj = this.#j;
+		let i = this.size - 1;
 		while (i > 0) {
 			const p = i - 1 >> 1;
-			if (!this.#less(i, p)) break;
-			this.#swap(i, p);
+			if (!(key < d[p] || key === d[p] && value < jj[p])) break;
+			d[i] = d[p];
+			jj[i] = jj[p];
 			i = p;
 		}
+		d[i] = key;
+		jj[i] = value;
+	}
+	clear() {
+		this.size = 0;
+	}
+	add(d, j) {
+		if (this.size === this.#d.length) {
+			const dd = new Float64Array(2 * this.size);
+			dd.set(this.#d);
+			this.#d = dd;
+			const jj = new Int32Array(2 * this.size);
+			jj.set(this.#j);
+			this.#j = jj;
+		}
+		this.#d[this.size] = d;
+		this.#j[this.size] = j;
+		this.size++;
+	}
+	build() {
+		for (let i = (this.size >> 1) - 1; i >= 0; i--) this.#down(i);
 	}
 	/** This method removes the pair with the smallest key and gives its value. */
 	pop() {
-		const top = this.#v[0];
-		const k = this.#k.pop();
-		const v = this.#v.pop();
-		if (this.#k.length > 0) {
-			this.#k[0] = k;
-			this.#v[0] = v;
-			let i = 0;
-			for (;;) {
-				const l = 2 * i + 1;
-				const r = l + 1;
-				let m = i;
-				if (l < this.#k.length && this.#less(l, m)) m = l;
-				if (r < this.#k.length && this.#less(r, m)) m = r;
-				if (m === i) break;
-				this.#swap(i, m);
-				i = m;
-			}
+		const top = this.#j[0];
+		this.size--;
+		if (this.size > 0) {
+			this.#d[0] = this.#d[this.size];
+			this.#j[0] = this.#j[this.size];
+			this.#down(0);
 		}
 		return top;
 	}
+	#down(i) {
+		const d = this.#d;
+		const jj = this.#j;
+		const n = this.size;
+		const di = d[i];
+		const ji = jj[i];
+		for (;;) {
+			const l = 2 * i + 1;
+			if (l >= n) break;
+			const r = l + 1;
+			let m = l;
+			if (r < n && (d[r] < d[l] || d[r] === d[l] && jj[r] < jj[l])) m = r;
+			if (!(d[m] < di || d[m] === di && jj[m] < ji)) break;
+			d[i] = d[m];
+			jj[i] = jj[m];
+			i = m;
+		}
+		d[i] = di;
+		jj[i] = ji;
+	}
 };
 // src/ways.ts
 /**
@@ -1511,7 +2481,150 @@ const plugsRouter = {
 		return { routes };
 	}
 };
+// src/bench/links.ts
+/** A link goes out and back when its distance to its target grows by more than this share of the distance between its ends. */
+const BACKTRACK_SHARE = .25;
+/** A link goes out and back only when its distance to its target grows by more than this number of units. */
+const BACKTRACK_MIN = 40;
+/** The default `slack` of `LinkFaultOptions`. */
+const OUTSIDE_SLACK = 24;
+/**
+* This function gives the largest growth of the distance to the last point of a polyline.
+* The growth at a vertex is its distance to the last point, less the nearest approach of the polyline before that vertex.
+*/
+function backtrackOf(p) {
+	if (p.length < 3) return 0;
+	const end = p[p.length - 1];
+	let near = dist(p[0], end);
+	let worst = 0;
+	for (let i = 1; i < p.length; i++) {
+		worst = Math.max(worst, dist(p[i], end) - near);
+		near = Math.min(near, pointSegmentDistance(end, p[i - 1], p[i]));
+	}
+	return worst;
+}
+/** This function tells if the polyline `p` goes out and back: `backtrackOf(p)` is more than `BACKTRACK_MIN` and more than `BACKTRACK_SHARE` of the span. */
+function goesOutAndBack(p) {
+	if (p.length < 3) return false;
+	const span = dist(p[0], p[p.length - 1]);
+	return backtrackOf(p) > Math.max(40, BACKTRACK_SHARE * span);
+}
+/**
+* This function measures the faults of links between boxes. The map `boxes` gives the box of each end.
+* The bounding box of `outside` is the bounding box of all the boxes of the map.
+*/
+function measureLinks(boxes, links, options = {}) {
+	const slack = options.slack ?? 24;
+	let size = 0;
+	let x0 = Infinity;
+	let y0 = Infinity;
+	let x1 = -Infinity;
+	let y1 = -Infinity;
+	for (const b of boxes.values()) {
+		size += Math.max(b.w, b.h);
+		x0 = Math.min(x0, b.x);
+		y0 = Math.min(y0, b.y);
+		x1 = Math.max(x1, b.x + b.w);
+		y1 = Math.max(y1, b.y + b.h);
+	}
+	const grid = new Grid(Math.max(180, 2 * size / Math.max(1, boxes.size)));
+	for (const [id, b] of boxes) grid.add(id, b);
+	let through = 0;
+	let backtrack = 0;
+	let worstDetour = 0;
+	let outside = 0;
+	for (const l of links) {
+		const p = l.points;
+		if (p.length === 0) continue;
+		let hit = false;
+		for (let i = 1; i < p.length && !hit; i++) {
+			const a = p[i - 1];
+			const b = p[i];
+			grid.querySegment(a, b, 0, (id) => {
+				if (!hit && id !== l.source && id !== l.target && segmentHitsBox(a, b, inflate(boxes.get(id), -.5), .5)) hit = true;
+			});
+		}
+		if (hit) through++;
+		if (goesOutAndBack(p)) backtrack++;
+		const span = dist(p[0], p[p.length - 1]);
+		if (span > 1) worstDetour = Math.max(worstDetour, polylineLength(p) / span);
+		if (p.some((q) => q.x < x0 - slack || q.x > x1 + slack || q.y < y0 - slack || q.y > y1 + slack)) outside++;
+	}
+	return {
+		links: links.length,
+		through,
+		backtrack,
+		worstDetour,
+		outside
+	};
+}
+/** This function measures the faults of the routes of a result. The ends of a route are the nodes of its edge. */
+function measureRouteFaults(graph, result, options = {}) {
+	const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
+	const edges = new Map(graph.edges.map((e) => [e.id, e]));
+	const links = [];
+	for (const r of result.routes) {
+		const e = edges.get(r.edge);
+		if (e) links.push({
+			source: e.source.node,
+			target: e.target.node,
+			points: r.points
+		});
+	}
+	return measureLinks(boxes, links, options);
+}
+/** This function counts the pairs of boxes that overlap by more than `TOLERANCE` on each axis. */
+function countOverlaps(boxes) {
+	let size = 0;
+	for (const b of boxes) size += Math.max(b.w, b.h);
+	const grid = new Grid(Math.max(180, 2 * size / Math.max(1, boxes.length)));
+	boxes.forEach((b, i) => grid.add(i, b));
+	let n = 0;
+	boxes.forEach((a, i) => {
+		grid.query(a, (j) => {
+			const b = boxes[j];
+			if (j > i && Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x) > .5 && Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y) > .5) n++;
+		});
+	});
+	return n;
+}
+/** This function measures the faults of the links of one zoom level. The items of the level are the boxes. */
+function measureLevel(level, options = {}) {
+	const boxes = new Map(level.items.map((i) => [i.id, i.box]));
+	return {
+		depth: level.depth,
+		items: level.items.length,
+		groups: level.items.filter((i) => i.nodes.length > 1).length,
+		overlaps: countOverlaps(level.items.map((i) => i.box)),
+		...measureLinks(boxes, level.links, options)
+	};
+}
+/**
+* This function measures the faults of each zoom level of a result that has groups: the levels of the far view.
+* A level of single nodes only is the near view. Its links are routes, and `measureRouteFaults` measures them.
+*/
+function measureLevelFaults(result, options = {}) {
+	return (result.levels ?? []).filter((l) => l.items.some((i) => i.nodes.length > 1)).map((l) => measureLevel(l, options));
+}
+/** This function adds the faults of several levels: it sums the counts and keeps the largest `worstDetour`. */
+function sumFaults(list) {
+	return list.reduce((s, f) => ({
+		links: s.links + f.links,
+		through: s.through + f.through,
+		backtrack: s.backtrack + f.backtrack,
+		worstDetour: Math.max(s.worstDetour, f.worstDetour),
+		outside: s.outside + f.outside
+	}), {
+		links: 0,
+		through: 0,
+		backtrack: 0,
+		worstDetour: 0,
+		outside: 0
+	});
+}
 // src/levels.ts
+/** The margin of the second corner graph. A gap between two boxes wider than approximately 1.5 times this margin lets a link through. */
+const TIGHT_MARGIN = 1;
 const EPS = 1e-6;
 /**
 * This function removes the repeated points, the points in the middle of a straight run,
@@ -1554,7 +2667,7 @@ function levelLinks(items, pairs, options = {}) {
 		if (!s || !t) continue;
 		const [fs, ft] = facingPlugs(s.box, t.box, inset);
 		let points = isFree(ways, s, fs) && isFree(ways, t, ft) ? quickWay(ways, ends(ways, s, fs, t, ft)) : void 0;
-		points ??= squareWay(ways, ends(ways, s, sidePlug(ways, s, center(t.box)), t, sidePlug(ways, t, center(s.box))));
+		points ??= sideWay(ways, s, t, inset);
 		out.push({
 			source: p.source,
 			target: p.target,
@@ -1565,25 +2678,52 @@ function levelLinks(items, pairs, options = {}) {
 	return out;
 }
 /**
+* This function gives a way from plug to plug between the plugs at the middle of a side of the two nodes.
+* Without a way in the corner graph, the link goes straight between the ends, with legs parallel to the axes where they are clear.
+* When that line goes through another box, the link goes between the free plugs of the two nodes (`freeWay`) instead.
+*/
+function sideWay(ways, s, t, inset) {
+	const e = ends(ways, s, sidePlug(ways, s, center(t.box)), t, sidePlug(ways, t, center(s.box)));
+	const quick = quickWay(ways, e);
+	if (quick) return quick;
+	const path = ways.corners.path(e.a, e.b);
+	const way = pulled(ways, e.ps, path ?? [e.a, e.b], e.pt);
+	if (path || ways.obstacles.clearPath(way, 0, /* @__PURE__ */ new Set([s, t]))) return way;
+	return freeWay(ways, s, t, inset) ?? way;
+}
+/**
 * This function makes the obstacles and the corner graph of the items of a level.
 * The buckets of the obstacles grow with the items, so a long link visits few buckets.
+* The corner graphs use `cones`, so a link goes along the corridors between the groups, not around the outer edge of the board.
 */
 function levelWays(nodes, options) {
 	const margin = options.margin ?? 5;
+	const k = options.k ?? 8;
 	let size = 0;
 	for (const n of nodes) size += Math.max(n.box.w, n.box.h);
 	const obstacles = new Obstacles(nodes, Math.max(180, 2 * size / Math.max(1, nodes.length)));
+	const corners = new CornerGraph(nodes, obstacles, {
+		margin,
+		k,
+		cones: true
+	});
+	const out = (p) => ({
+		x: p.point.x + p.normal.x * margin,
+		y: p.point.y + p.normal.y * margin
+	});
+	let tight;
+	const tightGraph = () => tight ??= new CornerGraph(nodes, obstacles, {
+		margin: Math.min(margin, TIGHT_MARGIN),
+		k,
+		cones: true
+	});
 	return {
 		obstacles,
-		corners: new CornerGraph(nodes, obstacles, {
-			margin,
-			k: options.k ?? 8
-		}),
+		corners,
 		margin,
-		out: (p) => ({
-			x: p.point.x + p.normal.x * margin,
-			y: p.point.y + p.normal.y * margin
-		})
+		out,
+		tight: tightGraph,
+		free: /* @__PURE__ */ new Map()
 	};
 }
 /**
@@ -1657,13 +2797,139 @@ function sidePlug(ways, node, toward) {
 	return plug(order[0]);
 }
 /**
+* This function gives the free plugs of a node: on each side, the free point nearest to the middle of the side.
+* A point is free when it and the point at `margin` from it are in no other box. The function keeps the plugs of each node.
+*/
+function freePlugs(ways, node, inset) {
+	const known = ways.free.get(node);
+	if (known) return known;
+	const b = node.box;
+	const out = [];
+	for (const side of SIDES) {
+		const n = SIDE_NORMAL[side];
+		const across = n.x === 0;
+		const lo = across ? b.x : b.y;
+		const hi = across ? b.x + b.w : b.y + b.h;
+		const at = across ? n.y > 0 ? b.y + b.h : b.y : n.x > 0 ? b.x + b.w : b.x;
+		const far = at + (across ? n.y : n.x) * ways.margin;
+		const covered = [];
+		const strip = across ? {
+			x: lo,
+			y: Math.min(at, far),
+			w: hi - lo,
+			h: Math.abs(far - at)
+		} : {
+			x: Math.min(at, far),
+			y: lo,
+			w: Math.abs(far - at),
+			h: hi - lo
+		};
+		ways.obstacles.query(strip, (m) => {
+			if (m === node) return;
+			const o = m.box;
+			const [o0, o1, p0, p1] = across ? [
+				o.x,
+				o.x + o.w,
+				o.y,
+				o.y + o.h
+			] : [
+				o.y,
+				o.y + o.h,
+				o.x,
+				o.x + o.w
+			];
+			if (at > p0 && at < p1 || far > p0 && far < p1) covered.push([o0, o1]);
+		});
+		const mid = (lo + hi) / 2;
+		let best;
+		for (const [f0, f1] of freeSpans(lo, hi, covered)) {
+			const room = Math.min(inset, (f1 - f0) / 2);
+			const u = Math.max(f0 + room, Math.min(f1 - room, mid));
+			if (best === void 0 || Math.abs(u - mid) < Math.abs(best - mid)) best = u;
+		}
+		if (best !== void 0) out.push({
+			point: across ? {
+				x: best,
+				y: at
+			} : {
+				x: at,
+				y: best
+			},
+			normal: n
+		});
+	}
+	const free = {
+		plugs: out,
+		reach: out.map((p) => reach(ways, node, p))
+	};
+	ways.free.set(node, free);
+	return free;
+}
+/** This function gives the indices of the plugs, and the plugs that face `toward` most come first. */
+function facingOrder(plugs, from, toward) {
+	const facing = (p) => p.normal.x * (toward.x - from.x) + p.normal.y * (toward.y - from.y);
+	return plugs.map((_, i) => i).sort((u, v) => facing(plugs[v]) - facing(plugs[u]) || u - v);
+}
+/** This function gives the parts of the span from `lo` to `hi` outside each open interval of `covered`. A part of zero length does not count. */
+function freeSpans(lo, hi, covered) {
+	covered.sort((u, v) => u[0] - v[0]);
+	const out = [];
+	let x = lo;
+	for (const [c0, c1] of covered) {
+		if (c0 > x) out.push([x, Math.min(c0, hi)]);
+		x = Math.max(x, c1);
+		if (x >= hi) break;
+	}
+	if (x < hi) out.push([x, hi]);
+	return out.filter(([a, b]) => b - a > EPS);
+}
+/**
+* This function gives the shortest way between the free plugs of the two nodes, or `undefined` when the second corner graph has none.
+* A link uses it when its plugs at the middle of a side find no way. Other boxes can cover such a plug, or close the space in front of it.
+*/
+function freeWay(ways, s, t, inset) {
+	const fs = freePlugs(ways, s, inset);
+	const ft = freePlugs(ways, t, inset);
+	const cs = center(s.box);
+	const ct = center(t.box);
+	const is = facingOrder(fs.plugs, cs, ct);
+	const it = facingOrder(ft.plugs, ct, cs);
+	const from = is.map((i) => fs.plugs[i]);
+	const to = it.map((k) => ft.plugs[k]);
+	const ra = is.map((i) => fs.reach[i]);
+	const rb = it.map((k) => ft.reach[k]);
+	let best;
+	let bestLength = Infinity;
+	from.forEach((ps, i) => to.forEach((pt, k) => {
+		const way = quickWay(ways, endsAt(ps, ra[i], pt, rb[k]));
+		const length = way ? polylineLength(way) : Infinity;
+		if (length < bestLength) {
+			best = way;
+			bestLength = length;
+		}
+	}));
+	if (best) return best;
+	const a = from.map((ps, i) => ({
+		point: along(ps, ra[i]),
+		cost: ra[i]
+	}));
+	const b = to.map((pt, k) => ({
+		point: along(pt, rb[k]),
+		cost: rb[k]
+	}));
+	const found = ways.tight().pathAmong(a, b);
+	return found && pulled(ways, from[found.from], found.points, to[found.to]);
+}
+/**
 * This function gives the ends of a link. The link leaves each plug along its normal for the margin.
 * A box can be nearer than twice the margin in front of a plug. Then the link turns in the middle of the space before that box.
 * Two plugs that face each other across a narrow space make the link turn in the middle of that space.
 */
 function ends(ways, s, ps, t, pt) {
-	let ra = reach(ways, s, ps);
-	let rb = reach(ways, t, pt);
+	return endsAt(ps, reach(ways, s, ps), pt, reach(ways, t, pt));
+}
+/** This function gives the ends of a link from the plug `ps` to the plug `pt`, with the reach of each plug. */
+function endsAt(ps, ra, pt, rb) {
 	if (ps.normal.x === -pt.normal.x && ps.normal.y === -pt.normal.y) {
 		const d = (pt.point.x - ps.point.x) * ps.normal.x + (pt.point.y - ps.point.y) * ps.normal.y;
 		if (d > 0 && ra + rb > d) ra = rb = d / 2;
@@ -1709,17 +2975,15 @@ function quickWay(ways, e) {
 	]);
 }
 /**
-* This function gives a way from plug to plug through the corner graph. The way leaves and enters each plug along its normal.
-* Then it pulls the corners tight with legs that are parallel to the axes, where the obstacles let it.
-*/
-function squareWay(ways, e) {
-	const quick = quickWay(ways, e);
-	if (quick) return quick;
-	const legs = squarePull(ways.corners.path(e.a, e.b) ?? [e.a, e.b], ways.obstacles, ways.margin / 2, axisOf(e.ps.normal), axisOf(e.pt.normal));
+* This function gives a way from the plug `ps` through the points of `path` to the plug `pt`.
+* The way leaves and enters each plug along its normal. Then it pulls the corners tight with legs that are parallel to the axes, where the obstacles let it.
+*/
+function pulled(ways, ps, path, pt) {
+	const legs = squarePull(path, ways.obstacles, ways.margin / 2, axisOf(ps.normal), axisOf(pt.normal));
 	return tidy([
-		e.ps.point,
+		ps.point,
 		...legs,
-		e.pt.point
+		pt.point
 	]);
 }
 const axisOf = (n) => Math.abs(n.x) > Math.abs(n.y) ? "x" : "y";
@@ -1779,11 +3043,18 @@ function square(a, b, obstacles, pad, from, to) {
 // src/routers/sections.ts
 const dedupe$1 = (p) => p.filter((q, i) => i === 0 || dist(q, p[i - 1]) > 1e-9);
 /**
+* A hub can be this many units farther from the target than the nearest approach of the way before it.
+* A hub farther away goes out and back, so the way skips it.
+*/
+const HUB_SLACK = 80;
+/**
 * This function makes a router with a tree of sections. Each section has a hub: the free corner nearest to the center of its nodes.
 * An edge goes from its node up the hubs of its sections to the lowest common section, across, and down to the other node.
 * Each way from hub to hub is found one time, so all the edges on it share its points.
 * The edges in one section of the lowest level go straight around the nodes.
 *
+* An edge skips a hub that takes it away from its target. A way that still goes out and back gives way to the direct way.
+*
 * The result gives one zoom level for each depth of the tree.
 * A link of a level goes from the boundary of one item to the boundary of the other, around the other items.
 */
@@ -1824,6 +3095,19 @@ function sectionsRouter(options) {
 				}
 				return h;
 			};
+			const forward = (list, from, to) => {
+				const kept = [];
+				let near = dist(from, to);
+				let last = from;
+				for (const c of list) {
+					const h = hub(c);
+					if (dist(h, to) > near + HUB_SLACK) continue;
+					near = Math.min(near, pointSegmentDistance(to, last, h));
+					last = h;
+					kept.push(c);
+				}
+				return kept;
+			};
 			const up = (s) => {
 				const out = [];
 				for (let x = s; x; x = parent.get(x)) out.push(x);
@@ -1869,19 +3153,26 @@ function sectionsRouter(options) {
 				const lca = a.find((x) => common.has(x));
 				const keep = options.hubs ?? Infinity;
 				const side = (list) => list.slice(Math.max(0, list.indexOf(lca) - keep), list.indexOf(lca));
-				const chain = [...side(a), ...side(b).reverse()];
+				const end = ways.out(pt);
+				const start = ways.out(ps);
+				const chain = forward([...side(a), ...side(b).reverse()], start, pt.point);
+				if (chain.length === 0) {
+					routes.push({
+						edge: e.id,
+						points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
+					});
+					continue;
+				}
 				const out = [ps.point];
 				const append = (p) => {
 					for (const q of p) if (dist(q, out[out.length - 1]) > 1e-9) out.push(q);
 				};
 				const used = [];
-				const start = ways.out(ps);
 				append(piece(at(start), start, chain[0].id, hub(chain[0]), used));
 				for (let i = 1; i < chain.length; i++) append(piece(chain[i - 1].id, hub(chain[i - 1]), chain[i].id, hub(chain[i]), used));
-				const end = ways.out(pt);
 				append(piece(chain[chain.length - 1].id, hub(chain[chain.length - 1]), at(end), end, used));
 				append([pt.point]);
-				if (polylineLength(out) > stretch * dist(ps.point, pt.point) + 4 * ways.margin) {
+				if (polylineLength(out) > stretch * dist(ps.point, pt.point) + 4 * ways.margin || goesOutAndBack(out)) {
 					routes.push({
 						edge: e.id,
 						points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
@@ -2446,152 +3737,287 @@ const ROUTERS = [
 		maxNodes: 1e5
 	})
 ];
-// src/bench/properties.ts
-/** The tolerance of the hard rules, in units of the plane. */
-const TOLERANCE = .5;
+// src/room/index.ts
+const DEFAULT_GUTTER = 8;
+const DEFAULT_SPACING = 4;
+const DEFAULT_SNAP = .5;
+const lo = (b, a) => a === "x" ? b.x : b.y;
+const len = (b, a) => a === "x" ? b.w : b.h;
+const other = (a) => a === "x" ? "y" : "x";
 /**
-* This function checks the hard rules of a result. Each edge has one route, and each route starts and ends at its nodes.
-* Fixed plugs stay in place. No route goes through a node that is not one of its ends. The counts of each level add up.
-* Each link of a level starts on the box of its source and ends on the box of its target.
-*
-* Each route of a bundle starts with its trunk, and an edge is in one bundle at most.
-* Each run has two edges or more, and the route of each edge holds the points of the run in a row.
-* The function gives at most `limit` violations.
+* This function gives the gaps of a board. A sweep over each axis sorts the left (or top) edges of the boxes.
+* Each distinct edge after the first is a gap. The `lanes` of each gap are 0, and its `need` is its current width.
 */
-function checkProperties(graph, result, limit = 100) {
-	const out = [];
-	const add = (v) => {
-		out.push(v);
-		return out.length >= limit;
+function boardGaps(items, snap = DEFAULT_SNAP) {
+	return [...axisGaps(items, "x", snap), ...axisGaps(items, "y", snap)];
+}
+function axisGaps(items, axis, snap) {
+	const starts = [...new Set(items.map((i) => lo(i.box, axis)))].sort((u, v) => u - v);
+	const bounds = [];
+	for (const s of starts) if (bounds.length === 0 || s - bounds[bounds.length - 1] > snap) bounds.push(s);
+	const after = bounds.map(() => []);
+	for (const i of items) after[lastAtOrBefore(bounds, lo(i.box, axis) + snap)].push(i.id);
+	const ends = items.map((i) => ({
+		id: i.id,
+		end: lo(i.box, axis) + len(i.box, axis)
+	})).sort((u, v) => u.end - v.end);
+	const gaps = [];
+	let k = 0;
+	for (let n = 1; n < bounds.length; n++) {
+		const at = bounds[n];
+		while (k < ends.length && ends[k].end <= at + snap) k++;
+		const near = k > 0 ? ends[k - 1].end : at;
+		const before = [];
+		for (let j = k - 1; j >= 0 && ends[j].end >= near - snap; j--) before.push(ends[j].id);
+		gaps.push({
+			axis,
+			index: n - 1,
+			at,
+			before: before.reverse(),
+			after: after[n],
+			width: Math.max(0, at - near),
+			lanes: 0,
+			need: Math.max(0, at - near)
+		});
+	}
+	return gaps;
+}
+/** This function gives the index of the last value of the sorted list `v` that is at or before `x`, or 0. */
+function lastAtOrBefore(v, x) {
+	let a = 0;
+	let b = v.length - 1;
+	while (a < b) {
+		const m = a + b + 1 >> 1;
+		if (v[m] <= x) a = m;
+		else b = m - 1;
+	}
+	return a;
+}
+/**
+* This function moves the boxes apart, so that each gap gets the width `need`. The boxes keep their size, their order and their alignment.
+* A box moves by the sum of the growth of each gap at or before its left (or top) edge. Thus a grid stays a grid.
+* The function moves no box nearer to another box, so it makes no overlap.
+*/
+function openGaps(items, gaps, snap = DEFAULT_SNAP) {
+	const shift = (axis) => {
+		const list = gaps.filter((g) => g.axis === axis).sort((u, v) => u.at - v.at);
+		const at = list.map((g) => g.at);
+		const sum = [];
+		let s = 0;
+		for (const g of list) sum.push(s += Math.max(0, g.need - g.width));
+		return (v) => list.length === 0 || at[0] > v + snap ? 0 : sum[lastAtOrBefore(at, v + snap)];
 	};
-	const byId = nodeIndex(graph);
-	const grid = new Grid(180);
-	for (const n of graph.nodes) grid.add(n, n.box);
-	const routes = /* @__PURE__ */ new Map();
-	for (const r of result.routes) routes.set(r.edge, r);
-	for (const e of graph.edges) {
-		const r = routes.get(e.id);
-		const s = byId.get(e.source.node);
-		const t = byId.get(e.target.node);
-		if (!s || !t) continue;
-		if (!r || r.points.length < 2) {
-			if (add({
-				rule: "complete",
-				edge: e.id,
-				detail: "no route"
-			})) return out;
-			continue;
-		}
-		const a = r.points[0];
-		const b = r.points[r.points.length - 1];
-		if (pointBoxDistance(a, s.box) > .5 || pointBoxDistance(b, t.box) > .5) {
-			if (add({
-				rule: "ends-at-plugs",
-				edge: e.id,
-				detail: "an end of the route is away from its node"
-			})) return out;
+	const sx = shift("x");
+	const sy = shift("y");
+	return items.map((i) => ({
+		...i,
+		box: {
+			...i.box,
+			x: i.box.x + sx(i.box.x),
+			y: i.box.y + sy(i.box.y)
 		}
-		const fs = fixedPortPoint(s, e.source);
-		const ft = fixedPortPoint(t, e.target);
-		if (fs && dist(fs, a) > .5 || ft && dist(ft, b) > .5) {
-			if (add({
-				rule: "fixed-plugs",
-				edge: e.id,
-				detail: "the route does not start or end at its fixed plug"
-			})) return out;
+	}));
+}
+/**
+* This function gives the room that the links need in each gap of the board.
+* The lanes of a gap come from the `method` of the options. The need of a gap is `gutter + lanes × spacing`, and not less than its current width.
+*/
+function roomDemand(items, links, options = {}) {
+	const gutter = options.gutter ?? DEFAULT_GUTTER;
+	const spacing = options.spacing ?? DEFAULT_SPACING;
+	const snap = options.snap ?? DEFAULT_SNAP;
+	const weight = (l) => options.lanes === "count" ? Math.max(1, l.count ?? 1) : 1;
+	const gaps = boardGaps(items, snap);
+	const lanes = (options.method ?? "routes") === "lines" ? lineLanes(items, links, gaps, weight) : routeLanes(items, links, gaps, gutter, snap, weight, options.router);
+	return capGrowth(items, gaps.map((g, i) => ({
+		...g,
+		lanes: lanes[i],
+		need: Math.max(g.width, gutter + lanes[i] * spacing)
+	})), gutter, options.maxGrowth ?? Infinity);
+}
+/** This function gives the demand of the board and the board with each gap open to its need. */
+function makeRoom(items, links, options = {}) {
+	const gaps = roomDemand(items, links, options);
+	return {
+		gaps,
+		items: openGaps(items, gaps, options.snap ?? DEFAULT_SNAP)
+	};
+}
+/** This function gives the links between the nodes of a graph, with the count of the edges of each pair. A loop does not count. */
+function roomLinks(graph) {
+	const byPair = /* @__PURE__ */ new Map();
+	for (const e of graph.edges) {
+		const [s, t] = [e.source.node, e.target.node];
+		if (s === t) continue;
+		const key = s < t ? `${s}\u0000${t}` : `${t}\u0000${s}`;
+		const known = byPair.get(key);
+		if (known) known.count++;
+		else byPair.set(key, {
+			source: s,
+			target: t,
+			count: 1
+		});
+	}
+	return [...byPair.values()];
+}
+/** This function counts, for each gap, the straight lines between the centers of the boxes of a link that cross the gap. */
+function lineLanes(items, links, gaps, weight) {
+	const byId = new Map(items.map((i) => [i.id, center(i.box)]));
+	return gaps.map((g) => {
+		let n = 0;
+		for (const l of links) {
+			const a = byId.get(l.source);
+			const b = byId.get(l.target);
+			if (a && b && Math.min(a[g.axis], b[g.axis]) < g.at && Math.max(a[g.axis], b[g.axis]) > g.at) n += weight(l);
 		}
-		for (let i = 1; i < r.points.length; i++) {
-			const p = r.points[i - 1];
-			const q = r.points[i];
-			let hit;
-			grid.querySegment(p, q, 0, (n) => {
-				if (!hit && n !== s && n !== t && segmentHitsBox(p, q, inflate(n.box, -.5))) hit = n;
+		return n;
+	});
+}
+/**
+* This function routes the links one time on the board with each gap open to the gutter.
+* The lanes of a gap are the largest number of routes that run along the gap at one place.
+* A piece of a route goes along a gap when it is in the channel of the gap.
+* It must also go farther along the gap than across it.
+*/
+function routeLanes(items, links, gaps, gutter, snap, weight, router) {
+	const probeGaps = gaps.map((g) => ({
+		...g,
+		need: Math.max(g.width, gutter)
+	}));
+	const ways = probeWays(openGaps(items, probeGaps, snap), links, gutter, router);
+	return probeGaps.map((g) => {
+		let grow = 0;
+		for (const h of probeGaps) if (h.axis === g.axis && h.at <= g.at + snap) grow += h.need - h.width;
+		const hi = g.at + grow;
+		const lo = hi - g.need;
+		const spans = [];
+		ways.forEach((points, i) => {
+			const along = alongSpans(points, g.axis, lo, hi);
+			for (const [from, to] of merge(along)) spans.push({
+				from,
+				to,
+				w: weight(links[i])
 			});
-			if (hit) {
-				if (add({
-					rule: "no-pass-through",
-					edge: e.id,
-					detail: `segment ${i} goes through ${hit.id}`
-				})) return out;
-				break;
-			}
-		}
+		});
+		return density(spans);
+	});
+}
+/** This function gives the points of the way of each link on the probe board, in the order of the links. */
+function probeWays(items, links, gutter, router) {
+	if (router) {
+		const edges = links.map((l, i) => ({
+			id: `l${i}`,
+			source: { node: l.source },
+			target: { node: l.target }
+		}));
+		const routes = new Map(router.route({
+			nodes: items,
+			edges
+		}).routes.map((r) => [r.edge, r.points]));
+		return edges.map((e) => routes.get(e.id) ?? []);
 	}
-	const bundled = /* @__PURE__ */ new Set();
-	for (const b of result.bundles ?? []) for (const id of b.edges) {
-		const r = routes.get(id);
-		const shares = r !== void 0 && r.points.length >= b.trunk.length && b.trunk.every((p, i) => dist(p, r.points[i]) <= .5);
-		if (bundled.has(id) || !shares) {
-			if (add({
-				rule: "bundle-trunk",
-				edge: id,
-				detail: `bundle ${b.id}: the route is in two bundles or does not start with the trunk`
-			})) return out;
+	const out = levelLinks(items.map((i) => ({
+		id: i.id,
+		box: i.box,
+		nodes: [i.id]
+	})), links.map((l) => ({
+		source: l.source,
+		target: l.target,
+		count: l.count ?? 1
+	})), { margin: Math.max(1, gutter / 2) });
+	const byPair = new Map(out.map((l) => [`${l.source}\u0000${l.target}`, l.points]));
+	return links.map((l) => byPair.get(`${l.source}\u0000${l.target}`) ?? []);
+}
+/**
+* This function gives the spans along the axis of a gap where the polyline goes along the channel from `lo` to `hi`.
+* The axis `x` gap is a vertical channel, so its spans are on the y axis.
+*/
+function alongSpans(p, axis, lo, hi) {
+	const across = axis;
+	const along = other(axis);
+	const out = [];
+	for (let i = 1; i < p.length; i++) {
+		const a = p[i - 1];
+		const b = p[i];
+		const da = b[across] - a[across];
+		let t0 = 0;
+		let t1 = 1;
+		if (Math.abs(da) < 1e-9) {
+			if (a[across] < lo - 1e-6 || a[across] > hi + 1e-6) continue;
+		} else {
+			const u = (lo - a[across]) / da;
+			const v = (hi - a[across]) / da;
+			t0 = Math.max(0, Math.min(u, v));
+			t1 = Math.min(1, Math.max(u, v));
+			if (t1 <= t0) continue;
 		}
-		bundled.add(id);
+		const s = a[along] + (b[along] - a[along]) * t0;
+		const e = a[along] + (b[along] - a[along]) * t1;
+		const run = Math.abs(e - s);
+		if (run > Math.abs(da) * (t1 - t0) && run > 1e-6) out.push([Math.min(s, e), Math.max(s, e)]);
 	}
-	for (const run of result.runs ?? []) {
-		if (run.edges.length < 2) {
-			if (add({
-				rule: "run-shared",
-				detail: `run ${run.id} has fewer than two edges`
-			})) return out;
-		}
-		for (const id of run.edges) {
-			const r = routes.get(id);
-			if (!r || !(holds(r.points, run.points) || holds(r.points, [...run.points].reverse()))) {
-				if (add({
-					rule: "run-shared",
-					edge: id,
-					detail: `run ${run.id}: the route does not hold the points of the run in a row`
-				})) return out;
-			}
-		}
+	return out;
+}
+/** This function joins the spans that overlap, so that one link counts one time at each place. */
+function merge(spans) {
+	spans.sort((u, v) => u[0] - v[0]);
+	const out = [];
+	for (const s of spans) {
+		const last = out[out.length - 1];
+		if (last && s[0] <= last[1]) last[1] = Math.max(last[1], s[1]);
+		else out.push([s[0], s[1]]);
 	}
-	for (const level of result.levels ?? []) {
-		const itemOf = /* @__PURE__ */ new Map();
-		for (const it of level.items) for (const n of it.nodes) itemOf.set(n, it.id);
-		if (itemOf.size !== graph.nodes.length) {
-			if (add({
-				rule: "counts-sum",
-				detail: `level ${level.depth}: the items hold ${itemOf.size} of ${graph.nodes.length} nodes`
-			})) return out;
-		}
-		let between = 0;
-		for (const e of graph.edges) if (itemOf.get(e.source.node) !== itemOf.get(e.target.node)) between++;
-		const sum = level.links.reduce((s, l) => s + l.count, 0);
-		if (sum !== between) {
-			if (add({
-				rule: "counts-sum",
-				detail: `level ${level.depth}: the links count ${sum} edges, not ${between}`
-			})) return out;
+	return out;
+}
+/** This function gives the largest sum of the weights of the spans that overlap at one place. Spans that only touch do not overlap. */
+function density(spans) {
+	const events = [];
+	for (const s of spans) events.push([s.from, s.w], [s.to, -s.w]);
+	events.sort((u, v) => u[0] - v[0] || u[1] - v[1]);
+	let n = 0;
+	let best = 0;
+	for (const [, w] of events) {
+		n += w;
+		best = Math.max(best, n);
+	}
+	return best;
+}
+/**
+* This function keeps the growth of the board on each axis at most `maxGrowth` times its size.
+* Each gap keeps its gutter. The lanes of all gaps of the axis share the rest of the growth in proportion.
+*/
+function capGrowth(items, gaps, gutter, maxGrowth) {
+	if (!Number.isFinite(maxGrowth)) return gaps;
+	const out = [...gaps];
+	for (const axis of ["x", "y"]) {
+		let x0 = Infinity;
+		let x1 = -Infinity;
+		for (const i of items) {
+			x0 = Math.min(x0, lo(i.box, axis));
+			x1 = Math.max(x1, lo(i.box, axis) + len(i.box, axis));
 		}
-		const boxOf = new Map(level.items.map((it) => [it.id, it.box]));
-		for (const l of level.links) {
-			const s = boxOf.get(l.source);
-			const t = boxOf.get(l.target);
-			const p = l.points;
-			if (!s || !t || p.length < 2 || !onBoundary(p[0], s) || !onBoundary(p[p.length - 1], t)) {
-				if (add({
-					rule: "link-ends",
-					detail: `level ${level.depth}: the link ${l.source} to ${l.target} does not start and end on the boundaries of its items`
-				})) return out;
-			}
+		const budget = Math.max(0, maxGrowth) * Math.max(0, x1 - x0);
+		let base = 0;
+		let spare = 0;
+		for (const g of gaps) {
+			if (g.axis !== axis) continue;
+			const b = Math.max(0, gutter - g.width);
+			base += b;
+			spare += Math.max(0, g.need - g.width - b);
 		}
+		if (base + spare <= budget || spare === 0) continue;
+		const f = Math.max(0, (budget - base) / spare);
+		gaps.forEach((g, i) => {
+			if (g.axis !== axis) return;
+			const b = Math.max(0, gutter - g.width);
+			out[i] = {
+				...g,
+				need: g.width + b + f * Math.max(0, g.need - g.width - b)
+			};
+		});
 	}
 	return out;
 }
-/** This function tells if the point is on the boundary of the box, within `TOLERANCE`. */
-function onBoundary(p, b) {
-	const inner = inflate(b, -.5);
-	return !(p.x > inner.x && p.x < inner.x + inner.w && p.y > inner.y && p.y < inner.y + inner.h) && pointBoxDistance(p, b) <= .5;
-}
-/** This function tells if the polyline `p` holds the points of `part` in a row. */
-function holds(p, part) {
-	if (part.length === 0) return true;
-	for (let i = 0; i + part.length <= p.length; i++) if (part.every((q, j) => dist(q, p[i + j]) <= .5)) return true;
-	return false;
-}
 // src/bench/quality.ts
 /** The clearance stops at this distance. */
 const CLEARANCE_CAP = 40;
@@ -2777,7 +4203,7 @@ function measureStability(before, after) {
 	};
 }
 // src/bench/run.ts
-const now = () => globalThis.performance?.now() ?? Date.now();
+const now$2 = () => globalThis.performance?.now() ?? Date.now();
 /** This function routes each fixture with each router, checks the hard rules and measures the quality. */
 function runBenchmark(routers, fixtures, options = {}) {
 	const rows = [];
@@ -2816,9 +4242,9 @@ function benchOne(router, fixture, graph, repeat = 3) {
 	let first;
 	let deterministic = true;
 	for (let i = 0; i < Math.max(2, repeat); i++) {
-		const t0 = now();
+		const t0 = now$2();
 		const r = router.route(graph);
-		times.push(now() - t0);
+		times.push(now$2() - t0);
 		if (!first) first = r;
 		else if (i === 1 && !sameData(r, first)) deterministic = false;
 	}
@@ -2834,7 +4260,9 @@ function benchOne(router, fixture, graph, repeat = 3) {
 		deterministic,
 		violations: all.length,
 		sample: all.slice(0, 5),
-		quality: measureQuality(graph, result)
+		quality: measureQuality(graph, result),
+		faults: measureRouteFaults(graph, result),
+		levelFaults: measureLevelFaults(result)
 	};
 }
 /** This function writes the rows as a Markdown table. */
@@ -2851,6 +4279,205 @@ function formatTable(rows) {
 		})
 	].join("\n");
 }
-export { CLEARANCE_CAP, CornerGraph, FIXTURES, Grid, Obstacles, ROUTERS, SIDE_NORMAL, TOLERANCE, WayFinder, allSections, benchOne, bendCount, boxExit, buildSections, byCollection, center, checkProperties, cornersRouter, countCrossings, dist, fixedPortPoint, formatTable, frechet, groupEdges, inflate, inflectionCount, inflectionCurve, inflectionSector, laneOrder, laneRoutes, makeFixture, measureQuality, measureStability, nearestSide, nodeIndex, offsetPolyline, orderLanes, pathPoints, placePlug, plugsRouter, pointBoxDistance, pointOnSide, pointSegmentDistance, polylineLength, pullApart, rng, roundCorners, runBenchmark, runKey, sameData, sectionsRouter, segmentBounds, segmentBoxDistance, segmentHitsBox, segmentHitsRect, segmentsCross, segmentsOf, sharedRouter, sideAngle, sideToward, splitPoint, straightRouter, treeDepth, trunksRouter, turns };
+/**
+* This function writes the faults of the rows as a Markdown table: the routes first, then the sum of the levels with groups.
+* A router without such levels gets a dash in the columns of the levels.
+*/
+function formatFaults(rows) {
+	return [
+		"| router | fixture | through | out and back | worst detour | outside | level links | level overlaps | level through | level out and back | level worst detour | level outside |",
+		"|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|",
+		...rows.map((r) => {
+			const f = r.faults;
+			const cells = [
+				r.router,
+				r.fixture,
+				f.through,
+				f.backtrack,
+				f.worstDetour.toFixed(2),
+				f.outside
+			];
+			if (r.levelFaults.length === 0) cells.push("-", "-", "-", "-", "-", "-");
+			else {
+				const l = sumFaults(r.levelFaults);
+				cells.push(l.links, r.levelFaults.reduce((s, x) => s + x.overlaps, 0), l.through, l.backtrack, l.worstDetour.toFixed(2), l.outside);
+			}
+			return `| ${cells.join(" | ")} |`;
+		})
+	].join("\n");
+}
+// src/bench/curves.ts
+const now$1 = () => globalThis.performance?.now() ?? Date.now();
+/**
+* This function routes a graph with a router and makes each curve type of each route.
+* It counts the curves that go through a box, with and without the free space, and it compares their length to the polylines.
+* The type `spline` leaves each plug along the normal of the nearest side of its node.
+*/
+function benchCurves(router, fixture, graph, options = {}) {
+	const tolerance = options.tolerance ?? .25;
+	const result = router.route(graph);
+	const byId = nodeIndex(graph);
+	const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
+	const edges = new Map(graph.edges.map((e) => [e.id, e]));
+	const space = curveSpace(graph.nodes.map((n) => n.box), tolerance);
+	const routes = result.routes.flatMap((r) => {
+		const e = edges.get(r.edge);
+		const s = e && byId.get(e.source.node);
+		const t = e && byId.get(e.target.node);
+		if (!e || !s || !t || r.points.length < 2) return [];
+		const first = r.points[0];
+		const last = r.points[r.points.length - 1];
+		return [{
+			source: s.id,
+			target: t.id,
+			points: r.points,
+			startNormal: SIDE_NORMAL[nearestSide(s.box, first)],
+			endNormal: SIDE_NORMAL[nearestSide(t.box, last)]
+		}];
+	});
+	const base = measureLinks(boxes, routes);
+	const ink = routes.reduce((sum, r) => sum + polylineLength(r.points), 0);
+	return CURVE_TYPES.map((type) => {
+		const make = (withSpace) => routes.map((r) => ({
+			source: r.source,
+			target: r.target,
+			points: sampleCurve(curveOf(r.points, {
+				type,
+				radius: options.radius ?? 12,
+				startNormal: r.startNormal,
+				endNormal: r.endNormal,
+				...withSpace ? { space } : {}
+			}), tolerance)
+		}));
+		const free = measureLinks(boxes, make(false));
+		const t0 = now$1();
+		const clamped = make(true);
+		const ms = now$1() - t0;
+		const length = clamped.reduce((sum, l) => sum + polylineLength(l.points), 0);
+		return {
+			router: router.name,
+			fixture,
+			type,
+			links: routes.length,
+			through: base.through,
+			free: free.through,
+			clamped: measureLinks(boxes, clamped).through,
+			length: ink > 0 ? length / ink : 1,
+			ms
+		};
+	});
+}
+/** This function writes the rows of `benchCurves` as a Markdown table. */
+function formatCurves(rows) {
+	return [
+		"| router | fixture | curve | routes | through, polyline | through, free | through, clamped | length | ms |",
+		"|---|---|---|---:|---:|---:|---:|---:|---:|",
+		...rows.map((r) => `| ${r.router} | ${r.fixture} | ${r.type} | ${r.links} | ${r.through} | ${r.free} | ${r.clamped} | ${r.length.toFixed(3)} | ${r.ms.toFixed(1)} |`)
+	].join("\n");
+}
+// src/bench/room.ts
+const now = () => globalThis.performance?.now() ?? Date.now();
+/** This function gives the area of the bounding box of the nodes. */
+function areaOf(nodes) {
+	let x0 = Infinity;
+	let y0 = Infinity;
+	let x1 = -Infinity;
+	let y1 = -Infinity;
+	for (const n of 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);
+	}
+	return nodes.length ? (x1 - x0) * (y1 - y0) : 0;
+}
+/**
+* This function measures the links of one board. It measures the links of the far view, with each node of the graph as one item of a level.
+* It also measures the lane routes of the router `sections` at the lane width `spacing`.
+*/
+function measureBoard(graph, spacing) {
+	const links = roomLinks(graph);
+	const drawn = levelLinks(graph.nodes.map((n) => ({
+		id: n.id,
+		box: n.box,
+		nodes: [n.id]
+	})), links.map((l) => ({
+		source: l.source,
+		target: l.target,
+		count: l.count ?? 1
+	})));
+	const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
+	const edgeOf = /* @__PURE__ */ new Map();
+	for (const e of graph.edges) {
+		const key = `${e.source.node}\u0000${e.target.node}`;
+		if (!edgeOf.has(key)) edgeOf.set(key, e.id);
+	}
+	const q = measureQuality(graph, { routes: drawn.map((l) => ({
+		edge: edgeOf.get(`${l.source}\u0000${l.target}`),
+		points: l.points
+	})) });
+	const segments = segmentsOf(sectionsRouter({ name: "sections" }).route(graph));
+	const lanes = laneRoutes(segments, new Set(segments.segments.filter((s) => s.count > 1).map((s) => runKey(s.edges))), spacing);
+	return {
+		faults: measureLinks(boxes, drawn),
+		crossings: q.crossings,
+		ink: q.ink,
+		detour: q.detour,
+		laneThrough: measureRouteFaults(graph, { routes: lanes }).through
+	};
+}
+/**
+* This function measures a packed board, the board with each gap open to the gutter only, and the board that `makeRoom` opens with each method.
+* The options of `makeRoom` are the same for each method, except `method`.
+*/
+function benchRoom(fixture, graph, options = {}) {
+	const spacing = options.spacing ?? 4;
+	const area0 = areaOf(graph.nodes);
+	const links = roomLinks(graph);
+	const row = (board, nodes, ms) => ({
+		fixture,
+		board,
+		area: area0 > 0 ? areaOf(nodes) / area0 : 1,
+		ms,
+		...measureBoard({
+			nodes,
+			edges: graph.edges
+		}, spacing)
+	});
+	const rows = [row("packed", graph.nodes, 0)];
+	const states = [
+		["gutter", {
+			...options,
+			spacing: 0,
+			method: "routes"
+		}],
+		["routes", {
+			...options,
+			method: "routes"
+		}],
+		["lines", {
+			...options,
+			method: "lines"
+		}]
+	];
+	for (const [board, o] of states) {
+		const t0 = now();
+		const room = makeRoom(graph.nodes, links, o);
+		rows.push(row(board, room.items, now() - t0));
+	}
+	return rows;
+}
+/** This function writes the rows of `benchRoom` as a Markdown table. */
+function formatRoom(rows) {
+	return [
+		"| fixture | board | area | links | through | outside | out and back | worst detour | crossings | ink | detour | lane through | ms |",
+		"|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|",
+		...rows.map((r) => {
+			const f = r.faults;
+			return `| ${r.fixture} | ${r.board} | ${r.area.toFixed(3)} | ${f.links} | ${f.through} | ${f.outside} | ${f.backtrack} | ${f.worstDetour.toFixed(2)} | ${r.crossings} | ${Math.round(r.ink)} | ${r.detour.toFixed(3)} | ${r.laneThrough} | ${r.ms.toFixed(1)} |`;
+		})
+	].join("\n");
+}
+export { BACKTRACK_MIN, BACKTRACK_SHARE, CASES, CLEARANCE_CAP, CURVE_TYPES, CornerGraph, FIXTURES, Grid, OUTSIDE_SLACK, Obstacles, ROUTERS, SIDE_NORMAL, TOLERANCE, WayFinder, allSections, arcCurve, backtrackOf, benchCurves, benchOne, benchRoom, bendCount, boardGaps, boxExit, buildSections, byCollection, center, checkProperties, cornersRouter, countCrossings, countOverlaps, cubicAt, curveOf, curveSpace, denseGroupsBoard, dist, distinctPoints, fixedPortPoint, formatCurves, formatFaults, formatRoom, formatTable, frechet, goesOutAndBack, groupEdges, hubChainBoard, inflate, inflectionCount, inflectionCurve, inflectionSector, laneOrder, laneRoutes, makeFixture, makeRoom, manyGroupsBoard, measureBoard, measureLevel, measureLevelFaults, measureLinks, measureQuality, measureRouteFaults, measureStability, nearestSide, nodeIndex, offsetPolyline, openGaps, orderLanes, packedGridBoard, pathPoints, placePlug, plugsRouter, pointBoxDistance, pointOnSide, pointSegmentDistance, polylineLength, pullApart, rng, roomDemand, roomLinks, roundCorners, roundedCurve, runBenchmark, runKey, sameData, sampleCurve, sectionsRouter, segmentBounds, segmentBoxDistance, segmentHitsBox, segmentHitsRect, segmentsCross, segmentsOf, sharedRouter, sideAngle, sideToward, splineCurve, splitPoint, straightCurve, straightRouter, sumFaults, toSvgPath, treeDepth, trunksRouter, turns };
 
 //# sourceMappingURL=index.js.map