@mark1russell7/highways 0.0.0-stage → 0.1.1

package/build/index.js

@@ -0,0 +1,2548 @@
+// src/geom.ts
+/** This function gives the distance between two points. */
+function dist(a, b) {
+	const dx = a.x - b.x;
+	const dy = a.y - b.y;
+	return Math.sqrt(dx * dx + dy * dy);
+}
+/** This function gives the center of a box. */
+function center(b) {
+	return {
+		x: b.x + b.w / 2,
+		y: b.y + b.h / 2
+	};
+}
+/** This function gives a box that is larger by `m` on each side. A negative `m` makes the box smaller. */
+function inflate(b, m) {
+	return {
+		x: b.x - m,
+		y: b.y - m,
+		w: Math.max(0, b.w + 2 * m),
+		h: Math.max(0, b.h + 2 * m)
+	};
+}
+/** This function gives the sum of the lengths of the segments of a polyline. */
+function polylineLength(p) {
+	let s = 0;
+	for (let i = 1; i < p.length; i++) s += dist(p[i - 1], p[i]);
+	return s;
+}
+const orient = (a, b, c) => (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+/**
+* This function tells if the segments `ab` and `cd` cross at one point inside both of them.
+* Segments that only touch at an end, or that are collinear, do not cross.
+*/
+function segmentsCross(a, b, c, d) {
+	const d1 = orient(c, d, a);
+	const d2 = orient(c, d, b);
+	const d3 = orient(a, b, c);
+	const d4 = orient(a, b, d);
+	return d1 * d2 < 0 && d3 * d4 < 0;
+}
+/**
+* This function tells if the segment `ab` goes through the inside of the box.
+* The function clips the segment to the box (Liang-Barsky) and asks for a part longer than `eps`.
+*/
+function segmentHitsBox(a, b, box, eps = 1e-6) {
+	return segmentHitsRect(a, b, box.x, box.y, box.x + box.w, box.y + box.h, eps);
+}
+/** This function tells if the segment `ab` goes through the inside of the box from (`x0`, `y0`) to (`x1`, `y1`). */
+function segmentHitsRect(a, b, x0, y0, x1, y1, eps = 1e-6) {
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	let t0 = 0;
+	let t1 = 1;
+	if (dx === 0) {
+		if (a.x <= x0 || a.x >= x1) return false;
+	} else {
+		const ta = (x0 - a.x) / dx;
+		const tb = (x1 - a.x) / dx;
+		t0 = Math.max(t0, Math.min(ta, tb));
+		t1 = Math.min(t1, Math.max(ta, tb));
+		if (t0 > t1) return false;
+	}
+	if (dy === 0) {
+		if (a.y <= y0 || a.y >= y1) return false;
+	} else {
+		const ta = (y0 - a.y) / dy;
+		const tb = (y1 - a.y) / dy;
+		t0 = Math.max(t0, Math.min(ta, tb));
+		t1 = Math.min(t1, Math.max(ta, tb));
+		if (t0 > t1) return false;
+	}
+	return (t1 - t0) * Math.sqrt(dx * dx + dy * dy) > eps;
+}
+/** This function gives the distance from a point to a box. The distance is 0 when the point is in the box. */
+function pointBoxDistance(p, b) {
+	const qx = Math.max(b.x, Math.min(b.x + b.w, p.x));
+	const qy = Math.max(b.y, Math.min(b.y + b.h, p.y));
+	return Math.hypot(p.x - qx, p.y - qy);
+}
+/** This function gives the distance from a point to the segment `ab`. */
+function pointSegmentDistance(p, a, b) {
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	const l2 = dx * dx + dy * dy;
+	const t = l2 === 0 ? 0 : Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / l2));
+	return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
+}
+/** This function gives the distance from the segment `ab` to a box. The distance is 0 when they touch. */
+function segmentBoxDistance(a, b, box) {
+	if (segmentHitsBox(a, b, box, 0) || pointBoxDistance(a, box) === 0 || pointBoxDistance(b, box) === 0) return 0;
+	const corners = [
+		{
+			x: box.x,
+			y: box.y
+		},
+		{
+			x: box.x + box.w,
+			y: box.y
+		},
+		{
+			x: box.x,
+			y: box.y + box.h
+		},
+		{
+			x: box.x + box.w,
+			y: box.y + box.h
+		}
+	];
+	let d = Math.min(pointBoxDistance(a, box), pointBoxDistance(b, box));
+	for (const c of corners) d = Math.min(d, pointSegmentDistance(c, a, b));
+	return d;
+}
+/**
+* This function gives the turn at each inner vertex of a polyline, in radians, from -π to π.
+* A positive turn is counterclockwise in a frame with the y axis up. The function skips segments shorter than `eps`.
+*/
+function turns(p, eps = 1e-9) {
+	const q = [];
+	for (const v of p) if (q.length === 0 || dist(q[q.length - 1], v) > eps) q.push(v);
+	const out = [];
+	for (let i = 1; i + 1 < q.length; i++) {
+		const a = q[i - 1];
+		const b = q[i];
+		const c = q[i + 1];
+		const cr = (b.x - a.x) * (c.y - b.y) - (b.y - a.y) * (c.x - b.x);
+		const dt = (b.x - a.x) * (c.x - b.x) + (b.y - a.y) * (c.y - b.y);
+		out.push(Math.atan2(cr, dt));
+	}
+	return out;
+}
+/** This function counts the vertices of a polyline where the direction changes by more than `minTurn` radians. */
+function bendCount(p, minTurn = .05) {
+	return turns(p).filter((t) => Math.abs(t) > minTurn).length;
+}
+/**
+* This function counts the inflections of a polyline: the changes of the sign of the turn.
+* A turn smaller than `minTurn` radians does not count. Thus a straight part between two turns keeps their signs.
+*/
+function inflectionCount(p, minTurn = .001) {
+	let n = 0;
+	let last = 0;
+	for (const t of turns(p)) {
+		if (Math.abs(t) <= minTurn) continue;
+		const s = Math.sign(t);
+		if (last !== 0 && s !== last) n++;
+		last = s;
+	}
+	return n;
+}
+/**
+* This function gives the discrete Fréchet distance between two polylines (Eiter and Mannila, 1994).
+* The cost is O(|p|·|q|) in time and O(|q|) in memory.
+*/
+function frechet(p, q) {
+	if (p.length === 0 || q.length === 0) return p.length === q.length ? 0 : Infinity;
+	let prev = new Float64Array(q.length);
+	let cur = new Float64Array(q.length);
+	for (let i = 0; i < p.length; i++) {
+		for (let j = 0; j < q.length; j++) {
+			const d = dist(p[i], q[j]);
+			if (i === 0 && j === 0) cur[j] = d;
+			else if (i === 0) cur[j] = Math.max(cur[j - 1], d);
+			else if (j === 0) cur[j] = Math.max(prev[j], d);
+			else cur[j] = Math.max(Math.min(prev[j], prev[j - 1], cur[j - 1]), d);
+		}
+		[prev, cur] = [cur, prev];
+	}
+	return prev[q.length - 1];
+}
+// src/grid.ts
+/**
+* A uniform grid of buckets over the plane. A box item goes into each bucket that the box touches.
+* A segment item goes only into the buckets along the segment, so a long diagonal segment stays cheap.
+* A query gives each item in the buckets that it touches, one time each.
+*/
+var Grid = class {
+	#cell;
+	#buckets = /* @__PURE__ */ new Map();
+	#items = [];
+	#ids = /* @__PURE__ */ new Map();
+	#seen = /* @__PURE__ */ new Int32Array(16);
+	#stamp = 0;
+	/** This constructor makes an empty grid with square buckets of side `cell`. */
+	constructor(cell) {
+		this.#cell = Math.max(1e-9, cell);
+	}
+	#key(i, j) {
+		return (i + 1048576) * 2097152 + (j + 1048576);
+	}
+	#id(item) {
+		let id = this.#ids.get(item);
+		if (id === void 0) {
+			id = this.#items.length;
+			this.#ids.set(item, id);
+			this.#items.push(item);
+			if (id >= this.#seen.length) {
+				const seen = new Int32Array(this.#seen.length * 2);
+				seen.set(this.#seen);
+				this.#seen = seen;
+			}
+		}
+		return id;
+	}
+	#put(id, x0, y0, x1, y1) {
+		const c = this.#cell;
+		const i1 = Math.floor(x1 / c);
+		const j1 = Math.floor(y1 / c);
+		for (let i = Math.floor(x0 / c); i <= i1; i++) for (let j = Math.floor(y0 / c); j <= j1; j++) {
+			const key = this.#key(i, j);
+			const list = this.#buckets.get(key);
+			if (list === void 0) this.#buckets.set(key, [id]);
+			else if (list[list.length - 1] !== id) list.push(id);
+		}
+	}
+	#take(stamp, x0, y0, x1, y1, visit) {
+		const c = this.#cell;
+		const i1 = Math.floor(x1 / c);
+		const j1 = Math.floor(y1 / c);
+		const seen = this.#seen;
+		for (let i = Math.floor(x0 / c); i <= i1; i++) for (let j = Math.floor(y0 / c); j <= j1; j++) {
+			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;
+				visit(this.#items[id]);
+			}
+		}
+	}
+	#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;
+		let py = a.y;
+		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;
+			each(Math.min(px, qx) - margin, Math.min(py, qy) - margin, Math.max(px, qx) + margin, Math.max(py, qy) + margin);
+			px = qx;
+			py = qy;
+		}
+	}
+	/** This method adds an item with its bounding box. */
+	add(item, b) {
+		this.#put(this.#id(item), b.x, b.y, b.x + b.w, b.y + b.h);
+	}
+	/** This method adds the segment `ab` as an item. */
+	addSegment(item, a, b) {
+		const id = this.#id(item);
+		this.#segment(a, b, 0, (x0, y0, x1, y1) => this.#put(id, x0, y0, x1, y1));
+	}
+	/** This method gives each item whose buckets touch the box to `visit`, one time each. */
+	query(b, visit) {
+		this.#take(++this.#stamp, b.x, b.y, b.x + b.w, b.y + b.h, visit);
+	}
+	/** 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 function gives the bounding box of the segment `ab`. */
+function segmentBounds(a, b) {
+	return {
+		x: Math.min(a.x, b.x),
+		y: Math.min(a.y, b.y),
+		w: Math.abs(a.x - b.x),
+		h: Math.abs(a.y - b.y)
+	};
+}
+// src/model.ts
+/** This function gives a map from the id of each node to the node. */
+function nodeIndex(g) {
+	const m = /* @__PURE__ */ new Map();
+	for (const n of g.nodes) m.set(n.id, n);
+	return m;
+}
+/** This function gives the absolute place of a fixed plug, or `undefined` for a free plug or no plug. */
+function fixedPortPoint(node, end) {
+	if (end.port === void 0) return void 0;
+	const p = node.ports?.find((q) => q.id === end.port);
+	if (p?.at === void 0) return void 0;
+	return {
+		x: node.box.x + p.at.x,
+		y: node.box.y + p.at.y
+	};
+}
+// src/fixtures.ts
+/** This function gives a seeded random source with values in [0, 1) (mulberry32). */
+function rng(seed) {
+	let a = seed >>> 0;
+	return () => {
+		a = a + 1831565813 >>> 0;
+		let t = a;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/** The fixtures of the benchmark, from 10 to 100 000 nodes. */
+const FIXTURES = [
+	{
+		name: "tiny-uniform",
+		kind: "uniform",
+		nodes: 10,
+		edgesPerNode: 1.5,
+		seed: 1
+	},
+	{
+		name: "small-clustered",
+		kind: "clustered",
+		nodes: 100,
+		edgesPerNode: 2,
+		seed: 2,
+		fixedPorts: .2
+	},
+	{
+		name: "grid-400",
+		kind: "grid",
+		nodes: 400,
+		edgesPerNode: 2,
+		seed: 3
+	},
+	{
+		name: "mid-uniform",
+		kind: "uniform",
+		nodes: 1e3,
+		edgesPerNode: 2,
+		seed: 4
+	},
+	{
+		name: "mid-clustered",
+		kind: "clustered",
+		nodes: 1e3,
+		edgesPerNode: 3,
+		seed: 5,
+		fixedPorts: .2
+	},
+	{
+		name: "mid-hubs",
+		kind: "hubs",
+		nodes: 1e3,
+		edgesPerNode: 2,
+		seed: 6
+	},
+	{
+		name: "mid-fanout",
+		kind: "collections",
+		nodes: 1e3,
+		edgesPerNode: 2,
+		seed: 9
+	},
+	{
+		name: "large-clustered",
+		kind: "clustered",
+		nodes: 1e4,
+		edgesPerNode: 3,
+		seed: 7
+	},
+	{
+		name: "huge-clustered",
+		kind: "clustered",
+		nodes: 1e5,
+		edgesPerNode: 2,
+		seed: 8
+	}
+];
+const COLLECTIONS = [
+	"users",
+	"modes",
+	"speeds",
+	"scores",
+	"teams"
+];
+const SIDES = [
+	"north",
+	"east",
+	"south",
+	"west"
+];
+const GAP = 12;
+const SPACING = 90;
+/**
+* This function makes the graph of a fixture. The same spec always gives the same graph.
+* Node boxes do not overlap, and a gap of 12 units stays between them.
+*/
+function makeFixture(spec) {
+	const R = rng(spec.seed * 2654435761 + spec.nodes);
+	const gauss = () => Math.sqrt(-2 * Math.log(R() + 1e-12)) * Math.cos(2 * Math.PI * R());
+	const side = Math.sqrt(spec.nodes) * SPACING;
+	const grid = new Grid(SPACING);
+	const nodes = [];
+	const clusterOf = [];
+	const free = (b) => {
+		let ok = true;
+		const g = {
+			x: b.x - GAP,
+			y: b.y - GAP,
+			w: b.w + 24,
+			h: b.h + 24
+		};
+		grid.query(g, (o) => {
+			if (ok && o.x < g.x + g.w && g.x < o.x + o.w && o.y < g.y + g.h && g.y < o.y + o.h) ok = false;
+		});
+		return ok;
+	};
+	const centers = Array.from({ length: Math.max(3, Math.round(Math.sqrt(spec.nodes) / 3)) }, () => ({
+		x: side * (.1 + .8 * R()),
+		y: side * (.1 + .8 * R())
+	}));
+	const spread = side / (2.5 * Math.sqrt(centers.length));
+	const cols = Math.ceil(Math.sqrt(spec.nodes));
+	let tries = 0;
+	while (nodes.length < spec.nodes && tries++ < spec.nodes * 200) {
+		const w = 30 + Math.floor(R() * 30);
+		const h = 18 + Math.floor(R() * 12);
+		let cx;
+		let cy;
+		let cluster = -1;
+		if (spec.kind === "grid") {
+			const i = nodes.length;
+			cx = (i % cols + .5) * SPACING;
+			cy = (Math.floor(i / cols) + .5) * SPACING;
+		} else if (spec.kind === "clustered" || spec.kind === "collections") {
+			cluster = Math.floor(R() * centers.length);
+			const c = centers[cluster];
+			cx = c.x + gauss() * spread;
+			cy = c.y + gauss() * spread;
+		} else {
+			cx = R() * side;
+			cy = R() * side;
+		}
+		const box = {
+			x: Math.round(cx - w / 2),
+			y: Math.round(cy - h / 2),
+			w,
+			h
+		};
+		if (spec.kind !== "grid" && !free(box)) continue;
+		grid.add(box, box);
+		clusterOf.push(cluster);
+		const id = `n${nodes.length}`;
+		if (R() < (spec.fixedPorts ?? 0)) {
+			const s = SIDES[Math.floor(R() * 4)];
+			const t = .2 + .6 * R();
+			const at = s === "north" ? {
+				x: w * t,
+				y: 0
+			} : s === "south" ? {
+				x: w * t,
+				y: h
+			} : s === "west" ? {
+				x: 0,
+				y: h * t
+			} : {
+				x: w,
+				y: h * t
+			};
+			const ports = [{
+				id: "out",
+				at: {
+					x: Math.round(at.x),
+					y: Math.round(at.y)
+				}
+			}];
+			nodes.push({
+				id,
+				box,
+				ports
+			});
+		} else nodes.push({
+			id,
+			box
+		});
+	}
+	return {
+		nodes,
+		edges: makeEdges(spec, nodes, clusterOf, R)
+	};
+}
+function makeEdges(spec, nodes, clusterOf, R) {
+	const n = nodes.length;
+	if (n < 2) return [];
+	const locality = spec.locality ?? .65;
+	const near = new Grid(180);
+	nodes.forEach((v, i) => near.add(i, v.box));
+	const kindOf = spec.kind === "collections" ? clusterOf.map((c) => `${COLLECTIONS[c % COLLECTIONS.length]}-${c}`) : nodes.map(() => COLLECTIONS[Math.floor(R() * COLLECTIONS.length)]);
+	const pickFar = () => spec.kind === "hubs" ? Math.floor(n * R() ** 3) : Math.floor(R() * n);
+	const target = Math.round(n * spec.edgesPerNode);
+	const seen = /* @__PURE__ */ new Set();
+	const edges = [];
+	const add = (u, v) => {
+		const key = u < v ? `${u}-${v}` : `${v}-${u}`;
+		if (u === v || seen.has(key)) return;
+		seen.add(key);
+		const src = nodes[u];
+		edges.push({
+			id: `e${edges.length}`,
+			source: src.ports ? {
+				node: src.id,
+				port: "out"
+			} : { node: src.id },
+			target: { node: nodes[v].id },
+			data: { collection: kindOf[v] }
+		});
+	};
+	if (spec.kind === "collections") {
+		const members = /* @__PURE__ */ new Map();
+		clusterOf.forEach((c, i) => {
+			const list = members.get(c);
+			if (list) list.push(i);
+			else members.set(c, [i]);
+		});
+		const clusters = [...members.keys()].sort((a, c) => a - c);
+		let rounds = 0;
+		while (edges.length < target * .6 && clusters.length > 1 && rounds++ < target) {
+			const u = Math.floor(R() * n);
+			const others = clusters.filter((c) => c !== clusterOf[u]);
+			const pool = members.get(others[Math.floor(R() * others.length)]);
+			const fan = 4 + Math.floor(R() * 12);
+			for (let i = 0; i < fan; i++) add(u, pool[Math.floor(R() * pool.length)]);
+		}
+	}
+	let tries = 0;
+	while (edges.length < target && tries++ < target * 30) {
+		const u = Math.floor(R() * n);
+		let v = -1;
+		if (R() < locality) {
+			const b = nodes[u].box;
+			const cand = [];
+			for (let r = SPACING; cand.length < 8 && r < 5760; r *= 2) {
+				cand.length = 0;
+				near.query({
+					x: b.x - r,
+					y: b.y - r,
+					w: b.w + 2 * r,
+					h: b.h + 2 * r
+				}, (i) => {
+					if (i !== u) cand.push(i);
+				});
+			}
+			cand.sort((a, c) => a - c);
+			if (cand.length) v = cand[Math.floor(R() * cand.length)];
+		} else v = pickFar();
+		if (v >= 0) add(u, v);
+	}
+	return edges;
+}
+// src/plugs.ts
+/** The outward normal of each side, in a frame with the y axis down. */
+const SIDE_NORMAL = {
+	north: {
+		x: 0,
+		y: -1
+	},
+	east: {
+		x: 1,
+		y: 0
+	},
+	south: {
+		x: 0,
+		y: 1
+	},
+	west: {
+		x: -1,
+		y: 0
+	}
+};
+/** This function gives the side of the box that is nearest to the point. */
+function nearestSide(box, p) {
+	const d = [
+		["north", Math.abs(p.y - box.y)],
+		["east", Math.abs(box.x + box.w - p.x)],
+		["south", Math.abs(box.y + box.h - p.y)],
+		["west", Math.abs(p.x - box.x)]
+	];
+	let best = d[0];
+	for (const x of d) if (x[1] < best[1]) best = x;
+	return best[0];
+}
+/**
+* This function gives the side that faces `toward`: the side of the larger component of the direction from the center.
+* Thus the angle between the normal of the side and that direction is 45° or less.
+*/
+function sideToward(box, toward) {
+	const c = center(box);
+	const dx = toward.x - c.x;
+	const dy = toward.y - c.y;
+	if (Math.abs(dx) >= Math.abs(dy)) return dx >= 0 ? "east" : "west";
+	return dy >= 0 ? "south" : "north";
+}
+/**
+* This function gives the point on a side of the box that is nearest to the line from the center to `toward`.
+* The point stays away from the corners by `inset`, or by a quarter of the side when the side is short.
+*/
+function pointOnSide(box, side, toward, inset = 6) {
+	const c = center(box);
+	const dx = toward.x - c.x;
+	const dy = toward.y - c.y;
+	const clamp = (v, lo, len) => {
+		const m = Math.min(inset, len / 4);
+		return Math.max(lo + m, Math.min(lo + len - m, v));
+	};
+	if (side === "east" || side === "west") {
+		const x = side === "east" ? box.x + box.w : box.x;
+		return {
+			x,
+			y: clamp(dx === 0 ? c.y : c.y + dy * (x - c.x) / dx, box.y, box.h)
+		};
+	}
+	const y = side === "south" ? box.y + box.h : box.y;
+	return {
+		x: clamp(dy === 0 ? c.x : c.x + dx * (y - c.y) / dy, box.x, box.w),
+		y
+	};
+}
+/**
+* This function places the plug of one end of an edge. A fixed plug stays at its point. A plug with a side stays on that side.
+* The router places a free plug on the side that faces `toward`.
+*/
+function placePlug(node, end, toward) {
+	const fixed = fixedPortPoint(node, end);
+	const port = end.port === void 0 ? void 0 : node.ports?.find((p) => p.id === end.port);
+	if (fixed) return {
+		point: fixed,
+		normal: SIDE_NORMAL[port?.side ?? nearestSide(node.box, fixed)]
+	};
+	const side = port?.side ?? sideToward(node.box, toward);
+	return {
+		point: pointOnSide(node.box, side, toward),
+		normal: SIDE_NORMAL[side]
+	};
+}
+// src/curves.ts
+/**
+* This function gives the number of inflections that the rule asks for a chord at the angle `angle` (radians).
+* It gives 0 near an axis, 1 near a diagonal and 2 between them. The bands are `tol` wide on each side.
+*/
+function inflectionSector(angle, tol = 7 * Math.PI / 180) {
+	const q = Math.PI / 2;
+	const mod = (angle % q + q) % q;
+	if (mod < tol || q - mod < tol) return 0;
+	if (Math.abs(mod - q / 2) < tol) return 1;
+	return 2;
+}
+/**
+* This function draws the curve of the inflection rule from the plug `p0` to `target`.
+* The curve leaves `p0` along `normal`. In the frame of the chord, its side offset f has f(0) = f(L) = 0 and f'(0) = tan θ.
+* Here θ is the angle from the chord to the normal. A polynomial of degree 2, 3 or 4 gives 0, 1 or 2 inflections,
+* at 1/2, or at 1/3 and 2/3, of the chord.
+*/
+function inflectionCurve(p0, normal, target, options = {}) {
+	const L = dist(p0, target);
+	if (L === 0) return [p0, target];
+	const ux = (target.x - p0.x) / L;
+	const uy = (target.y - p0.y) / L;
+	const k = inflectionSector(Math.atan2(uy, ux), options.tol);
+	const maxAngle = options.maxAngle ?? 1.35;
+	const th = -Math.atan2(normal.x * uy - normal.y * ux, normal.x * ux + normal.y * uy);
+	const d = Math.tan(Math.max(-maxAngle, Math.min(maxAngle, th)));
+	const f = k === 0 ? (s) => -d / L * s * s + d * s : k === 1 ? (s) => 12 * d / (L * L) * (s ** 3 / 6 - L * s * s / 4) + d * s : (s) => -36 * d / L ** 3 * (s ** 4 / 12 - L * s ** 3 / 6 + L * L * s * s / 9) + d * s;
+	const n = Math.max(2, options.samples ?? 24);
+	const out = [];
+	for (let i = 0; i <= n; i++) {
+		if (i === n) {
+			out.push(target);
+			break;
+		}
+		const s = L * i / n;
+		const o = f(s);
+		out.push({
+			x: p0.x + ux * s - uy * o,
+			y: p0.y + uy * s + ux * o
+		});
+	}
+	out[0] = p0;
+	return out;
+}
+/**
+* This function rounds each inner vertex of a polyline with a quadratic Bézier curve.
+* The curve starts and ends at most `radius` from the vertex, and at most half of each segment. The ends of the polyline stay.
+*/
+function roundCorners(p, radius, steps = 4) {
+	if (p.length < 3 || radius <= 0) return [...p];
+	const out = [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 r = Math.min(radius, la / 2, lb / 2);
+		if (r <= 0) {
+			out.push(v);
+			continue;
+		}
+		const p1 = {
+			x: v.x + (a.x - v.x) * r / la,
+			y: v.y + (a.y - v.y) * r / la
+		};
+		const p2 = {
+			x: v.x + (b.x - v.x) * r / lb,
+			y: v.y + (b.y - v.y) * r / lb
+		};
+		for (let k = 0; k <= steps; k++) {
+			const t = k / steps;
+			const u = 1 - t;
+			out.push({
+				x: u * u * p1.x + 2 * u * t * v.x + t * t * p2.x,
+				y: u * u * p1.y + 2 * u * t * v.y + t * t * p2.y
+			});
+		}
+	}
+	out.push(p[p.length - 1]);
+	return out;
+}
+// src/visibility.ts
+/** The nodes as obstacles, with a grid for fast tests. */
+var Obstacles = class {
+	#grid;
+	/** This constructor indexes the boxes of the nodes. */
+	constructor(nodes, cell) {
+		this.#grid = new Grid(cell);
+		for (const n of nodes) this.#grid.add(n, n.box);
+	}
+	/** 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 ok;
+	}
+	/** 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 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;
+		this.#grid.query({
+			x: p.x,
+			y: p.y,
+			w: 0,
+			h: 0
+		}, (n) => {
+			if (!hit && n !== skip) {
+				const b = n.box;
+				hit = p.x > b.x - pad && p.x < b.x + b.w + pad && p.y > b.y - pad && p.y < b.y + b.h + pad;
+			}
+		});
+		return hit;
+	}
+};
+/**
+* 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.
+* A path goes from corner to corner around the boxes.
+* The obstacle test uses half of the margin, so a path keeps a clearance of at least half of the margin.
+*/
+var CornerGraph = class {
+	points = [];
+	#adj = [];
+	#len = [];
+	#obstacles;
+	#pointGrid;
+	#cell;
+	#pad;
+	#k;
+	#g = /* @__PURE__ */ new Float64Array(0);
+	#parent = /* @__PURE__ */ new Int32Array(0);
+	#open = /* @__PURE__ */ new Int32Array(0);
+	#closed = /* @__PURE__ */ new Int32Array(0);
+	#stamp = 0;
+	#tested = /* @__PURE__ */ new Int32Array(0);
+	#testStamp = 0;
+	/** This constructor makes the graph of the nodes. */
+	constructor(nodes, obstacles, options) {
+		this.#obstacles = obstacles;
+		this.#pad = options.margin / 2;
+		this.#k = options.k;
+		let size = 0;
+		for (const n of nodes) size += (n.box.w + n.box.h) / 2;
+		this.#cell = Math.max(1, size / Math.max(1, nodes.length) + 2 * options.margin);
+		this.#pointGrid = new Grid(this.#cell);
+		for (const n of nodes) {
+			const b = inflate(n.box, options.margin);
+			for (const c of [
+				{
+					x: b.x,
+					y: b.y
+				},
+				{
+					x: b.x + b.w,
+					y: b.y
+				},
+				{
+					x: b.x + b.w,
+					y: b.y + b.h
+				},
+				{
+					x: b.x,
+					y: b.y + b.h
+				}
+			]) if (!obstacles.inside(c, this.#pad)) this.#addPoint(c);
+		}
+		const spacing = (options.lattice ?? 3) * this.#cell;
+		if (spacing > 0 && nodes.length > 0) {
+			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);
+			}
+			for (let x = x0 - spacing / 2; x <= x1 + spacing; x += spacing) for (let y = y0 - spacing / 2; y <= y1 + spacing; y += spacing) {
+				const c = {
+					x,
+					y
+				};
+				if (!obstacles.inside(c, options.margin)) this.#addPoint(c);
+			}
+		}
+		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)) {
+			links[i].add(j);
+			links[j].add(i);
+		}
+		links.forEach((s, i) => {
+			const adj = [...s].sort((a, b) => a - b);
+			this.#adj.push(adj);
+			this.#len.push(adj.map((j) => dist(this.points[i], this.points[j])));
+		});
+	}
+	#addPoint(c) {
+		this.#pointGrid.add(this.points.length, {
+			x: c.x,
+			y: c.y,
+			w: 0,
+			h: 0
+		});
+		this.points.push(c);
+	}
+	/** This method gives the number of links of the graph. */
+	get linkCount() {
+		let n = 0;
+		for (const a of this.#adj) n += a.length;
+		return n / 2;
+	}
+	/** This method gives the index of the corner nearest to `p`, seen or not, or -1 when the graph has no corner near it. */
+	nearest(p) {
+		for (let r = this.#cell; r <= this.#cell * 64; r *= 2) {
+			let best = -1;
+			let bestD = Infinity;
+			this.#pointGrid.query({
+				x: p.x - r,
+				y: p.y - r,
+				w: 2 * r,
+				h: 2 * r
+			}, (j) => {
+				const d = dist(p, this.points[j]);
+				if (d < bestD || d === bestD && j < best) {
+					bestD = d;
+					best = j;
+				}
+			});
+			if (best >= 0 && bestD <= r) return best;
+		}
+		return -1;
+	}
+	/** This method gives at most `k` corners that `p` can see, nearest first. The corner `self` does not count. */
+	nearestVisible(p, k, self = -1) {
+		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], this.#pad)) out.push(j);
+				if (out.length >= k) return out;
+			}
+		}
+		return out;
+	}
+	/**
+	* This method gives a shortest path from `from` to `to` in the graph (A*), with the two points as its ends.
+	* It gives `undefined` when the graph links no corner near `from` to a corner near `to`.
+	* The function `cost` can change the cost of the link from corner `i` to corner `j`, of length `d`.
+	* It must give at least `floor` × `d`, so that the estimate of A* stays below the true cost.
+	*/
+	path(from, to, cost, floor = 1) {
+		if (this.#obstacles.clear(from, to, this.#pad)) return [from, to];
+		const n = this.points.length;
+		if (this.#g.length < n) {
+			this.#g = new Float64Array(n);
+			this.#parent = new Int32Array(n);
+			this.#open = new Int32Array(n);
+			this.#closed = new Int32Array(n);
+		}
+		const stamp = ++this.#stamp;
+		const goal = /* @__PURE__ */ new Map();
+		for (const j of this.nearestVisible(to, this.#k * 2)) goal.set(j, dist(this.points[j], to));
+		if (goal.size === 0) return void 0;
+		const heap = new MinHeap();
+		const h = (i) => floor * dist(this.points[i], to);
+		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);
+		};
+		for (const j of this.nearestVisible(from, this.#k * 2)) relax(j, dist(from, this.points[j]), -1);
+		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];
+			const tail = goal.get(i);
+			if (tail !== void 0 && gi + tail < best) {
+				best = gi + tail;
+				bestEnd = i;
+			}
+			const adj = this.#adj[i];
+			const len = this.#len[i];
+			for (let m = 0; m < adj.length; m++) {
+				const j = adj[m];
+				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();
+	}
+	/** This method removes the vertices that a later vertex makes needless: from each vertex, it goes to the farthest vertex in view. */
+	pull(p, lookahead = 16) {
+		if (p.length < 3) return [...p];
+		const out = [p[0]];
+		let i = 0;
+		while (i < p.length - 1) {
+			let j = Math.min(p.length - 1, i + lookahead);
+			while (j > i + 1 && !this.#obstacles.clear(p[i], p[j], this.#pad)) j--;
+			out.push(p[j]);
+			i = j;
+		}
+		return out;
+	}
+};
+/** A binary min-heap of (key, value) pairs. Equal keys come out by the smaller value, so the order is deterministic. */
+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;
+	}
+	/** The smallest key. */
+	get topKey() {
+		return this.#k[0];
+	}
+	push(key, value) {
+		this.#k.push(key);
+		this.#v.push(value);
+		let i = this.#k.length - 1;
+		while (i > 0) {
+			const p = i - 1 >> 1;
+			if (!this.#less(i, p)) break;
+			this.#swap(i, p);
+			i = p;
+		}
+	}
+	/** 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;
+			}
+		}
+		return top;
+	}
+};
+// src/ways.ts
+/**
+* The ways around the nodes of one graph. A way leaves a plug along its normal.
+* It goes a shortest way (A*) through the corner graph, without the needless corners. It enters the other plug along its normal.
+*/
+var WayFinder = class {
+	obstacles;
+	corners;
+	margin;
+	#smooth;
+	/** This constructor makes the obstacles and the corner graph of the nodes. */
+	constructor(nodes, options = {}) {
+		this.margin = options.margin ?? 5;
+		this.#smooth = options.smooth ?? false;
+		this.obstacles = new Obstacles(nodes, 180);
+		this.corners = new CornerGraph(nodes, this.obstacles, {
+			margin: this.margin,
+			k: options.k ?? 8
+		});
+	}
+	/** This method gives the point at `margin` from the plug, along its normal. */
+	out(p) {
+		return {
+			x: p.point.x + p.normal.x * this.margin,
+			y: p.point.y + p.normal.y * this.margin
+		};
+	}
+	/** This method gives a way from plug to plug. Without a way in the graph, it gives the straight line. */
+	between(ps, pt, ends) {
+		if (this.#smooth) {
+			const curve = inflectionCurve(ps.point, ps.normal, pt.point);
+			if (this.obstacles.clearPath(curve, this.margin / 2, ends)) return curve;
+		}
+		const way = this.corners.path(this.out(ps), this.out(pt));
+		if (!way) return [ps.point, pt.point];
+		const poly = [
+			ps.point,
+			...this.corners.pull(way),
+			pt.point
+		];
+		if (this.#smooth) {
+			const round = roundCorners(poly, this.margin);
+			if (this.obstacles.clearPath(round, 0, ends)) return round;
+		}
+		return poly;
+	}
+	/** This method gives a way from a plug to a free point, or `undefined` when the graph has none. */
+	fromPlug(ps, to) {
+		const way = this.corners.path(this.out(ps), to);
+		return way && [ps.point, ...this.corners.pull(way)];
+	}
+	/** This method gives a way from a free point to a plug, or `undefined` when the graph has none. */
+	toPlug(from, pt) {
+		const way = this.corners.path(from, this.out(pt));
+		return way && [...this.corners.pull(way), pt.point];
+	}
+};
+// src/segments.ts
+const SAME = 1e-6;
+/** This function gives the index where `p` holds the points of `part` in a row, from `from` on, or -1. */
+function indexOf(p, part, from) {
+	for (let i = from; i + part.length <= p.length; i++) {
+		let ok = true;
+		for (let j = 0; ok && j < part.length; j++) ok = dist(p[i + j], part[j]) <= SAME;
+		if (ok) return i;
+	}
+	return -1;
+}
+/**
+* This function breaks each route into segments. The runs and the trunks of the bundles become shared segments.
+* The other parts of each route become private segments. The segments of a path, in order, give the points of its route again.
+*/
+function segmentsOf(result) {
+	const shared = [...(result.runs ?? []).map((r) => ({
+		id: r.id,
+		points: r.points,
+		edges: r.edges
+	})), ...(result.bundles ?? []).map((b) => ({
+		id: b.id,
+		points: b.trunk,
+		edges: b.edges
+	}))].filter((s) => s.points.length >= 2);
+	const onEdge = /* @__PURE__ */ new Map();
+	for (const s of shared) s.edges.forEach((edge, lane) => {
+		const list = onEdge.get(edge);
+		if (list) list.push({
+			id: s.id,
+			points: s.points,
+			lane
+		});
+		else onEdge.set(edge, [{
+			id: s.id,
+			points: s.points,
+			lane
+		}]);
+	});
+	const segments = shared.map((s) => ({
+		id: s.id,
+		points: s.points,
+		edges: s.edges,
+		count: s.edges.length
+	}));
+	const paths = [];
+	for (const route of result.routes) {
+		const p = route.points;
+		const found = [];
+		for (const s of onEdge.get(route.edge) ?? []) {
+			let at = indexOf(p, s.points, 0);
+			let reverse = false;
+			if (at < 0) {
+				at = indexOf(p, [...s.points].reverse(), 0);
+				reverse = true;
+			}
+			if (at >= 0) found.push({
+				at,
+				end: at + s.points.length - 1,
+				ref: {
+					segment: s.id,
+					reverse,
+					lane: s.lane
+				}
+			});
+		}
+		found.sort((a, b) => a.at - b.at);
+		const refs = [];
+		let i = 0;
+		const own = (to) => {
+			if (to <= i) return;
+			const id = `${route.edge}/${refs.length}`;
+			segments.push({
+				id,
+				points: p.slice(i, to + 1),
+				edges: [route.edge],
+				count: 1
+			});
+			refs.push({
+				segment: id,
+				reverse: false,
+				lane: 0
+			});
+		};
+		for (const f of found) {
+			if (f.at < i) continue;
+			own(f.at);
+			refs.push(f.ref);
+			i = f.end;
+		}
+		own(p.length - 1);
+		paths.push({
+			edge: route.edge,
+			segments: refs
+		});
+	}
+	return {
+		segments,
+		paths
+	};
+}
+/** This function gives the points of a path, with the segments in the order and the way of the path. */
+function pathPoints(graph, path) {
+	const byId = new Map(graph.segments.map((s) => [s.id, s]));
+	const out = [];
+	for (const ref of path.segments) {
+		const s = byId.get(ref.segment);
+		if (!s) continue;
+		const pts = ref.reverse ? [...s.points].reverse() : s.points;
+		for (const q of pts) if (out.length === 0 || dist(q, out[out.length - 1]) > SAME) out.push(q);
+	}
+	return out;
+}
+/**
+* This function moves each point of a polyline by `d` to the left, in a frame with the y axis down.
+* At an inner point, it moves along the bisector, at most 2 × `d` far.
+*/
+function offsetPolyline(p, d) {
+	if (d === 0 || p.length < 2) return [...p];
+	const normals = [];
+	for (let i = 1; i < p.length; i++) {
+		const dx = p[i].x - p[i - 1].x;
+		const dy = p[i].y - p[i - 1].y;
+		const l = Math.hypot(dx, dy);
+		normals.push(l > 0 ? {
+			x: dy / l,
+			y: -dx / l
+		} : normals[normals.length - 1] ?? {
+			x: 0,
+			y: 0
+		});
+	}
+	return p.map((q, i) => {
+		const a = normals[Math.max(0, i - 1)];
+		const b = normals[Math.min(normals.length - 1, i)];
+		const mx = a.x + b.x;
+		const my = a.y + b.y;
+		const ml = Math.hypot(mx, my);
+		if (ml < 1e-9) return {
+			x: q.x + a.x * d,
+			y: q.y + a.y * d
+		};
+		const cos = (mx * a.x + my * a.y) / ml;
+		const k = Math.min(2, 1 / Math.max(cos, 1e-9)) * d;
+		return {
+			x: q.x + mx / ml * k,
+			y: q.y + my / ml * k
+		};
+	});
+}
+/**
+* This function pulls the lanes of each shared segment apart, and gives a route for each edge.
+* The lanes keep the lane order, so they do not cross in a segment. The two ends of each route stay at their plugs.
+*/
+function pullApart(graph, options) {
+	return lanePaths(graph, (s) => s.count > 1 ? Math.min(options.spacing, options.maxWidth / (s.count - 1)) : 0);
+}
+/** This function gives the key of a shared run: the ids of its edges, sorted and joined with commas. */
+function runKey(edges) {
+	return [...edges].sort().join(",");
+}
+/**
+* This function opens the shared segments whose key is in `open`: each edge of an open segment gets its own lane.
+* The lanes are `laneWidth` apart, and an open segment is at most `maxWidth` wide. The other segments stay as one way.
+*
+* Lane 0 is on the left of the segment, from its first point to its last, with the y axis down.
+* The function takes a result or its segments. It gives a route for each edge, with the ends at their plugs.
+* The key of a segment is `runKey` of its edges.
+*/
+function laneRoutes(source, open, laneWidth, maxWidth = Infinity) {
+	const graph = "paths" in source ? source : segmentsOf(source);
+	if (open.size === 0) return graph.paths.map((path) => ({
+		edge: path.edge,
+		points: pathPoints(graph, path)
+	}));
+	return lanePaths(graph, (s) => s.count > 1 && open.has(runKey(s.edges)) ? Math.min(laneWidth, maxWidth / (s.count - 1)) : 0);
+}
+/** This function gives the route of each path, with the lanes of each segment at the spacing that `spacingOf` gives. */
+function lanePaths(graph, spacingOf) {
+	const byId = new Map(graph.segments.map((s) => [s.id, s]));
+	const routes = [];
+	for (const path of graph.paths) {
+		const ends = pathPoints(graph, path);
+		const out = [];
+		for (const ref of path.segments) {
+			const s = byId.get(ref.segment);
+			if (!s) continue;
+			const spacing = spacingOf(s);
+			const moved = offsetPolyline(s.points, ((s.count - 1) / 2 - ref.lane) * spacing);
+			for (const q of ref.reverse ? moved.reverse() : moved) if (out.length === 0 || dist(q, out[out.length - 1]) > SAME) out.push(q);
+		}
+		if (out.length >= 2 && ends.length >= 2) {
+			out[0] = ends[0];
+			out[out.length - 1] = ends[ends.length - 1];
+		}
+		routes.push({
+			edge: path.edge,
+			points: out
+		});
+	}
+	return routes;
+}
+/** The angle, from -π to π, of the turn at `base` from the direction `from` → `base` to the point `to`. */
+function turn$1(from, base, to) {
+	const dx = base.x - from.x;
+	const dy = base.y - from.y;
+	const vx = to.x - base.x;
+	const vy = to.y - base.y;
+	return Math.atan2(dx * vy - dy * vx, dx * vx + dy * vy);
+}
+/**
+* This function gives the lane order of the edges on a shared way `run` (metro-line order). Two routes go on together
+* past the last point of the run until they part. The route that turns more to the left there gets the lane more to the left.
+* Two routes can part only before the first point. Then the route that comes from more to the left gets the lane more to the left.
+* A route that does not hold the run goes last.
+*/
+function orderLanes(run, routes) {
+	const placed = [];
+	const lost = [];
+	for (const r of routes) {
+		let at = indexOf(r.points, run, 0);
+		if (at >= 0) placed.push({
+			edge: r.edge,
+			p: r.points,
+			s: at,
+			e: at + run.length - 1
+		});
+		else {
+			const p = [...r.points].reverse();
+			at = indexOf(p, run, 0);
+			if (at >= 0) placed.push({
+				edge: r.edge,
+				p,
+				s: at,
+				e: at + run.length - 1
+			});
+			else lost.push(r.edge);
+		}
+	}
+	const same = (a, b) => dist(a, b) <= SAME;
+	placed.sort((P, Q) => {
+		for (let j = 1;; j++) {
+			const a = P.p[P.e + j];
+			const b = Q.p[Q.e + j];
+			if (a === void 0 || b === void 0) break;
+			if (!same(a, b)) {
+				const d = turn$1(P.p[P.e + j - 2], P.p[P.e + j - 1], a) - turn$1(P.p[P.e + j - 2], P.p[P.e + j - 1], b);
+				if (d !== 0) return d;
+				break;
+			}
+		}
+		for (let j = 1;; j++) {
+			const a = P.p[P.s - j];
+			const b = Q.p[Q.s - j];
+			if (a === void 0 || b === void 0) break;
+			if (!same(a, b)) {
+				const d = turn$1(P.p[P.s - j + 2], P.p[P.s - j + 1], b) - turn$1(P.p[P.s - j + 2], P.p[P.s - j + 1], a);
+				if (d !== 0) return d;
+				break;
+			}
+		}
+		return P.edge < Q.edge ? -1 : P.edge > Q.edge ? 1 : 0;
+	});
+	return [...placed.map((x) => x.edge), ...lost.sort()];
+}
+// src/sections.ts
+/**
+* This function makes the tree of sections of the nodes. A cell with more than `cap` nodes splits in four.
+* When the nodes of a cell are all in one quarter, the cell becomes that quarter and does not make a level.
+*/
+function buildSections(nodes, options = {}) {
+	const cap = Math.max(1, options.cap ?? 8);
+	const maxDepth = options.maxDepth ?? 16;
+	const centers = nodes.map((n) => center(n.box));
+	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);
+	}
+	const root = nodes.length ? {
+		x: x0,
+		y: y0,
+		w: x1 - x0,
+		h: y1 - y0
+	} : {
+		x: 0,
+		y: 0,
+		w: 0,
+		h: 0
+	};
+	const make = (id, depth, cell, list) => {
+		let box = cell;
+		for (let guard = 0; list.length > cap && depth < maxDepth && guard < 32; guard++) {
+			const mx = box.x + box.w / 2;
+			const my = box.y + box.h / 2;
+			const parts = [
+				[],
+				[],
+				[],
+				[]
+			];
+			for (const i of list) parts[(centers[i].x < mx ? 0 : 1) + (centers[i].y < my ? 0 : 2)].push(i);
+			const quarter = (q) => ({
+				x: q % 2 === 0 ? box.x : mx,
+				y: q < 2 ? box.y : my,
+				w: box.w / 2,
+				h: box.h / 2
+			});
+			const full = parts.map((p, q) => [p, q]).filter(([p]) => p.length > 0);
+			if (full.length === 1) {
+				box = quarter(full[0][1]);
+				continue;
+			}
+			const children = full.map(([p, q]) => make(`${id}${q}`, depth + 1, quarter(q), p));
+			return {
+				id,
+				depth,
+				cell: box,
+				nodes: list,
+				children
+			};
+		}
+		return {
+			id,
+			depth,
+			cell: box,
+			nodes: list,
+			children: []
+		};
+	};
+	return make("s", 0, root, nodes.map((_, i) => i));
+}
+/** This function gives the sections of the tree, parents before children. */
+function allSections(root) {
+	const out = [];
+	const walk = (s) => {
+		out.push(s);
+		for (const c of s.children) walk(c);
+	};
+	walk(root);
+	return out;
+}
+/** This function gives the depth of the deepest section. */
+function treeDepth(root) {
+	return root.children.reduce((d, c) => Math.max(d, treeDepth(c)), root.depth);
+}
+// 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.
+*/
+function cornersRouter(options) {
+	const router = {
+		name: options.name,
+		route(graph) {
+			const byId = nodeIndex(graph);
+			const ways = new WayFinder(graph.nodes, options);
+			const routes = [];
+			for (const e of graph.edges) {
+				const s = byId.get(e.source.node);
+				const t = byId.get(e.target.node);
+				if (!s || !t) continue;
+				const ps = placePlug(s, e.source, center(t.box));
+				const pt = placePlug(t, e.target, center(s.box));
+				routes.push({
+					edge: e.id,
+					points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
+				});
+			}
+			return { routes };
+		}
+	};
+	return options.maxNodes === void 0 ? router : {
+		...router,
+		maxNodes: options.maxNodes
+	};
+}
+// src/routers/plugs.ts
+/**
+* Plugs and the inflection rule, with no obstacles. Each edge leaves its source plug at the tangent of the side.
+* It goes to the target plug on the curve of the rule. This router measures the rule alone.
+*/
+const plugsRouter = {
+	name: "plugs",
+	route(graph) {
+		const byId = nodeIndex(graph);
+		const routes = [];
+		for (const e of graph.edges) {
+			const s = byId.get(e.source.node);
+			const t = byId.get(e.target.node);
+			if (!s || !t) continue;
+			const ps = placePlug(s, e.source, center(t.box));
+			const pt = placePlug(t, e.target, center(s.box));
+			routes.push({
+				edge: e.id,
+				points: inflectionCurve(ps.point, ps.normal, pt.point)
+			});
+		}
+		return { routes };
+	}
+};
+// src/routers/sections.ts
+const dedupe$1 = (p) => p.filter((q, i) => i === 0 || dist(q, p[i - 1]) > 1e-9);
+/**
+* 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. The result gives one zoom level for each depth of the tree.
+*/
+function sectionsRouter(options) {
+	const router = {
+		name: options.name,
+		route(graph) {
+			const stretch = options.stretch ?? 2;
+			const byId = nodeIndex(graph);
+			const indexOfNode = new Map(graph.nodes.map((n, i) => [n.id, i]));
+			const ways = new WayFinder(graph.nodes, options);
+			const corners = ways.corners;
+			const root = buildSections(graph.nodes, options);
+			const parent = /* @__PURE__ */ new Map();
+			const leafOf = [];
+			for (const s of allSections(root)) {
+				for (const c of s.children) parent.set(c, s);
+				if (s.children.length === 0) for (const i of s.nodes) leafOf[i] = s;
+			}
+			const hubs = /* @__PURE__ */ new Map();
+			const hub = (s) => {
+				let h = hubs.get(s);
+				if (!h) {
+					let x = 0;
+					let y = 0;
+					for (const i of s.nodes) {
+						const c = center(graph.nodes[i].box);
+						x += c.x;
+						y += c.y;
+					}
+					const c = {
+						x: x / Math.max(1, s.nodes.length),
+						y: y / Math.max(1, s.nodes.length)
+					};
+					const j = corners.nearest(c);
+					h = j >= 0 ? corners.points[j] : c;
+					hubs.set(s, h);
+				}
+				return h;
+			};
+			const up = (s) => {
+				const out = [];
+				for (let x = s; x; x = parent.get(x)) out.push(x);
+				return out;
+			};
+			const pieces = /* @__PURE__ */ new Map();
+			const users = /* @__PURE__ */ new Map();
+			const piece = (ka, a, kb, b, used) => {
+				const forward = ka <= kb;
+				const key = forward ? `${ka}>${kb}` : `${kb}>${ka}`;
+				let p = pieces.get(key);
+				if (!p) {
+					const [from, to] = forward ? [a, b] : [b, a];
+					const way = corners.path(from, to);
+					p = dedupe$1(way ? corners.pull(way) : [from, to]);
+					pieces.set(key, p);
+				}
+				if (!used.includes(key)) used.push(key);
+				return forward ? p : [...p].reverse();
+			};
+			const at = (p) => `${p.x},${p.y}`;
+			const routes = [];
+			const marks = /* @__PURE__ */ new Map();
+			for (const e of graph.edges) {
+				const s = byId.get(e.source.node);
+				const t = byId.get(e.target.node);
+				const iu = indexOfNode.get(e.source.node);
+				const iv = indexOfNode.get(e.target.node);
+				if (!s || !t || iu === void 0 || iv === void 0) continue;
+				const ps = placePlug(s, e.source, center(t.box));
+				const pt = placePlug(t, e.target, center(s.box));
+				const lu = leafOf[iu];
+				const lv = leafOf[iv];
+				if (lu === lv) {
+					routes.push({
+						edge: e.id,
+						points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
+					});
+					continue;
+				}
+				const a = up(lu);
+				const b = up(lv);
+				const common = new Set(b);
+				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 out = [ps.point];
+				const mark = /* @__PURE__ */ new Map();
+				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));
+				mark.set(chain[0], out.length - 1);
+				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));
+					mark.set(chain[i], out.length - 1);
+				}
+				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) {
+					routes.push({
+						edge: e.id,
+						points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
+					});
+					continue;
+				}
+				for (const key of used) {
+					const list = users.get(key);
+					if (list) list.push(e.id);
+					else users.set(key, [e.id]);
+				}
+				routes.push({
+					edge: e.id,
+					points: out
+				});
+				marks.set(e.id, mark);
+			}
+			const routeOf = new Map(routes.map((r) => [r.edge, r]));
+			const runs = [];
+			for (const [key, p] of pieces) {
+				const list = users.get(key) ?? [];
+				if (list.length < 2 || p.length < 2) continue;
+				runs.push({
+					id: `r${runs.length}`,
+					key,
+					points: p,
+					edges: orderLanes(p, list.map((id) => routeOf.get(id)))
+				});
+			}
+			return {
+				routes,
+				runs,
+				levels: makeLevels(graph, root, routeOf, marks)
+			};
+		}
+	};
+	return options.maxNodes === void 0 ? router : {
+		...router,
+		maxNodes: options.maxNodes
+	};
+}
+/**
+* This function gives one zoom level for each depth of the tree, and a last level with each node alone.
+* At depth d, a section of depth d is one item. A link joins two items and counts the edges between them.
+* Its points are the part of the route of its first edge between the two items.
+*/
+function makeLevels(graph, root, routeOf, marks) {
+	const indexOfNode = new Map(graph.nodes.map((n, i) => [n.id, i]));
+	const levels = [];
+	const deepest = treeDepth(root);
+	for (let d = 0; d <= deepest + 1; d++) {
+		const items = [];
+		const itemOf = [];
+		const boxOf = (list) => {
+			let x0 = Infinity;
+			let y0 = Infinity;
+			let x1 = -Infinity;
+			let y1 = -Infinity;
+			for (const i of list) {
+				const b = graph.nodes[i].box;
+				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);
+			}
+			return {
+				x: x0,
+				y: y0,
+				w: x1 - x0,
+				h: y1 - y0
+			};
+		};
+		const visit = (s) => {
+			if (s.depth >= d) {
+				items.push({
+					id: s.id,
+					box: boxOf(s.nodes),
+					nodes: s.nodes.map((i) => graph.nodes[i].id)
+				});
+				for (const i of s.nodes) itemOf[i] = s;
+			} else if (s.children.length > 0) for (const c of s.children) visit(c);
+			else for (const i of s.nodes) {
+				const n = graph.nodes[i];
+				items.push({
+					id: n.id,
+					box: n.box,
+					nodes: [n.id]
+				});
+				itemOf[i] = i;
+			}
+		};
+		if (graph.nodes.length > 0) visit(root);
+		const links = /* @__PURE__ */ new Map();
+		for (const e of graph.edges) {
+			const iu = indexOfNode.get(e.source.node);
+			const iv = indexOfNode.get(e.target.node);
+			if (iu === void 0 || iv === void 0) continue;
+			const a = itemOf[iu];
+			const b = itemOf[iv];
+			if (a === b) continue;
+			const ida = typeof a === "number" ? graph.nodes[a].id : a.id;
+			const idb = typeof b === "number" ? graph.nodes[b].id : b.id;
+			const key = `${ida}\u0000${idb}`;
+			const link = links.get(key);
+			if (link) {
+				link.count++;
+				continue;
+			}
+			const route = routeOf.get(e.id)?.points ?? [];
+			const mark = marks.get(e.id);
+			const from = typeof a === "number" ? 0 : mark?.get(a) ?? 0;
+			const to = typeof b === "number" ? route.length - 1 : mark?.get(b) ?? route.length - 1;
+			links.set(key, {
+				source: ida,
+				target: idb,
+				count: 1,
+				points: route.slice(from, to + 1)
+			});
+		}
+		levels.push({
+			depth: d,
+			items,
+			links: [...links.values()]
+		});
+	}
+	return levels;
+}
+// src/routers/shared.ts
+const byText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+/** The angle, from -π to π, of the turn at `base` from the direction `from` → `base` to the point `to`. */
+function turn(from, base, to) {
+	const dx = base.x - from.x;
+	const dy = base.y - from.y;
+	const vx = to.x - base.x;
+	const vy = to.y - base.y;
+	return Math.atan2(dx * vy - dy * vx, dx * vx + dy * vy);
+}
+/**
+* This function makes a router where edges share their ways (after Pupyrev, Nachmanson, Bereg and Holroyd, "Edge routing with ordered bundles").
+* The edges go one by one through the corner graph. A link that an edge with the same key uses already costs less.
+* Thus the edges of a key come together on common ways. Each stretch that several edges share has the same points in each route.
+* The result gives each stretch as a run, with the order of its lanes.
+*/
+function sharedRouter(options) {
+	const discount = Math.min(1, Math.max(.05, options.discount ?? .5));
+	const keyOf = (e) => {
+		if (!options.rule) return "*";
+		return options.rule(e) ?? `\u0000${e.id}`;
+	};
+	const router = {
+		name: options.name,
+		route(graph) {
+			const byId = nodeIndex(graph);
+			const ways = new WayFinder(graph.nodes, options);
+			const corners = ways.corners;
+			const index = /* @__PURE__ */ new Map();
+			corners.points.forEach((p, i) => index.set(p, i));
+			const M = corners.points.length + 1;
+			const link = (i, j) => i < j ? i * M + j : j * M + i;
+			const ends = /* @__PURE__ */ new Map();
+			const endId = (p) => {
+				const k = `${p.x},${p.y}`;
+				let id = ends.get(k);
+				if (id === void 0) ends.set(k, id = corners.points.length + ends.size);
+				return id;
+			};
+			const all = [];
+			for (const e of graph.edges) {
+				const s = byId.get(e.source.node);
+				const t = byId.get(e.target.node);
+				if (!s || !t) continue;
+				const ps = placePlug(s, e.source, center(t.box));
+				const pt = placePlug(t, e.target, center(s.box));
+				all.push({
+					edge: e,
+					key: keyOf(e),
+					ps,
+					pt,
+					seq: [],
+					ids: [],
+					found: false
+				});
+			}
+			const discounted = /* @__PURE__ */ new Map();
+			const order = [...all].sort((p, q) => byText(p.key, q.key) || dist(q.ps.point, q.pt.point) - dist(p.ps.point, p.pt.point) || byText(p.edge.id, q.edge.id));
+			for (const w of order) {
+				let used = discounted.get(w.key);
+				if (!used) discounted.set(w.key, used = /* @__PURE__ */ new Map());
+				const mine = used;
+				const way = corners.path(ways.out(w.ps), ways.out(w.pt), (i, j, d) => mine.has(link(i, j)) ? d * discount : d, discount);
+				if (!way) continue;
+				w.found = true;
+				w.seq = way;
+				w.ids = way.map((p, i) => i === 0 || i === way.length - 1 ? endId(p) : index.get(p));
+				for (let i = 1; i < w.ids.length; i++) {
+					const a = w.ids[i - 1];
+					const b = w.ids[i];
+					if (a >= corners.points.length || b >= corners.points.length) continue;
+					const list = mine.get(link(a, b));
+					if (list) list.push(w.edge.id);
+					else mine.set(link(a, b), [w.edge.id]);
+				}
+			}
+			const users = /* @__PURE__ */ new Map();
+			for (const w of order) {
+				if (!w.found) continue;
+				let mine = users.get(w.key);
+				if (!mine) users.set(w.key, mine = /* @__PURE__ */ new Map());
+				for (let i = 1; i < w.ids.length; i++) {
+					const a = w.ids[i - 1];
+					const b = w.ids[i];
+					const k = a < b ? `${a}:${b}` : `${b}:${a}`;
+					const list = mine.get(k);
+					if (list) list.push(w.edge.id);
+					else mine.set(k, [w.edge.id]);
+				}
+			}
+			const runs = /* @__PURE__ */ new Map();
+			const points = /* @__PURE__ */ new Map();
+			for (const w of all) {
+				if (!w.found) continue;
+				const used = users.get(w.key);
+				const sig = (i) => {
+					const a = w.ids[i];
+					const b = w.ids[i + 1];
+					const list = used.get(a < b ? `${a}:${b}` : `${b}:${a}`);
+					return list.length < 2 ? "" : [...list].sort(byText).join("
");
+				};
+				const out = [w.ps.point];
+				const append = (piece) => {
+					for (const p of piece) if (dist(p, out[out.length - 1]) > 1e-9) out.push(p);
+				};
+				let start = 0;
+				for (let i = 0; i < w.seq.length - 1; i++) {
+					const s = sig(i);
+					if (i + 1 < w.seq.length - 1 && sig(i + 1) === s) continue;
+					const raw = w.seq.slice(start, i + 2);
+					if (s === "") append(corners.pull(raw));
+					else {
+						const a = w.ids[start];
+						const b = w.ids[i + 1];
+						const id = `${s}\u0002${Math.min(a, b)}\u0002${Math.max(a, b)}`;
+						let run = runs.get(id);
+						if (!run) {
+							run = {
+								key: w.key,
+								first: Math.min(a, b),
+								last: Math.max(a, b),
+								points: corners.pull(a < b ? raw : [...raw].reverse()),
+								ways: []
+							};
+							runs.set(id, run);
+						}
+						run.ways.push(w);
+						append(a < b ? run.points : [...run.points].reverse());
+					}
+					start = i + 1;
+				}
+				append([w.pt.point]);
+				points.set(w.edge.id, out);
+			}
+			const routes = [];
+			for (const w of all) routes.push({
+				edge: w.edge.id,
+				points: points.get(w.edge.id) ?? [w.ps.point, w.pt.point]
+			});
+			const shared = [];
+			for (const run of runs.values()) shared.push({
+				id: `r${shared.length}`,
+				key: run.key,
+				points: run.points,
+				edges: laneOrderOfRun(run)
+			});
+			return {
+				routes,
+				runs: shared
+			};
+		}
+	};
+	return options.maxNodes === void 0 ? router : {
+		...router,
+		maxNodes: options.maxNodes
+	};
+}
+/**
+* This function gives the lane order of a run (metro-line order). Two edges of the run go together past its last corner
+* until they part. The edge that turns more to the left there gets the lane more to the left.
+* Two edges can part only before the first corner. Then the edge that comes from more to the left gets the lane more to the left.
+*/
+function laneOrderOfRun(run) {
+	const oriented = /* @__PURE__ */ new Map();
+	for (const w of run.ways) {
+		const s0 = w.ids.indexOf(run.first);
+		const e0 = w.ids.indexOf(run.last);
+		if (s0 < e0) oriented.set(w, {
+			seq: w.seq,
+			ids: w.ids,
+			s: s0,
+			e: e0
+		});
+		else oriented.set(w, {
+			seq: [...w.seq].reverse(),
+			ids: [...w.ids].reverse(),
+			s: w.seq.length - 1 - s0,
+			e: w.seq.length - 1 - e0
+		});
+	}
+	const compare = (p, q) => {
+		const P = oriented.get(p);
+		const Q = oriented.get(q);
+		for (let j = 1;; j++) {
+			const a = P.seq[P.e + j];
+			const b = Q.seq[Q.e + j];
+			if (a === void 0 || b === void 0) break;
+			if (P.ids[P.e + j] !== Q.ids[Q.e + j]) {
+				const d = turn(P.seq[P.e + j - 2], P.seq[P.e + j - 1], a) - turn(P.seq[P.e + j - 2], P.seq[P.e + j - 1], b);
+				if (d !== 0) return d;
+				break;
+			}
+		}
+		for (let j = 1;; j++) {
+			const a = P.seq[P.s - j];
+			const b = Q.seq[Q.s - j];
+			if (a === void 0 || b === void 0) break;
+			if (P.ids[P.s - j] !== Q.ids[Q.s - j]) {
+				const d = turn(P.seq[P.s - j + 2], P.seq[P.s - j + 1], b) - turn(P.seq[P.s - j + 2], P.seq[P.s - j + 1], a);
+				if (d !== 0) return d;
+				break;
+			}
+		}
+		return byText(p.edge.id, q.edge.id);
+	};
+	return [...run.ways].sort(compare).map((w) => w.edge.id);
+}
+// src/routers/straight.ts
+/** This function gives the point where the ray from the center of the box to `toward` leaves the box. */
+function boxExit(box, toward) {
+	const c = center(box);
+	const dx = toward.x - c.x;
+	const dy = toward.y - c.y;
+	if (dx === 0 && dy === 0) return c;
+	const tx = dx === 0 ? Infinity : box.w / 2 / Math.abs(dx);
+	const ty = dy === 0 ? Infinity : box.h / 2 / Math.abs(dy);
+	const t = Math.min(tx, ty);
+	return {
+		x: c.x + dx * t,
+		y: c.y + dy * t
+	};
+}
+/**
+* The control of the benchmark: each edge is one straight line between its plugs.
+* A free plug goes where the line between the two centers leaves the box.
+*/
+const straightRouter = {
+	name: "straight",
+	route(graph) {
+		const byId = nodeIndex(graph);
+		const routes = [];
+		for (const e of graph.edges) {
+			const s = byId.get(e.source.node);
+			const t = byId.get(e.target.node);
+			if (!s || !t) continue;
+			const fs = fixedPortPoint(s, e.source);
+			const ft = fixedPortPoint(t, e.target);
+			const a = fs ?? boxExit(s.box, ft ?? center(t.box));
+			const b = ft ?? boxExit(t.box, fs ?? center(s.box));
+			routes.push({
+				edge: e.id,
+				points: [a, b]
+			});
+		}
+		return { routes };
+	}
+};
+// src/routers/trunks.ts
+/** The rule that groups the edges by the collection of their target, in `data.collection`. */
+const byCollection = (e) => {
+	const c = e.data?.["collection"];
+	return typeof c === "string" ? c : void 0;
+};
+/**
+* This function groups the edges by their source plug and their key. Each group keeps the order of the edges.
+* A group with fewer than `minSize` edges does not appear.
+*/
+function groupEdges(edges, rule, minSize = 2) {
+	const all = /* @__PURE__ */ new Map();
+	for (const e of edges) {
+		const key = rule(e);
+		if (key === void 0) continue;
+		const id = `${e.source.node}\u0000${e.source.port ?? ""}\u0000${key}`;
+		const list = all.get(id);
+		if (list) list.push(e);
+		else all.set(id, [e]);
+	}
+	for (const [id, list] of all) if (list.length < minSize) all.delete(id);
+	return all;
+}
+/**
+* This function gives the lane order of the branches that leave the split point `from`, with the trunk along `dir`.
+* Lane 0 turns most to the left, in a frame with the y axis down. Thus two lanes do not cross at the split.
+*/
+function laneOrder(dir, from, branches) {
+	const angle = (p) => {
+		const vx = p.x - from.x;
+		const vy = p.y - from.y;
+		return Math.atan2(dir.x * vy - dir.y * vx, dir.x * vx + dir.y * vy);
+	};
+	return branches.map((b) => ({
+		edge: b.edge,
+		a: angle(b.next)
+	})).sort((p, q) => p.a - q.a || (p.edge < q.edge ? -1 : p.edge > q.edge ? 1 : 0)).map((x) => x.edge);
+}
+/**
+* This function gives the split point of a bundle, on the line from `start` to the center of the targets.
+* The point is at `split` of the way, but at most half of the way to the nearest target. It moves back toward `start` out of the boxes.
+*/
+function splitPoint(start, targets, split, free, step) {
+	if (targets.length === 0) return start;
+	const c = {
+		x: targets.reduce((s, p) => s + p.x, 0) / targets.length,
+		y: targets.reduce((s, p) => s + p.y, 0) / targets.length
+	};
+	const L = dist(start, c);
+	if (L === 0) return start;
+	let d = Math.min(split * L, .5 * Math.min(...targets.map((p) => dist(start, p))));
+	const at = (t) => ({
+		x: start.x + (c.x - start.x) * t / L,
+		y: start.y + (c.y - start.y) * t / L
+	});
+	while (d > 0 && !free(at(d))) d -= step;
+	return d > 0 ? at(d) : start;
+}
+const dedupe = (p) => p.filter((q, i) => i === 0 || dist(q, p[i - 1]) > 1e-9);
+/**
+* This function makes a router that bundles the edges by a rule. The edges of a group share one plug and one trunk
+* to a split point. From there, each edge goes its own way. The router gives the bundles with their lane order.
+* The edges outside the groups go as in the corner router.
+*/
+function trunksRouter(options) {
+	const router = {
+		name: options.name,
+		route(graph) {
+			const byId = nodeIndex(graph);
+			const ways = new WayFinder(graph.nodes, options);
+			const points = /* @__PURE__ */ new Map();
+			const bundles = [];
+			for (const [id, group] of groupEdges(graph.edges, options.rule, options.minSize ?? 2)) {
+				const first = group[0];
+				const s = byId.get(first.source.node);
+				const targets = group.map((e) => byId.get(e.target.node));
+				if (!s || targets.some((t) => !t)) continue;
+				const centers = targets.map((t) => center(t.box));
+				const c = {
+					x: centers.reduce((a, p) => a + p.x, 0) / centers.length,
+					y: centers.reduce((a, p) => a + p.y, 0) / centers.length
+				};
+				const plug = placePlug(s, first.source, c);
+				const split = splitPoint(ways.out(plug), centers, options.split ?? .5, (p) => !ways.obstacles.inside(p, ways.margin), ways.margin);
+				const way = ways.fromPlug(plug, split);
+				if (!way) continue;
+				const trunk = dedupe(way);
+				const end = trunk[trunk.length - 1];
+				const prev = trunk.length >= 2 ? trunk[trunk.length - 2] : plug.point;
+				const len = dist(prev, end);
+				const dir = len > 0 ? {
+					x: (end.x - prev.x) / len,
+					y: (end.y - prev.y) / len
+				} : plug.normal;
+				const branches = [];
+				group.forEach((e, i) => {
+					const pt = placePlug(targets[i], e.target, end);
+					const branch = dedupe(ways.toPlug(end, pt) ?? [end, pt.point]);
+					points.set(e.id, dedupe([...trunk, ...branch.slice(1)]));
+					branches.push({
+						edge: e.id,
+						next: branch[1] ?? pt.point
+					});
+				});
+				bundles.push({
+					id: `b${bundles.length}`,
+					key: id.split("\0")[2],
+					node: s.id,
+					edges: laneOrder(dir, end, branches),
+					trunk
+				});
+			}
+			const routes = [];
+			for (const e of graph.edges) {
+				const s = byId.get(e.source.node);
+				const t = byId.get(e.target.node);
+				if (!s || !t) continue;
+				const known = points.get(e.id);
+				if (known) {
+					routes.push({
+						edge: e.id,
+						points: known
+					});
+					continue;
+				}
+				const ps = placePlug(s, e.source, center(t.box));
+				const pt = placePlug(t, e.target, center(s.box));
+				routes.push({
+					edge: e.id,
+					points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
+				});
+			}
+			return {
+				routes,
+				bundles
+			};
+		}
+	};
+	return options.maxNodes === void 0 ? router : {
+		...router,
+		maxNodes: options.maxNodes
+	};
+}
+// src/routers/index.ts
+/** The routers that the benchmark races. */
+const ROUTERS = [
+	straightRouter,
+	plugsRouter,
+	cornersRouter({
+		name: "corners",
+		maxNodes: 1e4
+	}),
+	cornersRouter({
+		name: "corners-smooth",
+		smooth: true,
+		maxNodes: 1e4
+	}),
+	trunksRouter({
+		name: "trunks",
+		rule: byCollection,
+		maxNodes: 1e4
+	}),
+	sharedRouter({
+		name: "shared",
+		rule: byCollection,
+		maxNodes: 1e4
+	}),
+	sharedRouter({
+		name: "shared-all",
+		maxNodes: 1e4
+	}),
+	sectionsRouter({
+		name: "sections",
+		maxNodes: 1e5
+	}),
+	sectionsRouter({
+		name: "sections-tree",
+		stretch: Infinity,
+		maxNodes: 1e5
+	})
+];
+// 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 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;
+		}
+	}
+	return out;
+}
+/** 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;
+const TIGHT = 4;
+const EXACT_CROSSINGS = 2e4;
+const SAMPLE = 2e3;
+const key = (p) => `${Math.round(p.x * 8)},${Math.round(p.y * 8)}`;
+/** This function measures the quality of a result. */
+function measureQuality(graph, result) {
+	const byId = nodeIndex(graph);
+	const nodes = new Grid(180);
+	for (const n of graph.nodes) nodes.add(n, n.box);
+	const segs = [];
+	const seen = /* @__PURE__ */ new Set();
+	let bends = 0;
+	let infl = 0;
+	let clear = 0;
+	let tight = 0;
+	let detour = 0;
+	let detourN = 0;
+	let angle = 0;
+	let angleN = 0;
+	for (const r of result.routes) {
+		const p = r.points;
+		for (let i = 1; i < p.length; i++) {
+			const ka = key(p[i - 1]);
+			const kb = key(p[i]);
+			if (ka === kb) continue;
+			const k = ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`;
+			if (seen.has(k)) continue;
+			seen.add(k);
+			segs.push([p[i - 1], p[i]]);
+		}
+		bends += bendCount(p);
+		infl += inflectionCount(p);
+		const ends = endNodes(graph, byId, r.edge);
+		let c = 40;
+		for (let i = 1; i < p.length; i++) {
+			const a = p[i - 1];
+			const b = p[i];
+			nodes.querySegment(a, b, c, (n) => {
+				if (n !== ends.source && n !== ends.target) c = Math.min(c, segmentBoxDistance(a, b, n.box));
+			});
+		}
+		clear += c;
+		if (c < TIGHT) tight++;
+		if (p.length >= 2) {
+			const d = dist(p[0], p[p.length - 1]);
+			if (d > 1) {
+				detour += polylineLength(p) / d;
+				detourN++;
+			}
+			for (const [at, next, node] of [[
+				p[0],
+				p[1],
+				ends.source
+			], [
+				p[p.length - 1],
+				p[p.length - 2],
+				ends.target
+			]]) {
+				if (!node) continue;
+				const a = sideAngle(node.box, at, next);
+				if (a !== void 0) {
+					angle += a;
+					angleN++;
+				}
+			}
+		}
+	}
+	const n = Math.max(1, result.routes.length);
+	let ink = 0;
+	for (const [a, b] of segs) ink += dist(a, b);
+	const [crossings, crossingsEstimated] = countCrossings(segs);
+	return {
+		ink,
+		crossings,
+		crossingsEstimated,
+		bends: bends / n,
+		inflections: infl / n,
+		clearance: clear / n,
+		tight: tight / n,
+		detour: detourN ? detour / detourN : 1,
+		plugAngle: angleN ? angle / angleN : 0
+	};
+}
+function endNodes(graph, byId, edgeId) {
+	const e = edgeIndex(graph).get(edgeId);
+	return {
+		source: e && byId.get(e.source.node),
+		target: e && byId.get(e.target.node)
+	};
+}
+const edgeIndexes = /* @__PURE__ */ new WeakMap();
+function edgeIndex(graph) {
+	let m = edgeIndexes.get(graph);
+	if (!m) {
+		m = /* @__PURE__ */ new Map();
+		for (const e of graph.edges) m.set(e.id, e);
+		edgeIndexes.set(graph, m);
+	}
+	return m;
+}
+/**
+* This function gives an angle in degrees: the angle between the segment from `at` to `next` and the outward normal.
+* The normal is the normal of the side of the box nearest to `at`. A route that starts inside the box (an interior route) gives no angle.
+*/
+function sideAngle(box, at, next) {
+	const d = [
+		[
+			Math.abs(at.y - box.y),
+			0,
+			-1
+		],
+		[
+			Math.abs(at.x - (box.x + box.w)),
+			1,
+			0
+		],
+		[
+			Math.abs(at.y - (box.y + box.h)),
+			0,
+			1
+		],
+		[
+			Math.abs(at.x - box.x),
+			-1,
+			0
+		]
+	].sort((a, b) => a[0] - b[0])[0];
+	if (d[0] > 1) return void 0;
+	const vx = next.x - at.x;
+	const vy = next.y - at.y;
+	const l = Math.hypot(vx, vy);
+	if (l === 0) return void 0;
+	const cos = Math.max(-1, Math.min(1, (vx * d[1] + vy * d[2]) / l));
+	return Math.acos(cos) * 180 / Math.PI;
+}
+/**
+* This function counts the crossings of a set of segments with a grid of buckets.
+* Above 20 000 segments, it counts the crossings of a seeded sample of 2 000 segments and scales the count.
+*/
+function countCrossings(segs) {
+	if (segs.length < 2) return [0, false];
+	const len = segs.reduce((s, [a, b]) => s + dist(a, b), 0) / segs.length;
+	const grid = new Grid(Math.max(20, len));
+	segs.forEach(([a, b], i) => grid.addSegment(i, a, b));
+	const exact = segs.length <= EXACT_CROSSINGS;
+	const R = rng(segs.length);
+	const pick = exact ? segs.map((_, i) => i) : Array.from({ length: SAMPLE }, () => Math.floor(R() * segs.length));
+	let count = 0;
+	for (const i of pick) {
+		const [a, b] = segs[i];
+		grid.querySegment(a, b, 0, (j) => {
+			if (exact && j <= i) return;
+			if (j === i) return;
+			const [c, d] = segs[j];
+			if (segmentsCross(a, b, c, d)) count++;
+		});
+	}
+	return exact ? [count, false] : [Math.round(count * segs.length / (2 * pick.length)), true];
+}
+/** This function measures how much the routes changed between two results. */
+function measureStability(before, after) {
+	const prev = new Map(before.routes.map((r) => [r.edge, r.points]));
+	let sum = 0;
+	let max = 0;
+	let moved = 0;
+	let n = 0;
+	for (const r of after.routes) {
+		const p = prev.get(r.edge);
+		if (!p) continue;
+		const f = frechet(p, r.points);
+		sum += f;
+		max = Math.max(max, f);
+		if (f > 1) moved++;
+		n++;
+	}
+	return {
+		mean: n ? sum / n : 0,
+		max,
+		moved: n ? moved / n : 0
+	};
+}
+// src/bench/run.ts
+const now = () => 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 = [];
+	for (const spec of fixtures) {
+		const graph = makeFixture(spec);
+		for (const router of routers) if (graph.nodes.length <= (router.maxNodes ?? Infinity)) rows.push(benchOne(router, spec.name, graph, options.repeat ?? 3));
+	}
+	return rows;
+}
+/**
+* This function tells if two values hold the same data, as JSON sees it. It does not make a string,
+* because the result of a large graph can be longer than the longest string.
+*/
+function sameData(a, b) {
+	if (a === b) return true;
+	if (typeof a === "number" && typeof b === "number") return Number.isNaN(a) && Number.isNaN(b);
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	if (Array.isArray(a) !== Array.isArray(b)) return false;
+	if (Array.isArray(a)) {
+		const y = b;
+		if (a.length !== y.length) return false;
+		for (let i = 0; i < a.length; i++) if (!sameData(a[i], y[i])) return false;
+		return true;
+	}
+	const x = a;
+	const y = b;
+	const kx = Object.keys(x).filter((k) => x[k] !== void 0);
+	const ky = Object.keys(y).filter((k) => y[k] !== void 0);
+	if (kx.length !== ky.length) return false;
+	for (const k of kx) if (!sameData(x[k], y[k])) return false;
+	return true;
+}
+/** This function routes one graph with one router and measures the result. */
+function benchOne(router, fixture, graph, repeat = 3) {
+	const times = [];
+	let first;
+	let deterministic = true;
+	for (let i = 0; i < Math.max(2, repeat); i++) {
+		const t0 = now();
+		const r = router.route(graph);
+		times.push(now() - t0);
+		if (!first) first = r;
+		else if (i === 1 && !sameData(r, first)) deterministic = false;
+	}
+	times.sort((a, b) => a - b);
+	const result = first;
+	const all = checkProperties(graph, result, 1e6);
+	return {
+		router: router.name,
+		fixture,
+		nodes: graph.nodes.length,
+		edges: graph.edges.length,
+		ms: times[Math.floor(times.length / 2)],
+		deterministic,
+		violations: all.length,
+		sample: all.slice(0, 5),
+		quality: measureQuality(graph, result)
+	};
+}
+/** This function writes the rows as a Markdown table. */
+function formatTable(rows) {
+	const head = "| router | fixture | nodes | edges | ms | same twice | violations | ink | crossings | bends | inflections | clearance | tight | detour | plug angle |";
+	const line = "|---|---|---:|---:|---:|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|";
+	const f = (v, d = 2) => Number.isInteger(v) ? String(v) : v.toFixed(d);
+	return [
+		head,
+		line,
+		...rows.map((r) => {
+			const q = r.quality;
+			return `| ${r.router} | ${r.fixture} | ${r.nodes} | ${r.edges} | ${f(r.ms, 1)} | ${r.deterministic ? "yes" : "NO"} | ${r.violations} | ${Math.round(q.ink)} | ${q.crossingsEstimated ? "≈" : ""}${q.crossings} | ${f(q.bends)} | ${f(q.inflections)} | ${f(q.clearance, 1)} | ${f(q.tight)} | ${f(q.detour)} | ${f(q.plugAngle, 1)} |`;
+		})
+	].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 };
+
+//# sourceMappingURL=index.js.map