@mark1russell7/highways 0.1.4 → 0.2.0

package/build/index.js

@@ -1510,7 +1510,7 @@ var Obstacles = class {
 	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;
+			if (skip?.has(n) || !hits$1(a, b, n, pad)) return false;
 			found = n;
 			return true;
 		});
@@ -1543,7 +1543,7 @@ var Obstacles = class {
 	}
 };
 /** This function tells if the segment `ab` goes into the box of the node, made larger by `pad`. */
-function hits(a, b, n, pad) {
+function hits$1(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);
 }
@@ -1738,7 +1738,7 @@ var CornerGraph = class {
 					if ((full & cone) !== 0) continue;
 				}
 				let blocked = false;
-				for (let b = 0; b < blockers.length && !blocked; b++) blocked = hits(p, q, blockers[b], pad);
+				for (let b = 0; b < blockers.length && !blocked; b++) blocked = hits$1(p, q, blockers[b], pad);
 				if (blocked) continue;
 				const hit = this.#obstacles.hit(p, q, pad);
 				if (hit !== void 0) blockers.push(hit);
@@ -2340,13 +2340,20 @@ function orderLanes(run, routes) {
 	return [...placed.map((x) => x.edge), ...lost.sort()];
 }
 // src/sections.ts
+/** The default values of `SectionOptions`. */
+const SECTION_DEFAULTS = Object.freeze({
+	cap: 8,
+	maxDepth: 16,
+	collapse: 32
+});
 /**
 * 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 cap = Math.max(1, options.cap ?? SECTION_DEFAULTS.cap);
+	const maxDepth = options.maxDepth ?? SECTION_DEFAULTS.maxDepth;
+	const collapse = options.collapse ?? SECTION_DEFAULTS.collapse;
 	const centers = nodes.map((n) => center(n.box));
 	let x0 = Infinity;
 	let y0 = Infinity;
@@ -2371,7 +2378,7 @@ function buildSections(nodes, options = {}) {
 	};
 	const make = (id, depth, cell, list) => {
 		let box = cell;
-		for (let guard = 0; list.length > cap && depth < maxDepth && guard < 32; guard++) {
+		for (let guard = 0; list.length > cap && depth < maxDepth && guard < collapse; guard++) {
 			const mx = box.x + box.w / 2;
 			const my = box.y + box.h / 2;
 			const parts = [
@@ -2425,6 +2432,156 @@ function allSections(root) {
 function treeDepth(root) {
 	return root.children.reduce((d, c) => Math.max(d, treeDepth(c)), root.depth);
 }
+/**
+* This function examines a tree of sections from a grouping rule. It throws an error when the tree is not valid for `count` nodes.
+* In a valid tree, each node is in exactly one leaf. The children of a section split its nodes, and a child is one level deeper than its parent.
+*/
+function checkSections(root, count) {
+	const seen = new Array(count).fill(0);
+	const ids = /* @__PURE__ */ new Set();
+	const fail = (s, what) => {
+		throw new Error(`The tree of sections is not valid at the section "${s.id}": ${what}.`);
+	};
+	if (root.depth !== 0) fail(root, "the root has a depth that is not 0");
+	if (root.nodes.length !== count) fail(root, `the root has ${root.nodes.length} nodes, and the graph has ${count}`);
+	const walk = (s) => {
+		if (ids.has(s.id)) fail(s, "two sections have this id");
+		ids.add(s.id);
+		if (s.children.length === 0) {
+			for (const i of s.nodes) {
+				if (!Number.isInteger(i) || i < 0 || i >= count) fail(s, `the node index ${i} is not in the graph`);
+				seen[i]++;
+			}
+			return;
+		}
+		let total = 0;
+		const own = new Set(s.nodes);
+		for (const c of s.children) {
+			if (c.depth !== s.depth + 1) fail(c, "a child is not one level deeper than its parent");
+			for (const i of c.nodes) if (!own.has(i)) fail(c, `the node index ${i} is not in the parent`);
+			total += c.nodes.length;
+			walk(c);
+		}
+		if (total !== s.nodes.length) fail(s, "the children do not split the nodes of the section");
+	};
+	walk(root);
+	const lost = seen.findIndex((n) => n !== 1);
+	if (lost >= 0) fail(root, `the node index ${lost} is in ${seen[lost]} leaves, not in one`);
+}
+// src/groups/quadtree/index.ts
+/**
+* This function gives the tree of sections of the grouping rule `quadtree`: the cells of a quadtree of the plane (`buildSections`).
+* It is the default grouping rule of the router `sections`.
+*/
+function quadtreeGroups(graph, options = {}) {
+	return buildSections(graph.nodes, options);
+}
+// src/groups/keys/index.ts
+/** This key rule gives the string `data.group` of the node, or `undefined` when the node has no such string. */
+const byDataGroup = (node) => {
+	const group = node.data?.["group"];
+	return typeof group === "string" ? group : void 0;
+};
+/** This function gives the bounding box of the boxes of the nodes of the list. */
+function boundsOf(nodes, list) {
+	let x0 = Infinity;
+	let y0 = Infinity;
+	let x1 = -Infinity;
+	let y1 = -Infinity;
+	for (const i of list) {
+		const b = 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 list.length ? {
+		x: x0,
+		y: y0,
+		w: x1 - x0,
+		h: y1 - y0
+	} : {
+		x: 0,
+		y: 0,
+		w: 0,
+		h: 0
+	};
+}
+/**
+* This function gives the tree of sections of the grouping rule `keys`. The root holds each node. Each child of the root holds the nodes of one key,
+* in the order of their first node. The id of a group is `s:` and its key. A node without a key is a group alone, with the id `s#` and its index.
+* Thus the far view of the router `sections` shows one item for each group.
+*/
+function keyedSections(nodes, options = {}) {
+	const key = options.key ?? byDataGroup;
+	const groups = /* @__PURE__ */ new Map();
+	nodes.forEach((n, i) => {
+		const k = key(n, i);
+		const id = k === void 0 ? `s#${i}` : `s:${k}`;
+		const list = groups.get(id);
+		if (list) list.push(i);
+		else groups.set(id, [i]);
+	});
+	const children = [...groups].map(([id, list]) => group(nodes, id, list, options.split));
+	return {
+		id: "s",
+		depth: 0,
+		cell: boundsOf(nodes, nodes.map((_, i) => i)),
+		nodes: nodes.map((_, i) => i),
+		children
+	};
+}
+/** This function gives the section of one group at depth 1. With `split`, the section has the quadtree of its nodes below it. */
+function group(nodes, id, list, split) {
+	if (!split) return {
+		id,
+		depth: 1,
+		cell: boundsOf(nodes, list),
+		nodes: list,
+		children: []
+	};
+	const tree = buildSections(list.map((i) => nodes[i]), split);
+	const rebase = (s) => ({
+		id: s.id === "s" ? id : `${id}/${s.id.slice(1)}`,
+		depth: s.depth + 1,
+		cell: s.cell,
+		nodes: s.nodes.map((j) => list[j]),
+		children: s.children.map(rebase)
+	});
+	return rebase(tree);
+}
+/** This function gives the tree of sections of the grouping rule `keys` for a graph. */
+function keyGroups(graph, options = {}) {
+	return keyedSections(graph.nodes, options);
+}
+// src/pick.ts
+/** This function gives the median width of the shown items of each level, in units of the plane. */
+function itemSizes(levels) {
+	return levels.map((level) => {
+		const sizes = level.items.map((i) => Math.max(i.box.w, i.box.h)).sort((a, b) => a - b);
+		return sizes.length ? sizes[Math.floor(sizes.length / 2)] : 0;
+	});
+}
+/** The default thresholds: a node of 22 pixels shows its routes, and a group of 120 pixels shows its parts. */
+const PICK = Object.freeze({
+	routesAt: 22,
+	itemAt: 120
+});
+/**
+* This function picks the level that a camera shows at a scale, in pixels for each unit of the plane. The sizes come from `itemSizes`.
+* The value `sizes.length` stands for the routes of each edge. The last level holds the nodes alone.
+* Each threshold that `options` does not give gets its value from `PICK`.
+*/
+function pickLevel(sizes, scale, options = PICK) {
+	const routesAt = options.routesAt ?? PICK.routesAt;
+	const itemAt = options.itemAt ?? PICK.itemAt;
+	const n = sizes.length;
+	if (n === 0) return 0;
+	if (sizes[n - 1] * scale >= routesAt) return n;
+	let pick = 0;
+	for (let d = 0; d < n - 1; d++) if (sizes[d] * scale >= itemAt) pick = d;
+	return pick;
+}
 // src/routers/corners.ts
 /**
 * This function makes a router that goes around the nodes.
@@ -2623,9 +2780,12 @@ function sumFaults(list) {
 	});
 }
 // 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;
+/** The default values of the two limits of `LevelLinkOptions`. */
+const LEVEL_LINK_DEFAULTS = Object.freeze({
+	tightMargin: 1,
+	plugInset: 6
+});
+const EPS$1 = 1e-6;
 /**
 * This function removes the repeated points, the points in the middle of a straight run,
 * and the points where the way turns back on itself.
@@ -2633,15 +2793,15 @@ const EPS = 1e-6;
 function tidy(p) {
 	const out = [];
 	for (const q of p) {
-		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS) continue;
+		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$1) continue;
 		while (out.length >= 2) {
 			const a = out[out.length - 2];
 			const b = out[out.length - 1];
 			const cross = (b.x - a.x) * (q.y - b.y) - (b.y - a.y) * (q.x - b.x);
-			if (Math.abs(cross) > EPS * (1 + dist(a, b) * dist(b, q))) break;
+			if (Math.abs(cross) > EPS$1 * (1 + dist(a, b) * dist(b, q))) break;
 			out.pop();
 		}
-		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS) continue;
+		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$1) continue;
 		out.push(q);
 	}
 	return out;
@@ -2659,7 +2819,7 @@ function levelLinks(items, pairs, options = {}) {
 	}));
 	const byId = new Map(nodes.map((n) => [n.id, n]));
 	const ways = levelWays(nodes, options);
-	const inset = Math.min(6, ways.margin);
+	const inset = Math.min(options.plugInset ?? LEVEL_LINK_DEFAULTS.plugInset, ways.margin);
 	const out = [];
 	for (const p of pairs) {
 		const s = byId.get(p.source);
@@ -2713,7 +2873,7 @@ function levelWays(nodes, options) {
 	});
 	let tight;
 	const tightGraph = () => tight ??= new CornerGraph(nodes, obstacles, {
-		margin: Math.min(margin, TIGHT_MARGIN),
+		margin: Math.min(margin, options.tightMargin ?? LEVEL_LINK_DEFAULTS.tightMargin),
 		k,
 		cones: true
 	});
@@ -2881,7 +3041,7 @@ function freeSpans(lo, hi, covered) {
 		if (x >= hi) break;
 	}
 	if (x < hi) out.push([x, hi]);
-	return out.filter(([a, b]) => b - a > EPS);
+	return out.filter(([a, b]) => b - a > EPS$1);
 }
 /**
 * This function gives the shortest way between the free plugs of the two nodes, or `undefined` when the second corner graph has none.
@@ -3013,7 +3173,7 @@ function squarePull(p, obstacles, pad, first, last, lookahead = 16) {
 		out.push(...step.legs);
 		const end = out[out.length - 1];
 		const before = out[out.length - 2];
-		axis = Math.abs(end.y - before.y) < EPS ? "x" : Math.abs(end.x - before.x) < EPS ? "y" : void 0;
+		axis = Math.abs(end.y - before.y) < EPS$1 ? "x" : Math.abs(end.x - before.x) < EPS$1 ? "y" : void 0;
 		i = step.j;
 	}
 	return out;
@@ -3023,7 +3183,7 @@ function squarePull(p, obstacles, pad, first, last, lookahead = 16) {
 * Of two clear corners, it picks the corner that continues the axis `from` and arrives along the axis `to`.
 */
 function square(a, b, obstacles, pad, from, to) {
-	if (Math.abs(a.x - b.x) < EPS || Math.abs(a.y - b.y) < EPS) return obstacles.clear(a, b, pad) ? [b] : void 0;
+	if (Math.abs(a.x - b.x) < EPS$1 || Math.abs(a.y - b.y) < EPS$1) return obstacles.clear(a, b, pad) ? [b] : void 0;
 	const options = [{
 		c: {
 			x: b.x,
@@ -3041,13 +3201,20 @@ function square(a, b, obstacles, pad, from, to) {
 	for (const { c } of options) if (obstacles.clear(a, c, pad) && obstacles.clear(c, b, pad)) return [c, b];
 }
 // src/routers/sections.ts
+/** The default values of the numbers of `SectionsOptions`: the limits of the hubs, of the tree and of the level links. */
+const SECTIONS_DEFAULTS = Object.freeze({
+	cap: SECTION_DEFAULTS.cap,
+	maxDepth: SECTION_DEFAULTS.maxDepth,
+	collapse: SECTION_DEFAULTS.collapse,
+	tightMargin: LEVEL_LINK_DEFAULTS.tightMargin,
+	plugInset: LEVEL_LINK_DEFAULTS.plugInset,
+	hubs: Infinity,
+	stretch: 2,
+	stretchPad: 4,
+	hubSlack: 80
+});
 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.
@@ -3062,12 +3229,14 @@ function sectionsRouter(options) {
 	const router = {
 		name: options.name,
 		route(graph) {
-			const stretch = options.stretch ?? 2;
+			const stretch = options.stretch ?? SECTIONS_DEFAULTS.stretch;
+			const stretchPad = options.stretchPad ?? SECTIONS_DEFAULTS.stretchPad;
+			const hubSlack = options.hubSlack ?? SECTIONS_DEFAULTS.hubSlack;
 			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 root = groupNodes(graph, options);
 			const parent = /* @__PURE__ */ new Map();
 			const leafOf = [];
 			for (const s of allSections(root)) {
@@ -3101,7 +3270,7 @@ function sectionsRouter(options) {
 				let last = from;
 				for (const c of list) {
 					const h = hub(c);
-					if (dist(h, to) > near + HUB_SLACK) continue;
+					if (dist(h, to) > near + hubSlack) continue;
 					near = Math.min(near, pointSegmentDistance(to, last, h));
 					last = h;
 					kept.push(c);
@@ -3151,7 +3320,7 @@ function sectionsRouter(options) {
 				const b = up(lv);
 				const common = new Set(b);
 				const lca = a.find((x) => common.has(x));
-				const keep = options.hubs ?? Infinity;
+				const keep = options.hubs ?? SECTIONS_DEFAULTS.hubs;
 				const side = (list) => list.slice(Math.max(0, list.indexOf(lca) - keep), list.indexOf(lca));
 				const end = ways.out(pt);
 				const start = ways.out(ps);
@@ -3172,7 +3341,7 @@ function sectionsRouter(options) {
 				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));
 				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 || goesOutAndBack(out)) {
+				if (polylineLength(out) > stretch * dist(ps.point, pt.point) + stretchPad * ways.margin || goesOutAndBack(out)) {
 					routes.push({
 						edge: e.id,
 						points: ways.between(ps, pt, /* @__PURE__ */ new Set([s, t]))
@@ -3213,8 +3382,16 @@ function sectionsRouter(options) {
 		maxNodes: options.maxNodes
 	};
 }
+/** This function gives the tree of sections of the grouping rule. It examines the tree of a strategy (`checkSections`). */
+function groupNodes(graph, options) {
+	if (!options.group) return buildSections(graph.nodes, options);
+	const root = options.group.run(graph, options.groupOptions);
+	checkSections(root, graph.nodes.length);
+	return root;
+}
 /**
 * This function gives one zoom level for each depth of the tree, and a last level with each node alone.
+* With the option `levels`, only those depths get a level with groups.
 * At depth d, a section of depth d is one item. A link joins two items and counts the edges between them.
 * In a level with groups, a link goes around the boxes of the other items (`levelLinks`).
 * In the last level, the points of a link are the route of its first edge.
@@ -3223,7 +3400,9 @@ function makeLevels(graph, root, routeOf, options) {
 	const indexOfNode = new Map(graph.nodes.map((n, i) => [n.id, i]));
 	const levels = [];
 	const deepest = treeDepth(root);
+	const shown = options.levels && new Set(options.levels);
 	for (let d = 0; d <= deepest + 1; d++) {
+		if (shown && d <= deepest && !shown.has(d)) continue;
 		const items = [];
 		const itemOf = [];
 		const boxOf = (list) => {
@@ -3700,7 +3879,7 @@ function trunksRouter(options) {
 	};
 }
 // src/routers/index.ts
-/** The routers that the benchmark races. */
+/** The built-in routers. The registry `STRATEGIES` holds the same routers as strategies, and the benchmark races the routers of the registry. */
 const ROUTERS = [
 	straightRouter,
 	plugsRouter,
@@ -3823,17 +4002,34 @@ function openGaps(items, gaps, snap = DEFAULT_SNAP) {
 * 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 snap = options.snap ?? DEFAULT_SNAP;
+	const passes = Math.max(1, Math.floor(options.passes ?? 1));
+	let total = demandOnce(items, links, options);
+	for (let p = 1; p < passes; p++) {
+		const next = demandOnce(openGaps(items, total, snap), links, options);
+		if (next.length !== total.length || next.some((g, i) => g.axis !== total[i].axis)) break;
+		total = total.map((g, i) => ({
+			...g,
+			lanes: Math.max(g.lanes, next[i].lanes),
+			need: g.need + Math.max(0, next[i].need - next[i].width)
+		}));
+	}
+	return capGrowth(items, total, gutter, options.maxGrowth ?? Infinity);
+}
+/** This function gives the demand of one pass, without the limit `maxGrowth`. */
+function demandOnce(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) => ({
+	return 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 = {}) {
@@ -4018,6 +4214,141 @@ function capGrowth(items, gaps, gutter, maxGrowth) {
 	}
 	return out;
 }
+// src/room/lanes.ts
+/** The lane orders of `gapLanes`, in the order of the benchmark. */
+const LANE_ORDERS = [
+	"links",
+	"ends",
+	"crossings"
+];
+const EPS = 1e-6;
+const ROUNDS = 8;
+/**
+* This function gives each link that runs along a gap its own lane in the gap. The lanes of a gap are `spacing` apart, around its middle line.
+* A leg of a link moves across its gap only, so the link keeps its plugs and the axes of its legs.
+* When a move puts a link through more boxes than before, the link keeps its points.
+*/
+function gapLanes(items, links, options = {}) {
+	const spacing = Math.max(0, options.spacing ?? 4);
+	const order = options.order ?? "crossings";
+	const moved = links.map((l) => l.points.map((p) => ({
+		x: p.x,
+		y: p.y
+	})));
+	for (const g of boardGaps(items, options.snap)) {
+		if (g.width <= EPS) continue;
+		const across = g.axis;
+		const along = g.axis === "x" ? "y" : "x";
+		const lo = g.at - g.width;
+		const hi = g.at;
+		const pieces = [];
+		links.forEach((l, li) => {
+			const p = l.points;
+			for (let i = 2; i <= p.length - 2; i++) {
+				const a = p[i - 1];
+				const b = p[i];
+				if (Math.abs(a[across] - b[across]) > EPS || a[across] <= lo + EPS || a[across] >= hi - EPS) continue;
+				if (Math.abs(a[along] - b[along]) <= EPS) continue;
+				const side = (q, r) => Math.sign(r[across] - q[across]);
+				pieces.push({
+					link: li,
+					seg: i,
+					lo: Math.min(a[along], b[along]),
+					hi: Math.max(a[along], b[along]),
+					turns: [[a[along], side(a, p[i - 2])], [b[along], side(b, p[i + 1])]]
+				});
+			}
+		});
+		if (pieces.length === 0) continue;
+		const list = orderPieces(pieces, order);
+		const lane = [];
+		let n = 0;
+		list.forEach((P, i) => {
+			let k = 0;
+			for (let j = 0; j < i; j++) if (overlaps(list[j], P)) k = Math.max(k, lane[j] + 1);
+			lane.push(k);
+			n = Math.max(n, k + 1);
+		});
+		const step = Math.min(spacing, g.width / (n + 1));
+		const mid = (lo + hi) / 2;
+		list.forEach((P, i) => {
+			const v = mid + (lane[i] - (n - 1) / 2) * step;
+			moved[P.link][P.seg - 1][across] = v;
+			moved[P.link][P.seg][across] = v;
+		});
+	}
+	const boxes = new Grid(Math.max(20, meanSide(items)));
+	for (const i of items) boxes.add(i.box, i.box);
+	return links.map((l, i) => hits(boxes, moved[i]) > hits(boxes, l.points) ? l : {
+		...l,
+		points: moved[i]
+	});
+}
+const overlaps = (P, Q) => Math.min(P.hi, Q.hi) - Math.max(P.lo, Q.lo) > EPS;
+/**
+* This function counts the crossings when the piece `P` is on the near side of the piece `Q`.
+* A turn of `P` to the far side crosses `Q` when it is inside the span of `Q`. A turn of `Q` to the near side crosses `P` in the same way.
+*/
+function cost(P, Q) {
+	let c = 0;
+	for (const [y, s] of P.turns) if (s > 0 && y > Q.lo + EPS && y < Q.hi - EPS) c++;
+	for (const [y, s] of Q.turns) if (s < 0 && y > P.lo + EPS && y < P.hi - EPS) c++;
+	return c;
+}
+/** This function gives the pieces of one gap in lane order, from the near side to the far side. */
+function orderPieces(pieces, order) {
+	if (order === "links") return [...pieces];
+	const sum = (P) => P.turns.reduce((s, [, side]) => s + side, 0);
+	const list = [...pieces].sort((P, Q) => sum(P) - sum(Q) || P.link - Q.link || P.seg - Q.seg);
+	if (order === "ends") return list;
+	const n = list.length;
+	const index = new Map(list.map((P, i) => [P, i]));
+	const c = list.map((P) => list.map((Q) => P !== Q && overlaps(P, Q) ? cost(P, Q) : 0));
+	const at = (P, Q) => c[index.get(P)][index.get(Q)];
+	for (let round = 0; round < ROUNDS; round++) {
+		let better = false;
+		for (let i = 0; i < n; i++) {
+			const x = list[i];
+			let best = 0;
+			let to = i;
+			let d = 0;
+			for (let k = i - 1; k >= 0; k--) {
+				d += at(x, list[k]) - at(list[k], x);
+				if (d < best) [best, to] = [d, k];
+			}
+			d = 0;
+			for (let k = i + 1; k < n; k++) {
+				d += at(list[k], x) - at(x, list[k]);
+				if (d < best) [best, to] = [d, k];
+			}
+			if (to !== i) {
+				list.splice(i, 1);
+				list.splice(to, 0, x);
+				better = true;
+			}
+		}
+		if (!better) break;
+	}
+	return list;
+}
+/** This function gives the mean of the longer side of the boxes. */
+function meanSide(items) {
+	let s = 0;
+	for (const i of items) s += Math.max(i.box.w, i.box.h);
+	return items.length ? s / items.length : 1;
+}
+/** This function counts the legs of a polyline that go through a box, for each box. */
+function hits(boxes, p) {
+	let n = 0;
+	for (let i = 1; i < p.length; i++) {
+		const a = p[i - 1];
+		const b = p[i];
+		boxes.querySegment(a, b, 0, (box) => {
+			if (segmentHitsBox(a, b, box)) n++;
+		});
+	}
+	return n;
+}
 // src/bench/quality.ts
 /** The clearance stops at this distance. */
 const CLEARANCE_CAP = 40;
@@ -4203,7 +4534,7 @@ function measureStability(before, after) {
 	};
 }
 // src/bench/run.ts
-const now$2 = () => globalThis.performance?.now() ?? Date.now();
+const now$3 = () => 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 = [];
@@ -4242,9 +4573,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$2();
+		const t0 = now$3();
 		const r = router.route(graph);
-		times.push(now$2() - t0);
+		times.push(now$3() - t0);
 		if (!first) first = r;
 		else if (i === 1 && !sameData(r, first)) deterministic = false;
 	}
@@ -4306,14 +4637,233 @@ function formatFaults(rows) {
 		})
 	].join("\n");
 }
+// src/strategies/model.ts
+/** The steps that have strategies, in the order of the pipeline. */
+const STEPS = [
+	"group",
+	"router",
+	"curve",
+	"room"
+];
+/**
+* This function makes a strategy from its definition. The strategy fills the missing options from `defaults`.
+* When the caller gives no option, the definition gets the `defaults` object itself.
+*/
+function defineStrategy(definition) {
+	const { step, name, describe, defaults, maxNodes } = definition;
+	if (name.length === 0) throw new Error(`A strategy of the step "${step}" has no name.`);
+	const strategy = {
+		step,
+		name,
+		describe,
+		defaults: Object.freeze({ ...defaults }),
+		...maxNodes === void 0 ? {} : { maxNodes },
+		run(input, options) {
+			const all = options === void 0 || Object.keys(options).length === 0 ? strategy.defaults : {
+				...strategy.defaults,
+				...options
+			};
+			return definition.run(input, all);
+		}
+	};
+	return Object.freeze(strategy);
+}
+/** This function makes a registry from a list of strategies. It keeps their order. Two strategies with one step and one name are an error. */
+function createRegistry(strategies) {
+	const out = {
+		group: [],
+		router: [],
+		curve: [],
+		room: []
+	};
+	for (const s of strategies) {
+		const list = out[s.step];
+		if (!list) throw new Error(`There is no step "${String(s.step)}". The steps are ${STEPS.join(", ")}.`);
+		if (list.some((t) => t.name === s.name)) throw new Error(`The step "${s.step}" has two strategies with the name "${s.name}".`);
+		list.push(s);
+	}
+	return Object.freeze({
+		group: Object.freeze(out.group),
+		router: Object.freeze(out.router),
+		curve: Object.freeze(out.curve),
+		room: Object.freeze(out.room)
+	});
+}
+/** This function gives a new registry with the strategies of `registry` and then `strategies`. It does not change `registry`. */
+function register(registry, ...strategies) {
+	return createRegistry([
+		...registry.group ?? [],
+		...registry.router,
+		...registry.curve,
+		...registry.room,
+		...strategies
+	]);
+}
+/** This function gives the strategies of one step of a registry, in order. */
+function listStrategies(registry, step) {
+	return registry[step] ?? [];
+}
+/** This function gives the strategy of one step with a name, or `undefined` when the registry has no such strategy. */
+function findStrategy(registry, step, name) {
+	return listStrategies(registry, step).find((s) => s.name === name);
+}
+/** This function gives the strategy of one step with a name. When the registry has no such strategy, the function throws an error. */
+function getStrategy(registry, step, name) {
+	const s = findStrategy(registry, step, name);
+	if (!s) throw new Error(`There is no ${step} "${name}". The registry has ${listStrategies(registry, step).map((t) => t.name).join(", ")}.`);
+	return s;
+}
+/** This function gives a `Router` that runs a router strategy with the options. The router keeps the name and the `maxNodes` of the strategy. */
+function asRouter(strategy, options) {
+	return {
+		name: strategy.name,
+		...strategy.maxNodes === void 0 ? {} : { maxNodes: strategy.maxNodes },
+		route: (graph) => strategy.run(graph, options)
+	};
+}
+/** This function gives the router strategies of a registry as `Router` objects, in order. The benchmark races them. */
+function routersOf(registry) {
+	return listStrategies(registry, "router").map((s) => asRouter(s));
+}
+// src/strategies/builtins.ts
+/** This function makes a router strategy from a router factory and a preset of its options. Each call makes the router of its options. */
+function routerStrategy(name, describe, maxNodes, defaults, make) {
+	return defineStrategy({
+		step: "router",
+		name,
+		describe,
+		defaults,
+		maxNodes,
+		run: (graph, options) => make({
+			...options,
+			name
+		}).route(graph)
+	});
+}
+/** This function makes a router strategy for a router without options. */
+function fixedRouter(router, describe) {
+	return defineStrategy({
+		step: "router",
+		name: router.name,
+		describe,
+		defaults: {},
+		run: (graph) => router.route(graph)
+	});
+}
+/** The built-in router strategies, in the order of the benchmark. They route as the routers of `ROUTERS`. */
+const routerStrategies = Object.freeze({
+	straight: fixedRouter(straightRouter, "The control. Each edge is one straight line between its plugs."),
+	plugs: fixedRouter(plugsRouter, "Each edge leaves its plug along the normal of the side and follows the curve of the inflection rule. It does not go around the nodes."),
+	corners: routerStrategy("corners", "Each edge goes around the nodes on a shortest path (A*) through a sparse visibility graph of the box corners.", 1e4, {}, cornersRouter),
+	"corners-smooth": routerStrategy("corners-smooth", "The same paths as `corners`. A route in clear view follows the inflection rule, and the other routes get round corners.", 1e4, { smooth: true }, cornersRouter),
+	trunks: routerStrategy("trunks", "A rule puts edges in groups. The edges of a group leave one plug of one node on one trunk. At a split point, each edge goes on to its target.", 1e4, { rule: byCollection }, trunksRouter),
+	shared: routerStrategy("shared", "The edges of one collection share their ways through the corner graph. A link that the group uses already costs half.", 1e4, { rule: byCollection }, sharedRouter),
+	"shared-all": routerStrategy("shared-all", "The same as `shared`, but all edges share their ways.", 1e4, {}, sharedRouter),
+	sections: routerStrategy("sections", "A tree of sections, with a hub in each section. A long edge goes through the hubs, and a short edge goes directly.", 1e5, {}, sectionsRouter),
+	"sections-tree": routerStrategy("sections-tree", "The same as `sections`, but without the limit of the stretch.", 1e5, { stretch: Infinity }, sectionsRouter)
+});
+/** The context of a curve input, without the keys that have no value. */
+const contextOf = (input) => ({
+	...input.startNormal ? { startNormal: input.startNormal } : {},
+	...input.endNormal ? { endNormal: input.endNormal } : {},
+	...input.space ? { space: input.space } : {}
+});
+/** The built-in curve strategies, in the order of `CURVE_TYPES`. Each one gives the same segments as `curveOf` with its type. */
+const curveStrategies = Object.freeze({
+	straight: defineStrategy({
+		step: "curve",
+		name: "straight",
+		describe: "The polyline as it is.",
+		defaults: {},
+		run: (input) => straightCurve(input.points)
+	}),
+	rounded: defineStrategy({
+		step: "curve",
+		name: "rounded",
+		describe: "A quadratic Bezier curve at each corner, as `roundCorners` draws it. The first and the last legs stay.",
+		defaults: { radius: 12 },
+		run: (input, o) => roundedCurve(input.points, {
+			...contextOf(input),
+			radius: o.radius
+		})
+	}),
+	spline: defineStrategy({
+		step: "curve",
+		name: "spline",
+		describe: "A centripetal Catmull-Rom spline through each point. It does not overshoot or make loops in a piece.",
+		defaults: { tension: 0 },
+		run: (input, o) => splineCurve(input.points, {
+			...contextOf(input),
+			tension: o.tension
+		})
+	}),
+	arc: defineStrategy({
+		step: "curve",
+		name: "arc",
+		describe: "A circular arc at each corner, tangent to the two legs. The first and the last legs stay.",
+		defaults: { radius: 12 },
+		run: (input, o) => arcCurve(input.points, {
+			...contextOf(input),
+			radius: o.radius
+		})
+	})
+});
+const roomStrategy = (method, describe) => defineStrategy({
+	step: "room",
+	name: method,
+	describe,
+	defaults: {},
+	run: (input, o) => roomDemand(input.items, input.links, {
+		...o,
+		method
+	})
+});
+/** The built-in room strategies: the methods of `roomDemand`. */
+const roomStrategies = Object.freeze({
+	routes: roomStrategy("routes", "The lanes of a gap are the most routes that run along it side by side, with each gap open to the gutter."),
+	lines: roomStrategy("lines", "The lanes of a gap are the straight lines between the centers of the boxes that cross the gap.")
+});
+/** The built-in grouping rules: the strategies of the step `group`. The router `sections` makes its hubs and its zoom levels from their tree. */
+const groupStrategies = Object.freeze({
+	quadtree: defineStrategy({
+		step: "group",
+		name: "quadtree",
+		describe: "The cells of a quadtree of the plane. A cell with more than `cap` nodes splits in four. It is the default rule of the router `sections`.",
+		defaults: { ...SECTION_DEFAULTS },
+		run: (graph, o) => quadtreeGroups(graph, o)
+	}),
+	keys: defineStrategy({
+		step: "group",
+		name: "keys",
+		describe: "One group for each key of the nodes. The default key is the string `data.group` of the node. A node without a key is a group alone.",
+		defaults: { key: byDataGroup },
+		run: (graph, o) => keyGroups(graph, o)
+	})
+});
+/** The built-in strategies of each step, in order. A consumer adds its own: `createRegistry([...BUILT_IN_STRATEGIES, mine])`. */
+const BUILT_IN_STRATEGIES = Object.freeze([
+	...Object.values(groupStrategies),
+	...Object.values(routerStrategies),
+	...Object.values(curveStrategies),
+	...Object.values(roomStrategies)
+]);
+/** The registry of the built-in strategies. The benchmark and the site take their lists from it. */
+const STRATEGIES = createRegistry(BUILT_IN_STRATEGIES);
 // src/bench/curves.ts
-const now$1 = () => globalThis.performance?.now() ?? Date.now();
+const now$2 = () => 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 = {}) {
+	return benchCurveStrategies(router, fixture, graph, CURVE_TYPES.map((t) => curveStrategies[t]), options);
+}
+/**
+* This function does the work of `benchCurves` with a list of curve strategies, in place of the curve types.
+* The option `radius` goes to each strategy. A strategy without such an option does not read it.
+*/
+function benchCurveStrategies(router, fixture, graph, curves, options = {}) {
 	const tolerance = options.tolerance ?? .25;
 	const result = router.route(graph);
 	const byId = nodeIndex(graph);
@@ -4337,27 +4887,27 @@ function benchCurves(router, fixture, graph, options = {}) {
 	});
 	const base = measureLinks(boxes, routes);
 	const ink = routes.reduce((sum, r) => sum + polylineLength(r.points), 0);
-	return CURVE_TYPES.map((type) => {
+	const radius = { radius: options.radius ?? 12 };
+	return curves.map((curve) => {
 		const make = (withSpace) => routes.map((r) => ({
 			source: r.source,
 			target: r.target,
-			points: sampleCurve(curveOf(r.points, {
-				type,
-				radius: options.radius ?? 12,
+			points: sampleCurve(curve.run({
+				points: r.points,
 				startNormal: r.startNormal,
 				endNormal: r.endNormal,
 				...withSpace ? { space } : {}
-			}), tolerance)
+			}, radius), tolerance)
 		}));
 		const free = measureLinks(boxes, make(false));
-		const t0 = now$1();
+		const t0 = now$2();
 		const clamped = make(true);
-		const ms = now$1() - t0;
+		const ms = now$2() - t0;
 		const length = clamped.reduce((sum, l) => sum + polylineLength(l.points), 0);
 		return {
 			router: router.name,
 			fixture,
-			type,
+			type: curve.name,
 			links: routes.length,
 			through: base.through,
 			free: free.through,
@@ -4376,7 +4926,7 @@ function formatCurves(rows) {
 	].join("\n");
 }
 // src/bench/room.ts
-const now = () => globalThis.performance?.now() ?? Date.now();
+const now$1 = () => globalThis.performance?.now() ?? Date.now();
 /** This function gives the area of the bounding box of the nodes. */
 function areaOf(nodes) {
 	let x0 = Infinity;
@@ -4393,11 +4943,13 @@ function areaOf(nodes) {
 }
 /**
 * 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`.
+* With a lane order, each link of the far view gets its own lane in each gap (`gapLanes` at the lane width `spacing`).
+* Without it, the links of a gap share the lines of the level links.
+* The function also measures the lane routes of the router `sections` at the lane width `spacing`.
 */
-function measureBoard(graph, spacing) {
+function measureBoard(graph, spacing, order) {
 	const links = roomLinks(graph);
-	const drawn = levelLinks(graph.nodes.map((n) => ({
+	const level = levelLinks(graph.nodes.map((n) => ({
 		id: n.id,
 		box: n.box,
 		nodes: [n.id]
@@ -4406,6 +4958,10 @@ function measureBoard(graph, spacing) {
 		target: l.target,
 		count: l.count ?? 1
 	})));
+	const drawn = order ? gapLanes(graph.nodes, level, {
+		spacing,
+		order
+	}) : level;
 	const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
 	const edgeOf = /* @__PURE__ */ new Map();
 	for (const e of graph.edges) {
@@ -4427,10 +4983,10 @@ function measureBoard(graph, spacing) {
 	};
 }
 /**
-* 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`.
+* This function measures a packed board, the board with each gap open to the gutter only, and the board that each room strategy opens.
+* The options are the same for each strategy, except `method`. The default strategies are the methods `routes` and `lines` of `roomDemand`.
 */
-function benchRoom(fixture, graph, options = {}) {
+function benchRoom(fixture, graph, options = {}, methods = [roomStrategies.routes, roomStrategies.lines]) {
 	const spacing = options.spacing ?? 4;
 	const area0 = areaOf(graph.nodes);
 	const links = roomLinks(graph);
@@ -4445,28 +5001,129 @@ function benchRoom(fixture, graph, options = {}) {
 		}, spacing)
 	});
 	const rows = [row("packed", graph.nodes, 0)];
-	const states = [
-		["gutter", {
-			...options,
-			spacing: 0,
-			method: "routes"
-		}],
-		["routes", {
-			...options,
+	const t0 = now$1();
+	const gutter = makeRoom(graph.nodes, links, {
+		...options,
+		spacing: 0,
+		method: "routes"
+	});
+	rows.push(row("gutter", gutter.items, now$1() - t0));
+	const { method: _method, ...preset } = options;
+	for (const s of methods) {
+		const t1 = now$1();
+		const gaps = s.run({
+			items: graph.nodes,
+			links
+		}, preset);
+		const nodes = openGaps(graph.nodes, gaps, options.snap);
+		rows.push(row(s.name, nodes, now$1() - t1));
+	}
+	return rows;
+}
+/**
+* This function measures the board that `makeRoom` opens with each setting, with the method `routes`.
+* The first row is the fair baseline: the board with each gap open to the gutter of `baseline` only, measured at the spacing of `baseline`.
+*/
+function sweepRoom(fixture, graph, settings, baseline = {
+	gutter: 8,
+	spacing: 4
+}) {
+	const area0 = areaOf(graph.nodes);
+	const links = roomLinks(graph);
+	const row = (board, nodes, ms, spacing, lanes) => ({
+		fixture,
+		board,
+		area: area0 > 0 ? areaOf(nodes) / area0 : 1,
+		ms,
+		...measureBoard({
+			nodes,
+			edges: graph.edges
+		}, spacing, lanes)
+	});
+	const rows = [row("gutter", makeRoom(graph.nodes, links, {
+		...baseline,
+		spacing: 0,
+		method: "routes",
+		maxGrowth: Infinity,
+		passes: 1
+	}).items, 0, baseline.spacing ?? 4)];
+	for (const s of settings) {
+		const t0 = now$1();
+		const open = makeRoom(graph.nodes, links, {
+			...s.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));
+		});
+		rows.push(row(s.name, open.items, now$1() - t0, s.options.spacing ?? 4, s.lanes));
 	}
 	return rows;
 }
+/** The values of `maxGrowth` of the sweep of ROOM-A. */
+const GROWTH_SWEEP = [
+	0,
+	.06,
+	.09,
+	.12,
+	.15,
+	.18,
+	.21,
+	.25,
+	.3,
+	.35,
+	.5,
+	Infinity
+];
+/** This function gives the settings of ROOM-A: the area and the faults for each `maxGrowth`, at gutter 8 and spacing 4. */
+function growthSettings(values = GROWTH_SWEEP) {
+	return values.map((m) => ({
+		name: `maxGrowth ${m}`,
+		options: {
+			gutter: 8,
+			spacing: 4,
+			maxGrowth: m
+		}
+	}));
+}
+/**
+* This function gives the settings of ROOM-C: each lane order of the far view at each spacing, at gutter 8.
+* The order `shared` is the far view without lanes, as before ROOM-C.
+*/
+function laneSettings(spacings = [
+	2,
+	4,
+	6,
+	8
+], orders = LANE_ORDERS) {
+	return spacings.flatMap((spacing) => [{
+		name: `shared spacing ${spacing}`,
+		options: {
+			gutter: 8,
+			spacing
+		}
+	}, ...orders.map((lanes) => ({
+		name: `${lanes} spacing ${spacing}`,
+		options: {
+			gutter: 8,
+			spacing
+		},
+		lanes
+	}))]);
+}
+/** This function gives the settings of ROOM-D: each gutter with each number of passes, at spacing 4. */
+function passSettings(gutters = [
+	4,
+	8,
+	12,
+	16
+], passes = [1, 2]) {
+	return gutters.flatMap((gutter) => passes.map((p) => ({
+		name: `gutter ${gutter} passes ${p}`,
+		options: {
+			gutter,
+			spacing: 4,
+			passes: p
+		}
+	})));
+}
 /** This function writes the rows of `benchRoom` as a Markdown table. */
 function formatRoom(rows) {
 	return [
@@ -4478,6 +5135,118 @@ function formatRoom(rows) {
 		})
 	].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 };
+// src/bench/sections.ts
+const now = () => globalThis.performance?.now() ?? Date.now();
+/** This function gives the number of items of the first level with more than one item, or 0 for a result without levels. */
+function farItems(result) {
+	return result.levels?.find((l) => l.items.length > 1)?.items.length ?? 0;
+}
+/**
+* This function measures the router `sections` on one board with each setting. The first row is the fair baseline: the defaults, with no option.
+* The direct routes come from the hub limit 0, so `hubRoutes` counts the routes that use the hubs.
+*/
+function sweepSections(fixture, graph, settings) {
+	return [{
+		name: "defaults",
+		options: {}
+	}, ...settings].map((s) => {
+		const direct = sectionsRouter({
+			...s.options,
+			name: "direct",
+			stretch: 0,
+			stretchPad: 0
+		}).route(graph);
+		const t0 = now();
+		const result = sectionsRouter({
+			...s.options,
+			name: s.name
+		}).route(graph);
+		const ms = now() - t0;
+		const levelFaults = measureLevelFaults(result);
+		return {
+			fixture,
+			setting: s.name,
+			faults: measureRouteFaults(graph, result),
+			levelFaults: sumFaults(levelFaults),
+			overlaps: levelFaults.reduce((n, f) => n + f.overlaps, 0),
+			hubRoutes: result.routes.filter((r, i) => !sameData(r.points, direct.routes[i]?.points)).length,
+			runs: result.runs?.length ?? 0,
+			levels: result.levels?.length ?? 0,
+			farItems: farItems(result),
+			ms
+		};
+	});
+}
+/** The values of the hub limit (`stretch`) of the sweep of CUSTOM. The default is 2. */
+const STRETCH_SWEEP = [
+	1.25,
+	1.5,
+	2,
+	3,
+	Infinity
+];
+/** This function gives the settings of the sweep of the hub limit: one setting for each value of `stretch`. */
+function stretchSettings(values = STRETCH_SWEEP) {
+	return values.map((stretch) => ({
+		name: `stretch ${stretch}`,
+		options: { stretch }
+	}));
+}
+/** The values of `hubSlack` of the sweep of CUSTOM. The default is 80. */
+const SLACK_SWEEP = [
+	0,
+	40,
+	80,
+	160,
+	Infinity
+];
+/** This function gives the settings of the sweep of the slack of the hubs: one setting for each value of `hubSlack`. */
+function slackSettings(values = SLACK_SWEEP) {
+	return values.map((hubSlack) => ({
+		name: `hubSlack ${hubSlack}`,
+		options: { hubSlack }
+	}));
+}
+/** The values of the section limit (`cap`) of the sweep of CUSTOM. The default is 8. */
+const CAP_SWEEP = [
+	4,
+	6,
+	8,
+	12,
+	16
+];
+/** This function gives the settings of the sweep of the section limit: one setting for each value of `cap`. */
+function capSettings(values = CAP_SWEEP) {
+	return values.map((cap) => ({
+		name: `cap ${cap}`,
+		options: { cap }
+	}));
+}
+/**
+* This function gives one setting for each grouping rule: the router `sections` with the strategy as its option `group`.
+* The map `options` gives the options of a strategy by its name.
+*/
+function groupSettings(strategies = Object.values(groupStrategies), options = {}) {
+	return strategies.map((group) => ({
+		name: `group ${group.name}`,
+		options: {
+			group,
+			...options[group.name] ? { groupOptions: options[group.name] } : {}
+		}
+	}));
+}
+/** This function writes the rows of `sweepSections` as a Markdown table. */
+function formatSections(rows) {
+	return [
+		"| fixture | setting | through | out and back | worst detour | outside | hub routes | runs | levels | far items | level through | level out and back | level outside | level overlaps | ms |",
+		"|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|",
+		...rows.map((r) => {
+			const f = r.faults;
+			const l = r.levelFaults;
+			return `| ${r.fixture} | ${r.setting} | ${f.through} | ${f.backtrack} | ${f.worstDetour.toFixed(2)} | ${f.outside} | ${r.hubRoutes} | ${r.runs} | ${r.levels} | ${r.farItems} | ${l.through} | ${l.backtrack} | ${l.outside} | ${r.overlaps} | ${r.ms.toFixed(1)} |`;
+		})
+	].join("\n");
+}
+export { BACKTRACK_MIN, BACKTRACK_SHARE, BUILT_IN_STRATEGIES, CAP_SWEEP, CASES, CLEARANCE_CAP, CURVE_TYPES, CornerGraph, FIXTURES, GROWTH_SWEEP, Grid, LANE_ORDERS, OUTSIDE_SLACK, Obstacles, PICK, ROUTERS, SECTION_DEFAULTS, SIDE_NORMAL, SLACK_SWEEP, STEPS, STRATEGIES, STRETCH_SWEEP, TOLERANCE, WayFinder, allSections, arcCurve, asRouter, backtrackOf, benchCurveStrategies, benchCurves, benchOne, benchRoom, bendCount, boardGaps, boxExit, buildSections, byCollection, byDataGroup, capSettings, center, checkProperties, checkSections, cornersRouter, countCrossings, countOverlaps, createRegistry, cubicAt, curveOf, curveSpace, curveStrategies, defineStrategy, denseGroupsBoard, dist, distinctPoints, findStrategy, fixedPortPoint, formatCurves, formatFaults, formatRoom, formatSections, formatTable, frechet, gapLanes, getStrategy, goesOutAndBack, groupEdges, groupSettings, groupStrategies, growthSettings, hubChainBoard, inflate, inflectionCount, inflectionCurve, inflectionSector, itemSizes, keyGroups, keyedSections, laneOrder, laneRoutes, laneSettings, listStrategies, makeFixture, makeRoom, manyGroupsBoard, measureBoard, measureLevel, measureLevelFaults, measureLinks, measureQuality, measureRouteFaults, measureStability, nearestSide, nodeIndex, offsetPolyline, openGaps, orderLanes, packedGridBoard, passSettings, pathPoints, pickLevel, placePlug, plugsRouter, pointBoxDistance, pointOnSide, pointSegmentDistance, polylineLength, pullApart, quadtreeGroups, register, rng, roomDemand, roomLinks, roomStrategies, roundCorners, roundedCurve, routerStrategies, routersOf, runBenchmark, runKey, sameData, sampleCurve, sectionsRouter, segmentBounds, segmentBoxDistance, segmentHitsBox, segmentHitsRect, segmentsCross, segmentsOf, sharedRouter, sideAngle, sideToward, slackSettings, splineCurve, splitPoint, straightCurve, straightRouter, stretchSettings, sumFaults, sweepRoom, sweepSections, toSvgPath, treeDepth, trunksRouter, turns };
 
 //# sourceMappingURL=index.js.map