@mark1russell7/highways 0.9.5 → 0.9.7

package/build/index.js

@@ -351,10 +351,20 @@ function portOffset(box, port) {
 		along: port.along
 	});
 }
-/** This function throws a `RangeError` when the `along` of a plug is bad: not finite, outside 0 to 1, without `side` or with `at`. */
+/**
+* This function throws a `RangeError` when the `along` of a plug is bad: not finite, outside 0 to 1, without `side` or with `at`.
+* It also throws a `RangeError` for a bad `range` of a plug. A bad range has a value that is not finite or is outside 0 to 1, or a start after its end.
+*/
 function checkPort(node, port) {
-	if (port.along === void 0) return;
 	const at = `The plug "${port.id}" of the node "${node.id}"`;
+	if (port.range !== void 0) {
+		const r = port.range;
+		if (!Array.isArray(r) || r.length !== 2 || !r.every((v) => typeof v === "number" && Number.isFinite(v))) throw new RangeError(`${at} has the range ${JSON.stringify(r)}. It must be two finite numbers.`);
+		const [lo, hi] = r;
+		if (lo < 0 || hi > 1) throw new RangeError(`${at} has the range [${lo}, ${hi}]. It must be in the side, from 0 to 1.`);
+		if (lo > hi) throw new RangeError(`${at} has the range [${lo}, ${hi}]. Its start must not be after its end.`);
+	}
+	if (port.along === void 0) return;
 	if (typeof port.along !== "number" || !Number.isFinite(port.along) || port.along < 0 || port.along > 1) throw new RangeError(`${at} has the along value ${String(port.along)}. It must be a finite number from 0 to 1.`);
 	if (port.side === void 0) throw new RangeError(`${at} has an along value and no side. A plug with along needs a side.`);
 	if (port.at !== void 0) throw new RangeError(`${at} has an along value and an at point. Give one of the two.`);
@@ -362,7 +372,7 @@ function checkPort(node, port) {
 /**
 * This function checks the plugs of a graph, and gives each plug with `side` and `along` a fixed `at`. The plug keeps its `side`.
 * Each router calls it at the start of `route`, so all routers agree. A graph without `along` comes back as the same object.
-* It throws a `RangeError` for a bad `along` (`checkPort`).
+* It throws a `RangeError` for a bad `along` or a bad `range` (`checkPort`).
 */
 function resolvePorts(graph) {
 	let found = false;
@@ -913,6 +923,115 @@ const CASES = [
 		make: () => manyGroupsBoard()
 	}
 ];
+// src/plugs/range.ts
+/** The tolerance of the comparisons of places along a side. */
+const EPS$9 = 1e-9;
+/** This function gives the axis along a side. */
+function alongAxis(side) {
+	return side === "east" || side === "west" ? "y" : "x";
+}
+/** This function gives the port of an end, or `undefined` when the end has no port or the node has no such port. */
+function portOfEnd(node, end) {
+	return end.port === void 0 ? void 0 : node.ports?.find((p) => p.id === end.port);
+}
+/**
+* This function gives the interval of a plug with a range, on the axis along its side, or `undefined` for a port without a range.
+* The interval is the range of the port, without the corner insets of the side.
+* When the range is all in a corner inset, the interval is the range.
+*/
+function rangeInterval(box, side, port, inset = 6) {
+	const range = port?.range;
+	if (range === void 0) return void 0;
+	const along = alongAxis(side);
+	const start = along === "y" ? box.y : box.x;
+	const len = along === "y" ? box.h : box.w;
+	const m = Math.min(inset, len / 4);
+	const lo = start + range[0] * len;
+	const hi = start + range[1] * len;
+	const a = Math.max(lo, start + m);
+	const b = Math.min(hi, start + len - m);
+	return a <= b ? [a, b] : [lo, hi];
+}
+/** This function moves a point of a side into the interval of its range, on the axis along the side. A point of a port without a range stays. */
+function clampToRange(box, side, port, point, inset = 6) {
+	const r = rangeInterval(box, side, port, inset);
+	if (!r) return point;
+	const along = alongAxis(side);
+	const v = Math.max(r[0], Math.min(r[1], point[along]));
+	return along === "y" ? {
+		x: point.x,
+		y: v
+	} : {
+		x: v,
+		y: point.y
+	};
+}
+/**
+* This function places `ideal.length` plugs of one side in their given order. The plug `i` stays in the interval from `lo[i]` to `hi[i]`.
+* Two neighbours are at least `gap` apart. When the intervals are too short for the gap, the gap shrinks evenly to the largest gap that they let.
+* The sum of the squares of the moves from the ideal places is the least.
+*
+* When the order cannot keep each plug in its interval, the plugs take the order of their ideal places in their intervals. Thus the intervals win over the order.
+* The result is in the order of `ideal`.
+*/
+function placeInIntervals(ideal, lo, hi, gap) {
+	const k = ideal.length;
+	if (k === 0) return [];
+	let order = ideal.map((_, i) => i);
+	let most = -Infinity;
+	let broken = false;
+	for (const i of order) {
+		if (hi[i] < most - EPS$9) broken = true;
+		most = Math.max(most, lo[i]);
+	}
+	if (broken) {
+		const c = order.map((i) => Math.max(lo[i], Math.min(hi[i], ideal[i])));
+		order = [...order].sort((a, b) => c[a] - c[b] || a - b);
+	}
+	let s = Math.max(0, gap);
+	for (let i = 1; i < k; i++) {
+		const hiI = hi[order[i]];
+		for (let j = 0; j < i; j++) s = Math.min(s, (hiI - lo[order[j]]) / (i - j));
+	}
+	s = Math.max(0, s);
+	const lower = new Array(k);
+	const upper = new Array(k);
+	let run = -Infinity;
+	for (let i = 0; i < k; i++) lower[i] = run = Math.max(run, lo[order[i]] - i * s);
+	run = Infinity;
+	for (let i = k - 1; i >= 0; i--) upper[i] = run = Math.min(run, hi[order[i]] - i * s);
+	const sum = [];
+	const size = [];
+	const blockLo = [];
+	const blockHi = [];
+	const value = [];
+	const clamp = (v, a, b) => Math.max(a, Math.min(b, v));
+	for (let i = 0; i < k; i++) {
+		sum.push(ideal[order[i]] - i * s);
+		size.push(1);
+		blockLo.push(lower[i]);
+		blockHi.push(upper[i]);
+		value.push(clamp(sum[sum.length - 1], lower[i], upper[i]));
+		while (value.length > 1 && value[value.length - 2] > value[value.length - 1]) {
+			const t = value.length - 1;
+			sum[t - 1] += sum[t];
+			size[t - 1] += size[t];
+			blockLo[t - 1] = blockLo[t];
+			value[t - 1] = clamp(sum[t - 1] / size[t - 1], blockLo[t - 1], blockHi[t - 1]);
+			sum.pop();
+			size.pop();
+			blockLo.pop();
+			blockHi.pop();
+			value.pop();
+		}
+	}
+	const out = new Array(k);
+	let i = 0;
+	value.forEach((v, b) => {
+		for (let j = 0; j < size[b]; j++, i++) out[order[i]] = v + i * s;
+	});
+	return out;
+}
 // src/plugs.ts
 /** The outward normal of each side, in a frame with the y axis down. */
 const SIDE_NORMAL = {
@@ -983,7 +1102,7 @@ function pointOnSide(box, side, toward, inset = 6) {
 }
 /**
 * 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`.
+* The router places a free plug on the side that faces `toward`. A free plug of a port with a `range` stays in that range (`clampToRange`).
 */
 function placePlug(node, end, toward) {
 	const fixed = fixedPortPoint(node, end);
@@ -993,8 +1112,9 @@ function placePlug(node, end, toward) {
 		normal: SIDE_NORMAL[port?.side ?? nearestSide(node.box, fixed)]
 	};
 	const side = port?.side ?? sideToward(node.box, toward);
+	const point = pointOnSide(node.box, side, toward);
 	return {
-		point: pointOnSide(node.box, side, toward),
+		point: port?.range === void 0 ? point : clampToRange(node.box, side, port, point),
 		normal: SIDE_NORMAL[side]
 	};
 }
@@ -4953,6 +5073,7 @@ function isotonic(v) {
 * This function moves the free plugs of each side of each node, so that two of them are at least `gap` apart (`justifyPlugs`).
 * The plugs keep their order on the side. Two plugs at one place take the order of their other ends. A fixed plug does not move.
 * A plug stays `inset` from the corners of its side, or a quarter of the side when the side is short.
+* A plug of a port with a `range` stays in its range (PORT-RANGE), and the plugs keep their order and the gap (`placeInIntervals`).
 */
 function spacePlugs(ends, gap, inset = 6) {
 	const sides = /* @__PURE__ */ new Map();
@@ -4985,18 +5106,21 @@ function spacePlugs(ends, gap, inset = 6) {
 			side.items.push([
 				i,
 				k,
-				other.point
+				other.point,
+				portOfEnd(node, end)
 			]);
 		}
 	});
 	for (const { node, normal, items } of sides.values()) {
-		if (items.length < 2) continue;
+		const ranged = items.some((x) => x[3]?.range !== void 0);
+		if (items.length < 2 && !ranged) continue;
 		const along = normal.x !== 0 ? "y" : "x";
 		const b = node.box;
 		const start = along === "y" ? b.y : b.x;
 		const len = along === "y" ? b.h : b.w;
 		const m = Math.min(inset, len / 4);
-		const placed = justifyPlugs(items.map(([i, k]) => ends[i][k].point[along]), start + m, start + len - m, gap, (j) => items[j][2][along]);
+		const ideal = items.map(([i, k]) => ends[i][k].point[along]);
+		const placed = ranged ? spaceInRanges(b, normal, items, ideal, start + m, start + len - m, gap, inset) : justifyPlugs(ideal, start + m, start + len - m, gap, (j) => items[j][2][along]);
 		items.forEach(([i, k], j) => {
 			const old = ends[i][k];
 			ends[i][k] = {
@@ -5013,6 +5137,28 @@ function spacePlugs(ends, gap, inset = 6) {
 	}
 }
 /**
+* This function places the free plugs of one side with ranges (PORT-RANGE). The order is the order of `justifyPlugs`.
+* Each plug stays in the interval of its range, or in the room of the side without a range.
+*/
+function spaceInRanges(box, normal, items, ideal, lo, hi, gap, inset) {
+	const side = sideOfNormal(normal);
+	const along = alongAxis(side);
+	const order = ideal.map((_, i) => i).sort((a, b) => ideal[a] - ideal[b] || items[a][2][along] - items[b][2][along] || a - b);
+	const span = order.map((j) => rangeInterval(box, side, items[j][3], inset) ?? [lo, hi]);
+	const at = placeInIntervals(order.map((j) => ideal[j]), span.map((r) => r[0]), span.map((r) => r[1]), gap);
+	const out = new Array(ideal.length);
+	order.forEach((j, i) => {
+		out[j] = at[i];
+	});
+	return out;
+}
+/** This function gives the side of an outward normal. */
+function sideOfNormal(n) {
+	if (n.x > 0) return "east";
+	if (n.x < 0) return "west";
+	return n.y > 0 ? "south" : "north";
+}
+/**
 * This function gives the plugs of the plug strategy `justify` (WILD-002): the plugs of `facing`, then the gaps of `spacePlugs`.
 * The router `corners` with the option `plugGap` gives the same plugs.
 */
@@ -5048,7 +5194,8 @@ function justifyEnds(input, options = {}) {
 /** This function gives the free side of an end, or `undefined` when the plug of the end is fixed. */
 function freeSide(node, end, toward, inset) {
 	if (fixedPortPoint(node, end)) return void 0;
-	const side = (end.port === void 0 ? void 0 : node.ports?.find((p) => p.id === end.port))?.side ?? sideToward(node.box, toward);
+	const port = end.port === void 0 ? void 0 : node.ports?.find((p) => p.id === end.port);
+	const side = port?.side ?? sideToward(node.box, toward);
 	const b = node.box;
 	const along = side === "east" || side === "west" ? "y" : "x";
 	const start = along === "y" ? b.y : b.x;
@@ -5056,6 +5203,23 @@ function freeSide(node, end, toward, inset) {
 	const m = Math.min(inset, len / 4);
 	const at = side === "east" ? b.x + b.w : side === "west" ? b.x : side === "south" ? b.y + b.h : b.y;
 	const point = pointOnSide(b, side, toward, inset);
+	const range = port?.range === void 0 ? void 0 : rangeInterval(b, side, port, inset);
+	if (range) {
+		const facing = clampToRange(b, side, port, point, inset);
+		return {
+			node,
+			side,
+			normal: SIDE_NORMAL[side],
+			along,
+			at,
+			lo: range[0],
+			hi: range[1],
+			facing: {
+				point: facing,
+				normal: SIDE_NORMAL[side]
+			}
+		};
+	}
 	return {
 		node,
 		side,
@@ -5215,7 +5379,7 @@ function sideEnds(input, options = {}) {
 // src/routers/gutter.ts
 /** The default cost of one bend of the gutter mode. */
 const GUTTER_BEND_COST = 16;
-const EPS$7 = 1e-6;
+const EPS$8 = 1e-6;
 /** The directions of a step: east, south, west and north, with the y axis down. */
 const DX = [
 	1,
@@ -5239,7 +5403,7 @@ const DY = [
 */
 function gutterRoutes(frame, nodes, edges, options = {}) {
 	const bend = options.bendCost ?? 16;
-	const boxes = nodes.map((n) => n.box).filter((b) => b.w > EPS$7 && b.h > EPS$7);
+	const boxes = nodes.map((n) => n.box).filter((b) => b.w > EPS$8 && b.h > EPS$8);
 	const entries = edges.map(entriesOf);
 	const xs = /* @__PURE__ */ new Set();
 	const ys = /* @__PURE__ */ new Set();
@@ -5257,7 +5421,7 @@ function gutterRoutes(frame, nodes, edges, options = {}) {
 		const cuts = [lo, lo + size];
 		for (const b of boxes) for (const v of key === "x" ? [b.x, b.x + b.w] : [b.y, b.y + b.h]) if (v > lo && v < lo + size) cuts.push(v);
 		cuts.sort((a, b) => a - b);
-		for (let i = 1; i < cuts.length; i++) if (cuts[i] - cuts[i - 1] > EPS$7) lines.add((cuts[i] + cuts[i - 1]) / 2);
+		for (let i = 1; i < cuts.length; i++) if (cuts[i] - cuts[i - 1] > EPS$8) lines.add((cuts[i] + cuts[i - 1]) / 2);
 	}
 	edges.forEach((e, i) => {
 		for (const { point, normal } of [{
@@ -5320,19 +5484,19 @@ function stubOnly(e, boxes) {
 	const n = e.plug.normal;
 	let q;
 	if (n.x !== 0) {
-		if (!(p.y > b.y + EPS$7 && p.y < b.y + b.h - EPS$7)) return void 0;
+		if (!(p.y > b.y + EPS$8 && p.y < b.y + b.h - EPS$8)) return void 0;
 		q = {
 			x: n.x > 0 ? b.x + b.w : b.x,
 			y: p.y
 		};
-		if ((q.x - p.x) * n.x > EPS$7) return void 0;
+		if ((q.x - p.x) * n.x > EPS$8) return void 0;
 	} else {
-		if (!(p.x > b.x + EPS$7 && p.x < b.x + b.w - EPS$7)) return void 0;
+		if (!(p.x > b.x + EPS$8 && p.x < b.x + b.w - EPS$8)) return void 0;
 		q = {
 			x: p.x,
 			y: n.y > 0 ? b.y + b.h : b.y
 		};
-		if ((q.y - p.y) * n.y > EPS$7) return void 0;
+		if ((q.y - p.y) * n.y > EPS$8) return void 0;
 	}
 	for (const o of boxes) if (o !== b && blocks(p, q, o)) return void 0;
 	return [p, q];
@@ -5340,11 +5504,11 @@ function stubOnly(e, boxes) {
 /** This function tells if the axis-parallel segment `ab` meets the closed box `o` along a part longer than a tiny length. A segment along a side meets the box. */
 function blocks(a, b, o) {
 	if (a.y === b.y) {
-		if (a.y < o.y - EPS$7 || a.y > o.y + o.h + EPS$7) return false;
-		return Math.min(Math.max(a.x, b.x), o.x + o.w) - Math.max(Math.min(a.x, b.x), o.x) > EPS$7;
+		if (a.y < o.y - EPS$8 || a.y > o.y + o.h + EPS$8) return false;
+		return Math.min(Math.max(a.x, b.x), o.x + o.w) - Math.max(Math.min(a.x, b.x), o.x) > EPS$8;
 	}
-	if (a.x < o.x - EPS$7 || a.x > o.x + o.w + EPS$7) return false;
-	return Math.min(Math.max(a.y, b.y), o.y + o.h) - Math.max(Math.min(a.y, b.y), o.y) > EPS$7;
+	if (a.x < o.x - EPS$8 || a.x > o.x + o.w + EPS$8) return false;
+	return Math.min(Math.max(a.y, b.y), o.y + o.h) - Math.max(Math.min(a.y, b.y), o.y) > EPS$8;
 }
 /** This function gives the direction index of a unit normal: 0 east, 1 south, 2 west, 3 north. */
 function dirOf(n) {
@@ -5363,12 +5527,12 @@ var Grid$1 = class {
 		this.#free = new Uint8Array(xs.length * ys.length);
 		for (let i = 0; i < ys.length; i++) {
 			const y = ys[i];
-			if (y <= frame.y + EPS$7 || y >= frame.y + frame.h - EPS$7) continue;
+			if (y <= frame.y + EPS$8 || y >= frame.y + frame.h - EPS$8) continue;
 			for (let j = 0; j < xs.length; j++) {
 				const x = xs[j];
-				if (x <= frame.x + EPS$7 || x >= frame.x + frame.w - EPS$7) continue;
+				if (x <= frame.x + EPS$8 || x >= frame.x + frame.w - EPS$8) continue;
 				let free = true;
-				for (const b of boxes) if (x >= b.x - EPS$7 && x <= b.x + b.w + EPS$7 && y >= b.y - EPS$7 && y <= b.y + b.h + EPS$7) {
+				for (const b of boxes) if (x >= b.x - EPS$8 && x <= b.x + b.w + EPS$8 && y >= b.y - EPS$8 && y <= b.y + b.h + EPS$8) {
 					free = false;
 					break;
 				}
@@ -5405,11 +5569,11 @@ var Grid$1 = class {
 		const sign = d < 2 ? 1 : -1;
 		let k = -1;
 		if (sign > 0) {
-			for (let m = 0; m < list.length; m++) if (list[m] > v + EPS$7) {
+			for (let m = 0; m < list.length; m++) if (list[m] > v + EPS$8) {
 				k = m;
 				break;
 			}
-		} else for (let m = list.length - 1; m >= 0; m--) if (list[m] < v - EPS$7) {
+		} else for (let m = list.length - 1; m >= 0; m--) if (list[m] < v - EPS$8) {
 			k = m;
 			break;
 		}
@@ -5608,7 +5772,7 @@ function lanes(frame, boxes, edges, entries, routes, laneGap) {
 		const b = legs[j];
 		if (a.route === b.route || a.horizontal !== b.horizontal) continue;
 		if (Math.min(a.s1, b.s1) - Math.max(a.s0, b.s0) <= -laneGap) continue;
-		if (a.across < b.lo - EPS$7 || a.across > b.hi + EPS$7 || b.across < a.lo - EPS$7 || b.across > a.hi + EPS$7) continue;
+		if (a.across < b.lo - EPS$8 || a.across > b.hi + EPS$8 || b.across < a.lo - EPS$8 || b.across > a.hi + EPS$8) continue;
 		parent[root(i)] = root(j);
 	}
 	const groups = /* @__PURE__ */ new Map();
@@ -5648,9 +5812,9 @@ function free(frame, boxes, horizontal, across, s0, s1) {
 			b.x,
 			b.w
 		];
-		if (Math.min(s1, bs + bl) - Math.max(s0, bs) <= EPS$7) continue;
-		if (cs + cl <= across + EPS$7) lo = Math.max(lo, cs + cl);
-		if (cs >= across - EPS$7) hi = Math.min(hi, cs);
+		if (Math.min(s1, bs + bl) - Math.max(s0, bs) <= EPS$8) continue;
+		if (cs + cl <= across + EPS$8) lo = Math.max(lo, cs + cl);
+		if (cs >= across - EPS$8) hi = Math.min(hi, cs);
 	}
 	return [lo, hi];
 }
@@ -5661,8 +5825,8 @@ function want(a, b) {
 		if (inner(sb, sa)) return -tb;
 		return ta === tb ? 0 : Math.sign(ta - tb);
 	};
-	const left = side(a.s0, b.s0, a.t0, b.t0, (x, y) => x > y + EPS$7);
-	const right = side(a.s1, b.s1, a.t1, b.t1, (x, y) => x < y - EPS$7);
+	const left = side(a.s0, b.s0, a.t0, b.t0, (x, y) => x > y + EPS$8);
+	const right = side(a.s1, b.s1, a.t1, b.t1, (x, y) => x < y - EPS$8);
 	if (left !== 0 && right !== 0 && left !== right) return left;
 	return left || right;
 }
@@ -5680,7 +5844,7 @@ function place(group, laneGap) {
 		const a = group[i];
 		const b = group[j];
 		if (a.pinned && b.pinned) {
-			if (Math.abs(a.across - b.across) <= EPS$7) continue;
+			if (Math.abs(a.across - b.across) <= EPS$8) continue;
 			const [x, y] = a.across < b.across ? [i, j] : [j, i];
 			hard[x].push(y);
 			hardIn[y]++;
@@ -5698,7 +5862,7 @@ function place(group, laneGap) {
 		let best = -1;
 		for (let i = 0; i < n; i++) {
 			if (done[i] || hardIn[i] > 0) continue;
-			if (best < 0 || softIn[i] < softIn[best] || softIn[i] === softIn[best] && group[i].across < group[best].across - EPS$7) best = i;
+			if (best < 0 || softIn[i] < softIn[best] || softIn[i] === softIn[best] && group[i].across < group[best].across - EPS$8) best = i;
 		}
 		done[best] = true;
 		order.push(best);
@@ -5711,7 +5875,7 @@ function place(group, laneGap) {
 		let to = k + 1;
 		for (let m = k + 1; m < order.length; m++) {
 			const b = group[order[m]];
-			if (b.pinned && Math.abs(b.across - a.across) <= EPS$7) order.splice(to++, 0, ...order.splice(m, 1));
+			if (b.pinned && Math.abs(b.across - a.across) <= EPS$8) order.splice(to++, 0, ...order.splice(m, 1));
 		}
 		k = to - 1;
 	}
@@ -5731,7 +5895,7 @@ function place(group, laneGap) {
 			const width = (run.length - 1) * s;
 			const mean = run.reduce((t, r) => t + group[r].across, 0) / run.length;
 			const first = Math.min(Math.max(mean - width / 2, lo + s), hi - s - width);
-			run.forEach((r, m) => at[r] = room > EPS$7 && s > 0 ? first + m * s : group[r].across);
+			run.forEach((r, m) => at[r] = room > EPS$8 && s > 0 ? first + m * s : group[r].across);
 		}
 		if (k < n) at[i] = group[i].across;
 		start = k + 1;
@@ -5741,7 +5905,7 @@ function place(group, laneGap) {
 }
 // src/routers/frames.ts
 /** The tiny gap between the bounds and the band of a wall, so that a way along the bounds stays clear of the wall. */
-const EPS$6 = 1e-6;
+const EPS$7 = 1e-6;
 /**
 * This function gives the inner routes of the inner edges (`splitFrames`). Each route stays in the bounds of its frame:
 * the box of the frame, smaller by `frameInset`. It goes around the other nodes of the frame.
@@ -5866,7 +6030,7 @@ function makeRoom$1(f, chain, children, byId, inset, options) {
 	const margin = options.margin ?? 5;
 	const bounds = shrink(f.box, inset);
 	const nodes = roomNodes(f, chain, children, byId, bounds, options);
-	const w = shrink(bounds, -(margin / 2 + EPS$6));
+	const w = shrink(bounds, -(margin / 2 + EPS$7));
 	const t = 2 * margin + 1;
 	const walls = [
 		{
@@ -6225,7 +6389,7 @@ const LEVEL_LINK_DEFAULTS = Object.freeze({
 	plugInset: 6,
 	throughCost: 8
 });
-const EPS$5 = 1e-6;
+const EPS$6 = 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.
@@ -6240,15 +6404,15 @@ function tidy$1(p) {
 function tidyPoints(p) {
 	const out = [];
 	for (const q of p) {
-		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$5) continue;
+		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$6) 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$5 * (1 + dist(a, b) * dist(b, q))) break;
+			if (Math.abs(cross) > EPS$6 * (1 + dist(a, b) * dist(b, q))) break;
 			out.pop();
 		}
-		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$5) continue;
+		if (out.length > 0 && dist(q, out[out.length - 1]) <= EPS$6) continue;
 		out.push(q);
 	}
 	return out;
@@ -6621,7 +6785,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$5);
+	return out.filter(([a, b]) => b - a > EPS$6);
 }
 /**
 * This function gives the shortest way between the free plugs of the two nodes, or `undefined` when the second corner graph has none.
@@ -6753,7 +6917,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$5 ? "x" : Math.abs(end.x - before.x) < EPS$5 ? "y" : void 0;
+		axis = Math.abs(end.y - before.y) < EPS$6 ? "x" : Math.abs(end.x - before.x) < EPS$6 ? "y" : void 0;
 		i = step.j;
 	}
 	return out;
@@ -6763,7 +6927,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$5 || Math.abs(a.y - b.y) < EPS$5) return obstacles.clear(a, b, pad) ? [b] : void 0;
+	if (Math.abs(a.x - b.x) < EPS$6 || Math.abs(a.y - b.y) < EPS$6) return obstacles.clear(a, b, pad) ? [b] : void 0;
 	const options = [{
 		c: {
 			x: b.x,
@@ -9421,7 +9585,7 @@ const ADAM_SCHEMA = {
 /** The moment factors of Adam (Kingma and Ba 2015), as the record gives them. */
 const BETA1 = .9;
 const BETA2 = .999;
-const EPS$4 = 1e-8;
+const EPS$5 = 1e-8;
 /** The weight of the term that holds a leg near its first place. */
 const HOLD = .05;
 /** This function gives the point of the segment `ab` nearest to `p`. */
@@ -9642,7 +9806,7 @@ function adamRoutes(input, result, options = {}) {
 			m2[i] = BETA2 * m2[i] + .0010000000000000009 * g * g;
 			const mh = m1[i] / (1 - b1);
 			const vh = m2[i] / (1 - b2);
-			shift[i] = Math.max(-2 * c, Math.min(2 * c, shift[i] - eta * mh / (Math.sqrt(vh) + EPS$4)));
+			shift[i] = Math.max(-2 * c, Math.min(2 * c, shift[i] - eta * mh / (Math.sqrt(vh) + EPS$5)));
 		}
 	}
 	const moved = new Set(legs.map((l) => l.route));
@@ -10704,7 +10868,7 @@ const LANE_TRACKS = [
 	"left-edge",
 	"free"
 ];
-const EPS$3 = 1e-6;
+const EPS$4 = 1e-6;
 const ROUNDS$1 = 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.
@@ -10729,7 +10893,7 @@ function laneGaps(items, links, options) {
 	})));
 	const counts = [];
 	for (const g of boardGaps(items, options.snap)) {
-		if (g.width <= EPS$3) continue;
+		if (g.width <= EPS$4) continue;
 		const across = g.axis;
 		const along = g.axis === "x" ? "y" : "x";
 		const lo = g.at - g.width;
@@ -10740,8 +10904,8 @@ function laneGaps(items, links, options) {
 			for (let i = 2; i <= p.length - 2; i++) {
 				const a = p[i - 1];
 				const b = p[i];
-				if (Math.abs(a[across] - b[across]) > EPS$3 || a[across] <= lo + EPS$3 || a[across] >= hi - EPS$3) continue;
-				if (Math.abs(a[along] - b[along]) <= EPS$3) continue;
+				if (Math.abs(a[across] - b[across]) > EPS$4 || a[across] <= lo + EPS$4 || a[across] >= hi - EPS$4) continue;
+				if (Math.abs(a[along] - b[along]) <= EPS$4) continue;
 				const side = (q, r) => Math.sign(r[across] - q[across]);
 				pieces.push({
 					link: li,
@@ -10817,7 +10981,7 @@ function leftEdgeLanes(list, constrained) {
 		const now = [];
 		let end = -Infinity;
 		for (const i of byStart) {
-			if (lane[i] >= 0 || wait[i] > 0 || list[i].lo < end - EPS$3) continue;
+			if (lane[i] >= 0 || wait[i] > 0 || list[i].lo < end - EPS$4) continue;
 			now.push(i);
 			end = list[i].hi;
 		}
@@ -10840,15 +11004,15 @@ function density(list) {
 	}
 	return most;
 }
-const overlaps = (P, Q) => Math.min(P.hi, Q.hi) - Math.max(P.lo, Q.lo) > EPS$3;
+const overlaps = (P, Q) => Math.min(P.hi, Q.hi) - Math.max(P.lo, Q.lo) > EPS$4;
 /**
 * This function counts the crossings when the piece `P` is on the near side of the piece `Q`.
 * A turn of `P` to the far side crosses `Q` when it is inside the span of `Q`. A turn of `Q` to the near side crosses `P` in the same way.
 */
 function cost$1(P, Q) {
 	let c = 0;
-	for (const [y, s] of P.turns) if (s > 0 && y > Q.lo + EPS$3 && y < Q.hi - EPS$3) c++;
-	for (const [y, s] of Q.turns) if (s < 0 && y > P.lo + EPS$3 && y < P.hi - EPS$3) c++;
+	for (const [y, s] of P.turns) if (s > 0 && y > Q.lo + EPS$4 && y < Q.hi - EPS$4) c++;
+	for (const [y, s] of Q.turns) if (s < 0 && y > P.lo + EPS$4 && y < P.hi - EPS$4) c++;
 	return c;
 }
 /** This function gives the pieces of one gap in lane order, from the near side to the far side. */
@@ -11052,17 +11216,10 @@ function facingEnds(input) {
 	}
 	return out;
 }
-// src/plugs/spread/index.ts
+// src/plugs/walls.ts
 /**
-* The plug strategy `spread` (PLUG-SPREAD): the free plugs of each wall share the room of that wall with a minimum gap.
-* The order on the wall keeps the order of the far ends, so two routes do not cross at the wall. No plug drops.
+* The walls of the plug strategies `spread`, `leaders` and `assign`: one side of one node, its room, and the order of its far ends.
 */
-/** The defaults of the plug strategy `spread`. */
-const SPREAD_DEFAULTS = Object.freeze({
-	plugGap: 8,
-	inset: 6,
-	rounds: 2
-});
 /** This function gives the axis along a side. */
 function alongOf(side) {
 	return side === "east" || side === "west" ? "y" : "x";
@@ -11111,6 +11268,17 @@ function keyOf$1(box, side, far) {
 	if (out >= 0) return p;
 	return along >= 0 ? 2 - p : -2 - p;
 }
+// src/plugs/spread/index.ts
+/**
+* The plug strategy `spread` (PLUG-SPREAD): the free plugs of each wall share the room of that wall with a minimum gap.
+* The order on the wall keeps the order of the far ends, so two routes do not cross at the wall. No plug drops.
+*/
+/** The defaults of the plug strategy `spread`. */
+const SPREAD_DEFAULTS = Object.freeze({
+	plugGap: 8,
+	inset: 6,
+	rounds: 2
+});
 /**
 * This function gives the sort key of a far point for a po-leader (EDA-041): its place on the axis along the wall.
 * A far point behind the wall gets the key of `keyOf` with a large shift, so it goes to an end of the wall.
@@ -11156,6 +11324,7 @@ function placeWall(slots, fixed, lo, hi, gap, idealOf = (s) => s.ideal) {
 		part = Math.max(part, p);
 		parts[part].push(s);
 	}
+	const ranged = slots.some((s) => s.range !== void 0);
 	parts.forEach((list, p) => {
 		if (list.length === 0) return;
 		const a = ends[p];
@@ -11166,6 +11335,21 @@ function placeWall(slots, fixed, lo, hi, gap, idealOf = (s) => s.ideal) {
 		const s = steps > 0 ? Math.max(0, Math.min(gap, (b - a) / steps)) : gap;
 		const lower = a + fa * s;
 		const upper = Math.max(lower, b - fb * s);
+		if (ranged) {
+			const span = list.map((x) => {
+				if (!x.range) return [lower, upper];
+				const lo = Math.max(lower, x.range[0]);
+				const hi = Math.min(upper, x.range[1]);
+				if (lo <= hi) return [lo, hi];
+				const v = x.range[1] < lower ? lower : upper;
+				return [v, v];
+			});
+			const at = placeInIntervals(list.map((x) => idealOf(x)), span.map((r) => r[0]), span.map((r) => r[1]), s);
+			list.forEach((x, i) => {
+				x.at = at[i];
+			});
+			return;
+		}
 		const at = placeInOrder(list.map((x) => idealOf(x)), lower, upper, s);
 		list.forEach((x, i) => {
 			x.at = at[i];
@@ -11226,12 +11410,14 @@ function spreadWith(input, options = {}, leader) {
 		if (slots.has(key)) return key;
 		const side = port?.side ?? sideToward(node.box, toward);
 		const ideal = placePlug(node, end, toward).point[alongOf(side)];
+		const range = rangeInterval(node.box, side, port, inset);
 		const slot = {
 			node,
 			side,
 			ideal,
 			rank: [port ? node.ports.indexOf(port) : -1, slots.size],
-			at: ideal
+			at: ideal,
+			...range ? { range } : {}
 		};
 		slots.set(key, slot);
 		wallOf(node, side).slots.push(slot);
@@ -11280,6 +11466,467 @@ function spreadWith(input, options = {}, leader) {
 		target: resolve(x.target)
 	}));
 }
+// src/plugs/assign/index.ts
+/**
+* The plug strategy `assign` (PLUG-ASSIGN): the plugs of each wall go to the intervals of their ends, with a least gap.
+* An interval is the range of the port (PORT-RANGE), or the room of the wall. The assignment is exact for the count of the ends in their intervals.
+*/
+/** The defaults of the plug strategy `assign`. */
+const ASSIGN_DEFAULTS = Object.freeze({
+	plugGap: 8,
+	inset: 6
+});
+/** The tolerance of the comparisons of places along a wall. */
+const EPS$3 = 1e-9;
+/** This function gives the index of the first value of the sorted list `list` that is `v` or more. */
+function lowerBound(list, v) {
+	let a = 0;
+	let b = list.length;
+	while (a < b) {
+		const mid = a + b >> 1;
+		if (list[mid] < v) a = mid + 1;
+		else b = mid;
+	}
+	return a;
+}
+/**
+* This function moves the place `p` out of the zones of the fixed plugs: the open intervals of the width `2·s` around each fixed plug.
+* The list `fixed` is sorted. The place only moves up.
+*/
+function pushOut(p, fixed, s) {
+	for (const f of fixed) if (p > f - s + EPS$3 && p < f + s - EPS$3) p = f + s;
+	return p;
+}
+/**
+* This function gives the gap of a wall with `n` plugs: `gap`, or the largest gap that lets all the plugs go in the room.
+* The plugs keep the gap to the fixed plugs too.
+*/
+function wallGap(n, fixed, lo, hi, gap) {
+	if (n <= 1) return gap;
+	if (fixed.length === 0) return Math.max(0, Math.min(gap, (hi - lo) / (n - 1)));
+	const fits = (s) => {
+		let p = lo;
+		for (let c = 0; c < n; c++) {
+			p = pushOut(p, fixed, s);
+			if (p > hi + EPS$3) return false;
+			p += s;
+		}
+		return true;
+	};
+	if (fits(gap)) return gap;
+	let a = 0;
+	let b = gap;
+	for (let i = 0; i < 60; i++) {
+		const mid = (a + b) / 2;
+		if (fits(mid)) a = mid;
+		else b = mid;
+	}
+	return Math.max(0, a - 1e-7);
+}
+/**
+* This function gives the plan of the ends of one wall in the order of their keys, with no crossing at the wall.
+* The plan has the most ends in their intervals that this order lets. The answer is exact for this order: a table of the least last place
+* for each count of ends in their intervals.
+*/
+function keyOrderPlan(order, win, fixed, lo, hi, s) {
+	const n = order.length;
+	const nf = fixed.length;
+	const at = (i, j, c) => (i * (nf + 1) + j) * (n + 1) + c;
+	const best = new Float64Array((n + 1) * (nf + 1) * (n + 1)).fill(Infinity);
+	const step = new Int8Array(best.length);
+	best[at(0, 0, 0)] = -Infinity;
+	const relax = (k, v, how) => {
+		if (v < best[k]) {
+			best[k] = v;
+			step[k] = how;
+		}
+	};
+	for (let i = 0; i <= n; i++) for (let j = 0; j <= nf; j++) for (let c = 0; c <= i; c++) {
+		const v = best[at(i, j, c)];
+		if (v === Infinity) continue;
+		const next = v === -Infinity ? -Infinity : v + s;
+		if (j < nf && (v === -Infinity || v + s <= fixed[j] + EPS$3)) relax(at(i, j + 1, c), fixed[j], 0);
+		if (i < n) {
+			const w = win[order[i]];
+			if (w) {
+				const p = Math.max(w[0], next);
+				if (p <= w[1] + EPS$3) relax(at(i + 1, j, c + 1), p, 1);
+			}
+			const q = Math.max(lo, next);
+			if (q <= hi + EPS$3) relax(at(i + 1, j, c), q, 2);
+		}
+	}
+	let c = n;
+	while (c >= 0 && best[at(n, nf, c)] === Infinity) c--;
+	if (c < 0) return void 0;
+	const items = [];
+	let i = n;
+	let j = nf;
+	while (i > 0 || j > 0) {
+		const k = at(i, j, c);
+		const how = step[k];
+		if (how === 0) items.push({
+			end: -1,
+			anchored: true,
+			at: fixed[--j]
+		});
+		else {
+			items.push({
+				end: order[--i],
+				anchored: how === 1,
+				at: best[k]
+			});
+			if (how === 1) c--;
+		}
+	}
+	return items.reverse();
+}
+/**
+* This function gives the most ends of a wall that can have their plug in their interval, in any order. It also gives one plan with that count.
+* Each end without its plug in its interval still gets a plug in the room of the wall: a free plug.
+*
+* The plan comes from two facts. First, a plan can move each plug down until it touches its interval, the room, a fixed zone or the plug before it.
+* Thus each plug is at a start place plus a whole number of gaps. Second, a swap of two plugs makes the last plug of the plan the end with the latest interval end.
+* Then the ends with an interval start up to its place are before it, and the others after it. This split gives a table over the ends and two places (the recursion `count`).
+* The free plugs have the room as interval and the latest end. Thus they split the wall into parts, and a second table chains the parts.
+*/
+function bestPlan(order, win, ideals, fixed, lo, hi, s) {
+	const n = order.length;
+	const jobs = order.filter((e) => win[e] !== void 0).sort((a, b) => win[a][1] - win[b][1] || win[a][0] - win[b][0] || a - b);
+	const r = jobs.length;
+	const allowed = (t) => t >= lo - EPS$3 && t <= hi + EPS$3 && fixed.every((f) => t <= f - s + EPS$3 || t >= f + s - EPS$3);
+	const starts = [
+		lo,
+		...jobs.map((e) => win[e][0]),
+		...fixed.map((f) => f + s)
+	];
+	const raw = [];
+	for (const b of starts) for (let q = 0; q <= n; q++) {
+		const t = b + q * s;
+		if (t > hi + EPS$3) break;
+		if (allowed(t)) raw.push(t);
+		if (s === 0) break;
+	}
+	raw.sort((a, b) => a - b);
+	const T = [];
+	for (const t of raw) if (T.length === 0 || t - T[T.length - 1] > EPS$3) T.push(t);
+	const m = T.length;
+	const id = (k, ui, vi) => (k * (m + 2) + ui + 1) * (m + 2) + vi + 1;
+	const memo = /* @__PURE__ */ new Map();
+	const pick = /* @__PURE__ */ new Map();
+	const count = (k, ui, vi) => {
+		if (k === 0) return 0;
+		const key = id(k, ui, vi);
+		const got = memo.get(key);
+		if (got !== void 0) return got;
+		const [a, b] = win[jobs[k - 1]];
+		const u = ui < 0 ? -Infinity : T[ui];
+		const v = vi >= m ? Infinity : T[vi];
+		let most = count(k - 1, ui, vi);
+		let choice = -1;
+		if (a > u + EPS$3 && a <= v + EPS$3) {
+			const from = Math.max(a, ui < 0 ? lo : u + s);
+			const to = Math.min(b, vi >= m ? hi : v - s);
+			for (let ti = lowerBound(T, from - EPS$3); ti < m && T[ti] <= to + EPS$3; ti++) {
+				const got2 = 1 + count(k - 1, ui, ti) + count(k - 1, ti, vi);
+				if (got2 > most) {
+					most = got2;
+					choice = ti;
+				}
+			}
+		}
+		memo.set(key, most);
+		if (choice >= 0) pick.set(key, choice);
+		return most;
+	};
+	let total = r === n && count(r, -1, m) === n ? n : -1;
+	let bestQ = 0;
+	let bestI = -1;
+	const chain = [];
+	const back = [];
+	for (let q = 1; q <= n; q++) {
+		const cur = new Float64Array(m).fill(-Infinity);
+		const from = new Int32Array(m).fill(-1);
+		for (let i = 0; i < m; i++) {
+			if (q === 1) {
+				cur[i] = count(r, -1, i);
+				continue;
+			}
+			const prev = chain[q - 2];
+			for (let h = 0; h < i; h++) {
+				if (prev[h] === -Infinity || T[i] - T[h] < s - EPS$3) continue;
+				const v = prev[h] + count(r, h, i);
+				if (v > cur[i]) {
+					cur[i] = v;
+					from[i] = h;
+				}
+			}
+		}
+		chain.push(cur);
+		back.push(from);
+		for (let i = 0; i < m; i++) {
+			if (cur[i] === -Infinity) continue;
+			const a = cur[i] + count(r, i, m);
+			if (a + q >= n && a > total) {
+				total = a;
+				bestQ = q;
+				bestI = i;
+			}
+		}
+	}
+	const placed = /* @__PURE__ */ new Map();
+	const place = (k, ui, vi) => {
+		if (k === 0) return;
+		const t = pick.get(id(k, ui, vi));
+		if (t === void 0) return place(k - 1, ui, vi);
+		placed.set(jobs[k - 1], T[t]);
+		place(k - 1, ui, t);
+		place(k - 1, t, vi);
+	};
+	const free = [];
+	let ui = bestI;
+	for (let q = bestQ; q >= 1; q--) {
+		free.push(T[ui]);
+		const h = back[q - 1][ui];
+		place(r, h, ui);
+		ui = h;
+	}
+	if (bestQ === 0) place(r, -1, m);
+	else place(r, bestI, m);
+	free.reverse();
+	const rest = order.filter((e) => !placed.has(e));
+	const slots = assignInOrder(rest, free);
+	const items = [];
+	for (const [e, p] of placed) items.push({
+		end: e,
+		anchored: true,
+		at: p
+	});
+	rest.forEach((e, i) => items.push({
+		end: e,
+		anchored: false,
+		at: slots[i]
+	}));
+	for (const f of fixed) items.push({
+		end: -1,
+		anchored: true,
+		at: f
+	});
+	return items.sort((a, b) => a.at - b.at || (a.end < 0 ? -1 : b.end < 0 ? 1 : order.indexOf(a.end) - order.indexOf(b.end)));
+	/** This function gives each end of `list` one of the sorted places `free`, in order. The sum of the squares of the moves from the ideal places is the least. */
+	function assignInOrder(list, places) {
+		const a = list.length;
+		const b = places.length;
+		const cost = (i, j) => (places[j] - ideals[list[i]]) ** 2;
+		const g = Array.from({ length: a + 1 }, () => new Float64Array(b + 1).fill(Infinity));
+		for (let j = 0; j <= b; j++) g[0][j] = 0;
+		for (let i = 1; i <= a; i++) for (let j = i; j <= b; j++) g[i][j] = Math.min(g[i][j - 1], g[i - 1][j - 1] + cost(i - 1, j - 1));
+		const out = new Array(a);
+		let j = b;
+		for (let i = a; i >= 1; i--) {
+			while (j > i && g[i][j - 1] === g[i][j]) j--;
+			out[i - 1] = places[j - 1];
+			j--;
+		}
+		return out;
+	}
+}
+/**
+* This function gives the plan of one wall (PLUG-ASSIGN). Each end has an interval on the axis along the wall. The plugs keep at least `gap` between two of them,
+* and between a plug and a fixed plug at a place of `fixed`. When the room is too short for all the plugs, the gap shrinks evenly. The plan has three goals, in this order:
+* 1. the most ends with their plug in their interval (exact).
+* 2. no crossing at the wall: the order of the keys, when that order lets the count of goal 1.
+* 3. the least sum of the squares of the moves from the ideal places, for the order and the ends of goals 1 and 2.
+*
+* An end that cannot get a plug in its interval still gets a plug in the room. When the order of the keys loses ends, the plugs swap their places
+* to come nearer to that order, while each end keeps its interval.
+*/
+function assignWall(ends, room, gap, fixed = []) {
+	const n = ends.length;
+	if (n === 0) return {
+		at: [],
+		anchored: [],
+		gap
+	};
+	const [lo, hi] = room;
+	const pins = [...fixed].sort((a, b) => a - b);
+	let s = wallGap(n, pins, lo, hi, Math.max(0, gap));
+	const win = ends.map((e) => {
+		const a = Math.max(lo, e.lo);
+		const b = Math.min(hi, e.hi);
+		return a <= b + EPS$3 ? [a, Math.max(a, b)] : void 0;
+	});
+	const order = ends.map((_, i) => i).sort((a, b) => ends[a].key - ends[b].key || a - b);
+	let items = keyOrderPlan(order, win, pins, lo, hi, s);
+	if (!items) {
+		s = 0;
+		items = keyOrderPlan(order, win, pins, lo, hi, s);
+	}
+	const inKey = items.filter((x) => x.end >= 0 && x.anchored).length;
+	if (inKey < win.filter((w) => w !== void 0).length && inKey < unionCap(win, pins, lo, hi, s, n)) {
+		const best = bestPlan(order, win, ends.map((e) => e.ideal), pins, lo, hi, s);
+		if (best.filter((x) => x.end >= 0 && x.anchored).length > inKey) items = untangle(best, ends, win);
+	}
+	const span = items.map((x) => x.end < 0 ? [x.at, x.at] : x.anchored ? win[x.end] : [lo, hi]);
+	const placed = placeInIntervals(items.map((x) => x.end < 0 ? x.at : ends[x.end].ideal), span.map((v) => v[0]), span.map((v) => v[1]), s);
+	const at = new Array(n);
+	items.forEach((x, i) => {
+		if (x.end >= 0) at[x.end] = placed[i];
+	});
+	return {
+		at,
+		anchored: ends.map((e, i) => at[i] >= e.lo - 1e-7 && at[i] <= e.hi + 1e-7 && win[i] !== void 0),
+		gap: s
+	};
+}
+/** This function gives the most plugs with the gap `s` in the union of the intervals, out of the fixed zones, and at most `n`. It is a bound of goal 1. */
+function unionCap(win, fixed, lo, hi, s, n) {
+	const parts = win.filter((w) => w !== void 0).sort((a, b) => a[0] - b[0]);
+	let count = 0;
+	let p = -Infinity;
+	for (const [a, b] of parts) {
+		let v = Math.max(a, p, lo);
+		for (;;) {
+			v = pushOut(v, fixed, s);
+			if (v > b + EPS$3 || v > hi + EPS$3 || count >= n) break;
+			count++;
+			p = v + s;
+			v = p;
+			if (s === 0) return n;
+		}
+	}
+	return count;
+}
+/**
+* This function swaps the places of two neighbours of a plan when their keys are in the wrong order, and each end keeps its interval.
+* Thus the plan comes nearer to the order of the keys. Each swap removes one inversion, so the loop ends.
+*/
+function untangle(items, ends, win) {
+	const own = items.filter((x) => x.end >= 0);
+	const ok = (x, p) => !x.anchored || p >= win[x.end][0] - EPS$3 && p <= win[x.end][1] + EPS$3;
+	for (let changed = true, rounds = 0; changed && rounds <= own.length * own.length; rounds++) {
+		changed = false;
+		for (let i = 0; i + 1 < own.length; i++) {
+			const x = own[i];
+			const y = own[i + 1];
+			if (ends[x.end].key <= ends[y.end].key) continue;
+			if (!ok(x, y.at) || !ok(y, x.at)) continue;
+			const t = x.at;
+			x.at = y.at;
+			y.at = t;
+			own[i] = y;
+			own[i + 1] = x;
+			changed = true;
+		}
+	}
+	return items.sort((a, b) => a.at - b.at || (a.end < 0 ? -1 : b.end < 0 ? 1 : ends[a.end].key - ends[b.end].key));
+}
+/**
+* This function gives the plugs of the plug strategy `assign` (PLUG-ASSIGN). A fixed plug stays at its point, and a plug with a side stays on that side.
+* Each free plug goes on the side that faces the other end (`sideToward`). Each end of a wall has an interval: the range of its port, or the room of the wall.
+* Then `assignWall` places the plugs of each wall, with at least `plugGap` between two of them. The ends of one port share one plug.
+*
+* The output has one entry for each edge with two known nodes, in the order of the edges.
+*/
+function assignEnds(input, options = {}) {
+	const { graph } = input;
+	const gap = options.plugGap ?? ASSIGN_DEFAULTS.plugGap;
+	const inset = options.inset ?? ASSIGN_DEFAULTS.inset;
+	const byId = nodeIndex(graph);
+	const slots = /* @__PURE__ */ new Map();
+	const walls = /* @__PURE__ */ new Map();
+	const wallOf = (node, side) => {
+		const key = JSON.stringify([node.id, side]);
+		let wall = walls.get(key);
+		if (!wall) {
+			const fixed = [];
+			for (const p of node.ports ?? []) {
+				const at = portOffset(node.box, p);
+				if (at === void 0) continue;
+				const point = {
+					x: node.box.x + at.x,
+					y: node.box.y + at.y
+				};
+				if ((p.side ?? nearestSide(node.box, point)) === side) fixed.push(point[alongOf(side)]);
+			}
+			walls.set(key, wall = {
+				node,
+				side,
+				slots: [],
+				fixed
+			});
+		}
+		return wall;
+	};
+	const plugOf = (node, end, far) => {
+		const toward = center(far.box);
+		const port = end.port === void 0 ? void 0 : node.ports?.find((p) => p.id === end.port);
+		if (port && portOffset(node.box, port) !== void 0) return placePlug(node, end, toward);
+		const key = port ? JSON.stringify([node.id, port.id]) : JSON.stringify([node.id, slots.size]);
+		if (slots.has(key)) return key;
+		const side = port?.side ?? sideToward(node.box, toward);
+		const ideal = placePlug(node, end, toward).point[alongOf(side)];
+		const range = rangeInterval(node.box, side, port, inset);
+		const slot = {
+			node,
+			side,
+			ideal,
+			at: ideal,
+			...range ? { range } : {}
+		};
+		slots.set(key, slot);
+		wallOf(node, side).slots.push(slot);
+		return key;
+	};
+	const ends = [];
+	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 source = plugOf(s, e.source, t);
+		const target = plugOf(t, e.target, s);
+		for (const [own, far] of [[source, target], [target, source]]) {
+			const slot = typeof own === "string" ? slots.get(own) : void 0;
+			if (slot && slot.far === void 0) slot.far = far;
+		}
+		ends.push({
+			edge: e.id,
+			source,
+			target
+		});
+	}
+	const farPoint = (s) => {
+		const far = s.far;
+		if (typeof far !== "string") return far.point;
+		const f = slots.get(far);
+		return pointAt$1(f.node.box, f.side, f.ideal);
+	};
+	for (const wall of walls.values()) {
+		const room = roomOf(wall.node.box, wall.side, inset);
+		const plan = assignWall(wall.slots.map((s) => ({
+			lo: s.range?.[0] ?? room[0],
+			hi: s.range?.[1] ?? room[1],
+			ideal: s.ideal,
+			key: keyOf$1(wall.node.box, wall.side, farPoint(s))
+		})), room, gap, wall.fixed);
+		wall.slots.forEach((s, i) => {
+			s.at = plan.at[i];
+		});
+	}
+	const resolve = (p) => {
+		if (typeof p !== "string") return p;
+		const s = slots.get(p);
+		return {
+			point: pointAt$1(s.node.box, s.side, s.at),
+			normal: SIDE_NORMAL[s.side]
+		};
+	};
+	return ends.map((x) => ({
+		edge: x.edge,
+		source: resolve(x.source),
+		target: resolve(x.target)
+	}));
+}
 // src/plugs/leaders/index.ts
 /** The values of `LeaderType`. */
 const LEADER_TYPES = Object.freeze([
@@ -26927,6 +27574,25 @@ const SPREAD_SCHEMA = {
 		describe: "The passes that sort each wall again by the new places of the far ends."
 	}
 };
+/** The declarations of the options of the plug strategy `assign` (PLUG-ASSIGN). */
+const ASSIGN_SCHEMA = {
+	plugGap: {
+		type: "number",
+		min: 0,
+		max: 24,
+		step: 1,
+		default: 8,
+		describe: "The least gap between two plugs of one wall. On a short wall, the gap shrinks evenly."
+	},
+	inset: {
+		type: "number",
+		min: 0,
+		max: 12,
+		step: 1,
+		default: 6,
+		describe: "A plug stays this far from the corners of its wall."
+	}
+};
 /** The declarations of the options of the whole strategy `pipeline`. */
 const PIPELINE_SCHEMA = {
 	router: {
@@ -28862,6 +29528,14 @@ const plugStrategies = Object.freeze({
 		defaults: { ...LEADER_DEFAULTS },
 		schema: LEADER_SCHEMA,
 		run: (input, o) => leaderEnds(input, o)
+	}),
+	assign: defineStrategy({
+		step: "plugs",
+		name: "assign",
+		describe: "PLUG-ASSIGN. The plugs of each wall go into the ranges of their ports with a minimum gap. The most ends are in their range, then the order of the far ends.",
+		defaults: { ...ASSIGN_DEFAULTS },
+		schema: ASSIGN_SCHEMA,
+		run: (input, o) => assignEnds(input, o)
 	})
 });
 /** The built-in level rules: the strategies of the step `levels`. The router `sections` makes its zoom levels with its option `level`. */
@@ -29008,6 +29682,42 @@ function sideOf(plug, node) {
 	for (const [side, n] of Object.entries(SIDE_NORMAL)) if (n.x === plug.normal.x && n.y === plug.normal.y) return side;
 	return nearestSide(node.box, plug.point);
 }
+/**
+* This function moves the new fixed ports of a side of a node into their ranges (PORT-RANGE). It does this when one port is out of its range.
+* The ports of the side keep their order, and two of them keep at least `gap` (`placeInIntervals`). A side with each port in its range does not change.
+*/
+function keepInRanges(node, ports, gap, inset) {
+	const bySide = /* @__PURE__ */ new Map();
+	for (const p of ports.values()) {
+		const list = bySide.get(p.side);
+		if (list) list.push(p);
+		else bySide.set(p.side, [p]);
+	}
+	const box = node.box;
+	for (const [side, list] of bySide) {
+		const along = alongAxis(side);
+		const v = (p) => p.at[along] + (along === "y" ? box.y : box.x);
+		if (!list.some((p) => {
+			const r = rangeInterval(box, side, p, inset);
+			return r !== void 0 && (v(p) < r[0] - 1e-6 || v(p) > r[1] + 1e-6);
+		})) continue;
+		const start = along === "y" ? box.y : box.x;
+		const len = along === "y" ? box.h : box.w;
+		const sorted = [...list].sort((a, b) => v(a) - v(b));
+		const span = sorted.map((p) => rangeInterval(box, side, p, inset) ?? [start, start + len]);
+		const at = placeInIntervals(sorted.map(v), span.map((r) => r[0]), span.map((r) => r[1]), gap);
+		sorted.forEach((p, i) => {
+			const point = {
+				...p.at,
+				[along]: at[i] - start
+			};
+			ports.set(p.id, {
+				...p,
+				at: point
+			});
+		});
+	}
+}
 /** This function gives an id that no port of the node has, from `base`. */
 function freeId(taken, base) {
 	let id = base;
@@ -29022,6 +29732,7 @@ function freeId(taken, base) {
 *
 * The rule sees the graph of `corners`: the plugs of `resolvePorts`, without the inner edges of the frames.
 * The rule is a strategy of the step `plugs`, or the name of one in the registry.
+* A new fixed port with a `range` is in its range (PORT-RANGE). When the rule gives a plug out of the range, the new plugs of that side move into their ranges.
 * The output is a new graph. The function does not change the input.
 */
 function fixPorts(graph, rule, options = {}) {
@@ -29090,6 +29801,16 @@ function fixPorts(graph, rule, options = {}) {
 			target
 		};
 	});
+	const own = strategy.defaults;
+	const given = options.plugOptions ?? {};
+	const num = (a, b, c) => typeof a === "number" ? a : typeof b === "number" ? b : c;
+	const gap = num(given.plugGap, own.plugGap, 0);
+	const inset = num(given.inset, own.inset, 6);
+	const ranges = options.ranges ?? (strategy.name === "assign" ? "rule" : "keep");
+	for (const [id, m] of fixed) {
+		const node = byId.get(id);
+		if (node && ranges === "keep") keepInRanges(node, m, gap, inset);
+	}
 	const nodes = graph.nodes.map((n) => {
 		const m = fixed.get(n.id);
 		const more = added.get(n.id);
@@ -31043,8 +31764,9 @@ function silhouette(graph, level) {
 /**
 * This function makes a seeded small change of a graph: one node moves by `boardUnit`, one edge goes and one new edge comes.
 * The moved box keeps a gap of 4 units to the other boxes. The same graph and the same seed give the same change.
+* With `edges: false`, the change only moves the node (Z11). The moved node is the node of the full change with the same seed.
 */
-function changeGraph(graph, seed) {
+function changeGraph(graph, seed, options = {}) {
 	const R = rng(seed * 2654435761 + 97);
 	const n = graph.nodes.length;
 	const u = boardUnit(graph);
@@ -31082,7 +31804,7 @@ function changeGraph(graph, seed) {
 	let edges = [...graph.edges];
 	let removed;
 	let added;
-	if (edges.length > 1) {
+	if (edges.length > 1 && options.edges !== false) {
 		const j = Math.floor(R() * edges.length);
 		const gone = edges[j];
 		removed = gone.id;
@@ -31132,6 +31854,40 @@ function routeStability(graph, before, after, options = {}) {
 		moved: s.moved
 	};
 }
+/**
+* This function measures the move response of a router (Z11 of MEAS0). `change` is a change of `changeGraph` with `edges: false`.
+* It gives `undefined` when no node moved. Above `sample` routes, a seeded sample serves, and the sum scales to all the routes.
+*/
+function moveResponse(graph, change, before, after, options = {}) {
+	const node = change.moved;
+	if (node === void 0) return void 0;
+	const max = options.sample ?? 2e3;
+	const prev = new Map(before.routes.map((r) => [r.edge, r.points]));
+	const ends = new Map(graph.edges.map((e) => [e.id, e.source.node === node || e.target.node === node]));
+	let routes = after.routes.filter((r) => prev.has(r.edge));
+	const all = routes.length;
+	if (routes.length > max) {
+		const R = rng(options.seed ?? 1);
+		routes = Array.from({ length: max }, () => routes[Math.floor(R() * routes.length)]);
+	}
+	const u = boardUnit(graph);
+	const degree = graph.edges.filter((e) => ends.get(e.id) === true).length;
+	let sum = 0;
+	let far = 0;
+	let spilled = 0;
+	for (const r of routes) {
+		const f = frechet(prev.get(r.edge), r.points);
+		sum += f;
+		if (ends.get(r.edge) === true) continue;
+		far++;
+		if (f > 1) spilled++;
+	}
+	const scale = routes.length > 0 ? all / routes.length : 0;
+	return {
+		gain: sum * scale / u / Math.max(1, degree),
+		spill: far > 0 ? spilled / far : 0
+	};
+}
 // src/bench/measures/room.ts
 /** Up to this number of boxes, `roomOrderFaults` examines each pair. */
 const EXACT_PAIRS = 2e3;
@@ -31628,7 +32384,7 @@ function routeSeparation(routes, near = 4, maxAngle = 5) {
 	if (ink <= 0) return 0;
 	const grid = new Grid(Math.max(16, 4 * near));
 	legs.forEach((l, i) => grid.addSegment(i, l.a, l.b));
-	const sin = Math.sin(maxAngle * Math.PI / 180);
+	const sin = parallelSine(maxAngle);
 	let close = 0;
 	legs.forEach((s, i) => {
 		const length = dist(s.a, s.b);
@@ -31653,6 +32409,97 @@ function routeSeparation(routes, near = 4, maxAngle = 5) {
 	});
 	return Math.min(1, close / ink);
 }
+/** This function gives the sine of the largest angle between two legs that R12 and R16 count as parallel. */
+function parallelSine(maxAngle) {
+	return Math.sin(maxAngle * Math.PI / 180);
+}
+/** The distance in units of the board up to which two parallel legs are neighbors for R16. It is 8 lane widths. */
+const MEASURE_BALANCE_REACH = 32;
+/**
+* This function gives the lane balance of the routes (R16 of MEAS0): the spread of the gaps between parallel routes.
+*
+* The legs are the legs of R12. For each leg `s`, its neighbor at each side is the nearest leg `t` of other edges with three properties.
+* It is within `maxAngle` degrees of parallel. Its projection overlaps `s`. Its distance at the middle of the overlap is less than `reach`.
+* Each neighbor pair gives a gap `g` with the weight `w`, the length of the overlap. A pair counts one time.
+* Two legs on one line have the gap 0.
+*
+* `cv = sqrt(Σ w (g − ḡ)² / Σ w) / ḡ`, with `ḡ = Σ w g / Σ w`. Lower is better. Routes without a neighbor pair give 0.
+* R12 counts the parallel ink that is too near. R16 counts uneven gaps, also when each gap is wide.
+*/
+function routeBalance(routes, reach = 32, maxAngle = 5) {
+	const legs = legsOf(routes);
+	const grid = new Grid(Math.max(16, reach));
+	legs.forEach((l, i) => grid.addSegment(i, l.a, l.b));
+	const sin = parallelSine(maxAngle);
+	const gaps = /* @__PURE__ */ new Map();
+	legs.forEach((s, i) => {
+		const length = dist(s.a, s.b);
+		if (length <= 0) return;
+		const ux = (s.b.x - s.a.x) / length;
+		const uy = (s.b.y - s.a.y) / length;
+		const best = /* @__PURE__ */ new Map();
+		grid.querySegment(s.a, s.b, reach, (j) => {
+			const t = legs[j];
+			if (j === i || t.edges === s.edges) return;
+			const tx = t.b.x - t.a.x;
+			const ty = t.b.y - t.a.y;
+			const tl2 = tx * tx + ty * ty;
+			const cross = ux * ty - uy * tx;
+			if (tl2 <= 0 || cross * cross > sin * sin * tl2) return;
+			const p = (t.a.x - s.a.x) * ux + (t.a.y - s.a.y) * uy;
+			const q = (t.b.x - s.a.x) * ux + (t.b.y - s.a.y) * uy;
+			const lo = Math.max(0, Math.min(p, q));
+			const hi = Math.min(length, Math.max(p, q));
+			if (hi - lo <= 1e-9) return;
+			const m = (lo + hi) / 2;
+			const px = s.a.x + ux * m;
+			const py = s.a.y + uy * m;
+			const k = ((px - t.a.x) * tx + (py - t.a.y) * ty) / tl2;
+			const o = (t.a.x + tx * k - px) * -uy + (t.a.y + ty * k - py) * ux;
+			const g = Math.abs(o);
+			if (g >= reach) return;
+			const side = o < -1e-9 ? -1 : 1;
+			const now = best.get(side);
+			if (!now || g < now.g) best.set(side, {
+				j,
+				g,
+				w: hi - lo
+			});
+		});
+		for (const n of best.values()) {
+			const key = i < n.j ? `${i},${n.j}` : `${n.j},${i}`;
+			if (!gaps.has(key)) gaps.set(key, {
+				g: n.g,
+				w: n.w
+			});
+		}
+	});
+	const list = [...gaps.values()];
+	const W = list.reduce((sum, x) => sum + x.w, 0);
+	if (list.length === 0 || W <= 0) return {
+		cv: 0,
+		low: 0,
+		pairs: 0
+	};
+	const mean = list.reduce((sum, x) => sum + x.w * x.g, 0) / W;
+	const variance = list.reduce((sum, x) => sum + x.w * (x.g - mean) ** 2, 0) / W;
+	const sorted = [...list].sort((x, y) => x.g - y.g);
+	let acc = 0;
+	let median = sorted[sorted.length - 1].g;
+	for (const x of sorted) {
+		acc += x.w;
+		if (acc >= W / 2) {
+			median = x.g;
+			break;
+		}
+	}
+	const low = list.filter((x) => x.g < median / 2).reduce((sum, x) => sum + x.w, 0) / W;
+	return {
+		cv: mean > 0 ? Math.sqrt(variance) / mean : 0,
+		low,
+		pairs: list.length
+	};
+}
 /**
 * This function gives the orthogonality of the routes (R14 of MEAS0): `orth = Σ L(legs within maxAngle degrees of an axis) / Σ_e L(r_e)`.
 * Each route counts its own legs, also on a shared segment. The scale is 0 to 1, and higher is better for an orthogonal style.
@@ -32945,6 +33792,7 @@ function compareStep(step, graph, options = {}) {
 	let rows;
 	if (step === "router") {
 		const change = graph.nodes.length <= stabilityMax ? changeGraph(graph, seed) : void 0;
+		const move = graph.nodes.length <= stabilityMax ? changeGraph(graph, seed, { edges: false }) : void 0;
 		rows = listStrategies(registry, "router").map((strategy) => {
 			if (graph.nodes.length > (strategy.maxNodes ?? Infinity)) return {
 				step,
@@ -32968,6 +33816,28 @@ function compareStep(step, graph, options = {}) {
 				values["Z10.max"] = s.max;
 				values["Z10.moved"] = s.moved;
 			}
+			if (move) {
+				const z = moveResponse(graph, move, result, router.route(move.graph), { seed });
+				if (z) {
+					values["Z11.gain"] = z.gain;
+					values["Z11.spill"] = z.spill;
+				}
+			}
+			if (change) {
+				const given = own[strategy.name] ?? {};
+				const base = typeof given.seed === "number" ? given.seed : strategy.defaults?.seed;
+				if (typeof base === "number") {
+					const s = routeStability(graph, result, asRouter(strategy, {
+						...own[strategy.name],
+						seed: base + 1
+					}).route(graph), { seed });
+					values["Z12.mean"] = s.mean;
+					values["Z12.moved"] = s.moved;
+				} else {
+					values["Z12.mean"] = 0;
+					values["Z12.moved"] = 0;
+				}
+			}
 			return {
 				step,
 				strategy: strategy.name,
@@ -33675,6 +34545,24 @@ const MEASURES = Object.freeze([
 		"higher",
 		false
 	],
+	[
+		"R16.cv",
+		"R16",
+		"route.balance.cv",
+		"no unit",
+		"lower",
+		true,
+		"The spread of the gaps between parallel routes: the standard deviation of the gaps over their mean. A value of 0 is even."
+	],
+	[
+		"R16.low",
+		"R16",
+		"route.balance.low",
+		"0 to 1",
+		"lower",
+		true,
+		"The share of the parallel overlap with a gap less than half of the median gap."
+	],
 	[
 		"ink",
 		"R1",
@@ -34039,6 +34927,42 @@ const MEASURES = Object.freeze([
 		"higher",
 		false
 	],
+	[
+		"Z11.gain",
+		"Z11",
+		"route.stability.move.gain",
+		"no unit",
+		"lower",
+		false,
+		"The movement of all the routes after one node moves by one unit, for each edge of that node. A value of 1 is a local response."
+	],
+	[
+		"Z11.spill",
+		"Z11",
+		"route.stability.move.spill",
+		"0 to 1",
+		"lower",
+		false,
+		"The share of the routes of other nodes that move after one node moves by one unit. A value of 0 is a local response."
+	],
+	[
+		"Z12.mean",
+		"Z12",
+		"route.stability.seed.mean",
+		"units of the board",
+		"lower",
+		false,
+		"The mean movement of the routes with the next seed of the strategy. A strategy without a seed has 0."
+	],
+	[
+		"Z12.moved",
+		"Z12",
+		"route.stability.seed.moved",
+		"0 to 1",
+		"lower",
+		false,
+		"The share of the routes that move with the next seed of the strategy. A strategy without a seed has 0."
+	],
 	[
 		"level-nesting",
 		"Z6",
@@ -37143,6 +38067,9 @@ function rowValues(step, graph, row, base) {
 		const open = openLanes(row.result);
 		values["R12.share"] = routeSeparation(routes);
 		values["R14.share"] = orthogonality(routes);
+		const balance = routeBalance(routes);
+		values["R16.cv"] = balance.cv;
+		values["R16.low"] = balance.low;
 		values["B5.crossings"] = laneCrossings(open.graph);
 		values["B7.ratio"] = occupiedArea(routes, boardUnit(graph));
 		const runs = runProfile(open.graph);
@@ -38589,6 +39516,6 @@ const sharedStretchStrategy = defineStrategy({
 		name: "shared-stretch"
 	}).route(graph)
 });
-export { ADAM_DEFAULTS, ADAM_SCHEMA, AMBIGUITY_GUARD_DEFAULTS, ANNEALING_DEFAULTS, ANNEALING_SCHEMA, ARC_SOURCES, AREA_DEFAULTS, AREA_WIDTHS, ATTRACTION_DEFAULTS, ATTRACTION_SCHEMA, BACKTRACK_MIN, BACKTRACK_SHARE, BALANCE_DEFAULTS, BALANCE_ENDS, BIPARTITE, BIPARTITE_LAYOUTS, BOARD_PORTFOLIO_DEFAULTS, BOARD_PORTFOLIO_SETTINGS, BREAK, BREAK_EVEN, BREAK_EVEN_DEFAULTS, BRONCHIAL_DEFAULTS, BRONCHIAL_SPLITS, BUILT_IN_STRATEGIES, BoundaryWalk, CANAL_DEFAULTS, CANAL_SCHEMA, CANDIDATE_SOURCES, CAP_SWEEP, CASES, CHANNEL_REACH, CLEARANCE_CAP, COMPARE_ALL_STEPS, COMPARE_STEPS, CONFLUENT_DEFAULTS, CONSENSUS_DEFAULTS, CONSENSUS_LINKAGES, CORRIDOR_DEFAULTS, COVERAGE_FAMILIES, CROSSBAR_DEFAULTS, CUBU_DEFAULTS, CURRICULUM_DEFAULTS, CURRICULUM_ORDERS, CURRICULUM_POOL, CURVE_TYPES, CUT_DEFAULTS, CornerGraph, DEFAULT_RNG, DENSE_GROUPS, DENSITY_KERNELS, DETAIL_DEFAULTS, DIFFUSION_DEFAULTS, DISTORTION_NEIGHBOURS, DIVIDED_DEFAULTS, EDGE_DISTANCES, EDGE_PATH_DEFAULTS, EXACT_CLASSES, EXACT_EDGES_PER_NODE, EXACT_V1, EXACT_V1_BOUNDS, EXACT_V1_BOUNDS_SIZES, EXACT_V1_SEEDS, EXACT_V1_SIZES, FAN_OUT, FDEB_DEFAULTS, FIREFLY_DEFAULTS, FIXTURES, FIXTURE_LAYOUTS, FIXTURE_LOCALITY, FLOW_CLUSTER_DEFAULTS, FLOW_FIELD_DEFAULTS, FRAME_ROWS, FRECHET_DEFAULTS, FRONT_OBJECTIVES, GAP_BASELINES, GAP_BOOTSTRAP, GAP_CAPS, GAP_DEFAULTS, GAP_RULES, GAP_VIEWS, GROUP_SCOPES, GROUP_SPINES, GROWTH_DEFAULTS, GROWTH_SWEEP, GUTTER_BEND_COST, Grid, HDBSCAN_DEFAULTS, HIERARCHY_DEFAULTS, HIERARCHY_GROUPS, HIGHWAYS_ENGINE, HIGHWAYS_FAMILIES, HIGHWAY_BASES, HIGHWAY_BASE_ROUTERS, HOUGH_DEFAULTS, HUB_ALLOCATIONS, HUB_ARC_DEFAULTS, HUB_CANDIDATES, HUB_CHAIN, HYSTERESIS_DEFAULTS, INTERCHANGE_BASES, INTERCHANGE_DEFAULTS, KDEEB_DEFAULTS, KD_DEFAULTS, KENDALL_EXACT, KNEE_DEFAULTS, KNEE_RULES, LANES_DEFAULTS, LANE_ORDERS, LANE_STRETCH_DEFAULTS, LANE_STRETCH_ORDERS, LANE_TRACKS, LEADER_DEFAULTS, LEADER_TYPES, LEVEL_HIGHWAY_DEFAULTS, LINKAGES, LINK_COMMUNITY_DEFAULTS, LOCAL_MESH, MANIFOLD_DEFAULTS, MANIFOLD_SIDES, MANY_GROUPS, MEASURES, MEASURE_LANE_WIDTH, MEET_DEFAULTS, MEMBER_FORMS, MESH_DEFAULTS, MINGLE_DEFAULTS, MIN_EFFECTS, MLSEB_DEFAULTS, MLS_FITS, MODULE_RULES, MOVE_NAMES, NESTED_DEFAULTS, OD_CELL_DEFAULTS, OUTSIDE_SLACK, Obstacles, PACKED_GRID, PICK, PIPELINE, PLAN_CHANGERS, PORTFOLIO_B1, PORTFOLIO_BANDS, PORTFOLIO_BASE_MEMBER, PORTFOLIO_CAPS, PORTFOLIO_FIT, PORTFOLIO_HASHES, PORTFOLIO_KS_API, PORTFOLIO_RULES, PORTFOLIO_SETS, POWER_DEFAULTS, PREFERENCE_DEFAULTS, PREFERENCE_FEATURES, PREFERENCE_PANEL, PROPOSED_RULES, P_HUB_DEFAULTS, QUICKBUNDLES_DEFAULTS, RECORD_EPS, REROUTE_DEFAULTS, REROUTE_SCHEMA, RESISTANCE_DEFAULTS, RIDGE_DEFAULTS, ROAD_CLASS_DEFAULTS, ROOM_FAMILIES, ROUTED_STEPS, ROUTERS, SAME_HIGHWAY, SBEB_DEFAULTS, SCALE_SPACE_DEFAULTS, SCREEN_FAMILY_BY, SCREEN_RULES, SCREEN_SETS, SCREEN_STEPS, SCREEN_V1, SCREEN_V2, SCREEN_V2_HELD_OUT, SCREEN_V3, SCREEN_V3_HELD_OUT, SCREEN_WRAPS, SEARCH_DEFAULTS, SEARCH_MOVES, SECTION_DEFAULTS, SELECT_DEFAULTS, SIDE_NORMAL, SKELETON_GROUPS, SKELETON_TARGETS, SLACK_SWEEP, SLOT_DEFAULTS, SLOT_KEYS, SMALL_CLUSTERED, SOFT_KEY_DEFAULTS, SPACING_LIMIT, SPARSE_LONG, SPECTRAL_DEFAULTS, SPIRAL_DEFAULTS, SPREAD_DEFAULTS, STABLE_ID_DEFAULTS, STEINER_DEFAULTS, STEINER_GROUPS, STEINER_METHODS, STEINER_METRICS, STEPS, STRATEGIES, STREET_DEFAULTS, STREET_SOURCES, STRETCH_DEFAULTS, STRETCH_SWEEP, STUB_DEFAULTS, SUITE_COLUMNS, SWARM_SEARCHES, SoftGraph, SplitTree, TERRITORY_DEFAULTS, TERRITORY_POINTS, THIN_BARS, TIGHT_DEFAULTS, TIGHT_FIRSTS, TIGHT_SCHEMA, TIGHT_TIES, TINY_UNIFORM, TOLERANCE, TRACING_DEFAULTS, TRACING_QUANTILES, TRACING_WEIGHTS, TRACLUS_DEFAULTS, TRAFFIC_RULES, TWO_HUBS, UNEVEN_SIZES, VENATION_BACKBONES, VENATION_DEFAULTS, WEISZFELD_DEFAULTS, WIDTH_SCALES, WSPD_DEFAULTS, WayFinder, ZIPPER_DEFAULTS, activationBase, activationReport, adamRouter, adamRoutes, adamStrategy, adjustedRandIndex, agreementOf, allSections, ambiguity, ambiguityGate, ambiguityPlan, annealWays, annealingRouter, annealingStrategy, arcCurve, arcsin, areaPlan, aroundBox, asRouter, attraction, attractionRouter, attractionStrategy, backboneLinks, backtrackOf, balance, balanceOf, balancePlan, basePlan, benchBendRoom, benchCurveStrategies, benchCurves, benchHighways, benchLevelRoom, benchOne, benchRoom, benchRun, benchTracks, bendCount, bendingEnergy, bicliqueGroups, bigGroups, boardGaps, boardPortfolio, boardUnit, boardWins, bootstrapMedian, boundsFamilyName, boxDisplacement, boxExit, boxPush, boxUnit, boxesOverlap, breakEvenGate, breakEvenPlan, bronchialPlan, buildSections, bundleStretch, bundledShare, byCollection, byDataGroup, canalHubs, canalRouter, canalStrategy, canalWays, candidateArcs, candidatePlan, candidateScore, canonicalJson, capSettings, caseSeed, cellSteps, center, chainClusters, changeGraph, changedDimensions, channelOverflows, channelWidth, characteristicPoints, checkFamilies, checkLevels, checkOptions, checkParents, checkPlan, checkPort, checkProperties, checkSchema, checkSections, clampOptions, clothoidCurve, clusters1d, coAssociation, collapseLinks, commonEdges, compareAnyStep, compareMeasure, compareSpec, compareStep, compatibility, compatibilityMatrix, confluentPlan, consensusGroups, consensusLabels, consensusPlan, controlChain, cornersRouter, corpusManifest, corridorPlan, countCrossings, countOverlaps, createFamilyRegistry, createRegistry, crossbarPlan, crossesItself, crossingAngle, crossingAngles, cubicAt, cubuPlan, curriculum, curvatureVariation, curveDeviation, curveFaults, curveJoints, curveOf, curveRuns, curveSpace, curveStrategies, curvesHash, cutGroups, cutShare, declaresFamily, defineStrategy, denseGroupsBoard, densityPlan, densityRidges, depthLevels, detailLevels, detailWidth, detourSpread, diamondAngle, diffusionPlan, dimensionAt, dimensionUnit, dist, distanceDistortion, distinctPoints, divideHighway, dividedPlan, documentHash, dominates, drawnSegments, edgeBlocks, edgeEnds, edgeLengths, edgePathPlan, edgePaths, edgePlugs, edgeResistance, enumDimension, exactBoard, exactFamily, exactGenerator, exactSeed, exactStretch, exactStretches, exercised, facingEnds, familyCell, familyKind, familyOf, familySeed, farLevel, farLinks, fdebLines, fdebPlan, fft, findStrategy, finderOf, fireflies, firstLines, fitPreferences, fixPorts, fixedPortPoint, fixtureGroupOptions, fixtureParams, fixtureRngSeed, fixtureSpecOf, flowClusterPlan, flowClusters, flowDistance, flowFieldPlan, fnv1a32, follow, formatActivation, formatBendRoom, formatCapped, formatCurves, formatFaults, formatFronts, formatGap, formatHighways, formatInput, formatLevelRoom, formatLevels, formatMeasureTime, formatPaired, formatRoom, formatRules, formatScreen, formatSections, formatSummaries, formatTable, formatTracks, frameRoutes, frechet, frechetBundles, frechetPlan, freeLines, g1Defect, g2Defect, gapBaselines, gapCap, gapClosed, gapLaneCounts, gapLanes, gapNames, gapPlan, gapValues, gateStrategy, getStrategy, goesOutAndBack, graphInput, greedyBicliques, greedyCrossbars, groupEdges, groupFill, groupRun, groupSettings, groupStability, groupStrategies, groupedPlan, growthPlan, growthSettings, guardBreaks, gutterRoutes, halfPower, hasCusp, hdbscanClusters, hdbscanLabels, hdbscanPlan, hierarchyPlan, highwayChurn, highwayCurve, highwayCurves, highwayEdits, highwayIdKeep, highwayMoves, highwayRouter, highwayRouterStrategy, highwayRouters, highwayStrategies, highwaysRegistry, houghLines, houghPeaks, houghPlan, hubArcPlan, hubCandidates, hubChainBoard, hysteresisGate, hysteresisPlan, inflate, inflectionCount, inflectionCurve, inflectionSector, inkSaved, innerPoints, inputGraph, inputId, interchangeCandidates, interchangePlan, isRoutedStep, itemOverlaps, itemSizes, jaccard, jaccardIndex, jogPeaks, joinReports, jsonSafe, kMeans, kdGroups, kdeebLines, kdeebPlan, keepMembers, kendallTau, keyGroups, keyedSections, keysPlan, kneeOf, kneePlan, labelGroups, laneArea, laneCrossings, laneFidelity, laneOrder, laneRoutes, laneSeparation, laneSettings, laneStretches, lanesPlan, lanesThrough, leaderEnds, leafGroups, lengthBetween, levelCut, levelGrouping, levelHighwayPlan, levelMeasures, levelPairs, levelRatio, levelRoom, levelStrategies, levelsOf, lineDensity, linePoint, linkAgreement, linkCommunities, linkCommunityGroups, linkCommunityPlan, linkDensity, listOptions, listStrategies, madeUpPairs, makeFixture, makeRoom, manifestHash, manifoldPlan, manyGroupsBoard, matchHighways, maxStretch, mdf, meanLine, measureBoard, measureByKey, measureByName, measureHighways, measureJogs, measureLevel, measureLevelFaults, measureLinks, measureName, measureQuality, measureRouteFaults, measureStability, meetMember, meetPlan, meetingPoints, memberAt, memberStrategy, mergeAngle, meshPlan, meshWaypoints, minEffectOf, minHash, mingleBundles, minglePlan, mixedSegments, mixesCollections, mlsPoint, mlsebLines, mlsebPlan, modularity, modulesOf, mulberry32, namedObjectives, nearestCentre, nearestOnBoundary, nearestOnLine, nearestSide, nearestSkeleton, nestedGridBoard, nestedGroups, nestedPlan, nestingFaults, nestingViolations, nextRow, nodeAmbiguity, nodeIndex, nodeLinks, numberDimension, numberOf, occupiedArea, odCellPlan, odGroups, offsetLine, offsetPolyline, oneSteiner, openGaps, openLanes, optimaFile, optimumKey, optionDefaults, orderChanges, orderFragility, orderLanes, orderRows, orderStability, orderSuiteRows, orthogonality, outOfBoxes, outerGraph, outputGroups, outputHash, pHubPlan, pMedian, packedGridBoard, pairCosts, paramProblem, paretoFront, parseLines, partWithin, passSettings, pathPoints, peakCurvature, pickLevel, pickMoves, placePlug, planMoves, planOfResult, plugSpacing, plugStrategies, plugsRouter, pointAt, pointBoxDistance, pointDensity, pointGroups, pointOnSide, pointSegmentDistance, polylineLength, portOffset, portfolio, portfolioB1Spec, portfolioBand, portfolioFacts, portfolioKey, portfolioMember, portfolioMembers, portfolioName, portfolioRouter, portfolioStrategy, positionStability, powerPlan, preferences, pullApart, quadtreeGroups, quantile, quickBundles, quickBundlesPlan, randomInt, rankShares, rayToBox, recordLines, recordMoves, rectScattered, regionBounds, register, repairResult, repairStrategy, representative, rerouteRouter, rerouteStrategy, rerouteWays, resample, resistanceClusters, resistancePlan, resolvePorts, resultForm, resultHash, ridgeLines, ridgePlan, rng, roadClassPlan, roomDemand, roomLinks, roomOrderFaults, roomStrategies, roomValues, round3, roundCorners, roundedCurve, routeCrossings, routeInStableOrder, routeMeasures, routePortfolio, routeSeparation, routeStability, routeSymmetry, routerStrategies, routersOf, ruleCounts, runBenchmark, runKey, runPipeline, runProfile, runSuite, sameData, sampleCurve, samplesOf, sbebLines, sbebPlan, scaleClusters, scaleSpaceGroups, scaleSpacePlan, screen, screenInputs, screenSplit, searchPlan, searchScore, sectionsRouter, segmentBounds, segmentBoxDistance, segmentClusters, segmentDistance, segmentHitsBox, segmentHitsRect, segmentKey, segmentsCross, segmentsOf, selectBest, selectPlan, setManifest, settingAt, sha256Hex, shapeSkeleton, sharedRouter, sharedStretchStrategy, sharedStretches, sharedWaysAll, sharedWaysPlan, shuffleEdges, sideAngle, sideToward, signTestPower, silhouette, skeletonGroups, skeletonPath, slackSettings, slotJoin, slotPlan, slotsOf, smoothCurve, snapPlan, softDistance, softKeyClusters, softKeyPlan, softStep, spanningTree, spectralClusters, spectralLabels, spectralPlan, spinePart, spiralJoin, spiralPlan, spiralTree, splineCurve, splitFrames, splitPath, splitPoint, splitTargets, spreadEnds, spreadWith, stableIdGate, stableIdPlan, stableOrder, stableOrderStrategy, steinerPlan, stepRouterStrategy, stepRouters, stepSeed, straightCurve, straightRouter, strategyKey, streetEdges, streetPlan, streetPoint, streetRide, stretchGate, stretchLaneOrders, stretchPlan, stretchSettings, stubPlan, suiteFronts, sumFaults, summarize, summarizeGap, summarizeRows, swarmScore, sweepGrid, sweepOf, sweepRoom, sweepSections, sweepValues, symmetricEigen, territoryPlan, tightRouter, tightStrategy, toSvgPath, totalTurn, tracePlan, tracing, tracingLoads, tracingValue, traclusPlan, treeCost, treeDepth, trunksRouter, turns, turnsOf, unwrappedName, utf8, venationLevels, venationLinks, waySlacks, waypointWay, weberPoint, weiszfeldPlan, wholeBoard, wholeStrategies, withBends, withRepair, withStableOrder, wspdGroups, wspdPlan, zipLegs, zipperPlan };
+export { ADAM_DEFAULTS, ADAM_SCHEMA, AMBIGUITY_GUARD_DEFAULTS, ANNEALING_DEFAULTS, ANNEALING_SCHEMA, ARC_SOURCES, AREA_DEFAULTS, AREA_WIDTHS, ASSIGN_DEFAULTS, ATTRACTION_DEFAULTS, ATTRACTION_SCHEMA, BACKTRACK_MIN, BACKTRACK_SHARE, BALANCE_DEFAULTS, BALANCE_ENDS, BIPARTITE, BIPARTITE_LAYOUTS, BOARD_PORTFOLIO_DEFAULTS, BOARD_PORTFOLIO_SETTINGS, BREAK, BREAK_EVEN, BREAK_EVEN_DEFAULTS, BRONCHIAL_DEFAULTS, BRONCHIAL_SPLITS, BUILT_IN_STRATEGIES, BoundaryWalk, CANAL_DEFAULTS, CANAL_SCHEMA, CANDIDATE_SOURCES, CAP_SWEEP, CASES, CHANNEL_REACH, CLEARANCE_CAP, COMPARE_ALL_STEPS, COMPARE_STEPS, CONFLUENT_DEFAULTS, CONSENSUS_DEFAULTS, CONSENSUS_LINKAGES, CORRIDOR_DEFAULTS, COVERAGE_FAMILIES, CROSSBAR_DEFAULTS, CUBU_DEFAULTS, CURRICULUM_DEFAULTS, CURRICULUM_ORDERS, CURRICULUM_POOL, CURVE_TYPES, CUT_DEFAULTS, CornerGraph, DEFAULT_RNG, DENSE_GROUPS, DENSITY_KERNELS, DETAIL_DEFAULTS, DIFFUSION_DEFAULTS, DISTORTION_NEIGHBOURS, DIVIDED_DEFAULTS, EDGE_DISTANCES, EDGE_PATH_DEFAULTS, EXACT_CLASSES, EXACT_EDGES_PER_NODE, EXACT_V1, EXACT_V1_BOUNDS, EXACT_V1_BOUNDS_SIZES, EXACT_V1_SEEDS, EXACT_V1_SIZES, FAN_OUT, FDEB_DEFAULTS, FIREFLY_DEFAULTS, FIXTURES, FIXTURE_LAYOUTS, FIXTURE_LOCALITY, FLOW_CLUSTER_DEFAULTS, FLOW_FIELD_DEFAULTS, FRAME_ROWS, FRECHET_DEFAULTS, FRONT_OBJECTIVES, GAP_BASELINES, GAP_BOOTSTRAP, GAP_CAPS, GAP_DEFAULTS, GAP_RULES, GAP_VIEWS, GROUP_SCOPES, GROUP_SPINES, GROWTH_DEFAULTS, GROWTH_SWEEP, GUTTER_BEND_COST, Grid, HDBSCAN_DEFAULTS, HIERARCHY_DEFAULTS, HIERARCHY_GROUPS, HIGHWAYS_ENGINE, HIGHWAYS_FAMILIES, HIGHWAY_BASES, HIGHWAY_BASE_ROUTERS, HOUGH_DEFAULTS, HUB_ALLOCATIONS, HUB_ARC_DEFAULTS, HUB_CANDIDATES, HUB_CHAIN, HYSTERESIS_DEFAULTS, INTERCHANGE_BASES, INTERCHANGE_DEFAULTS, KDEEB_DEFAULTS, KD_DEFAULTS, KENDALL_EXACT, KNEE_DEFAULTS, KNEE_RULES, LANES_DEFAULTS, LANE_ORDERS, LANE_STRETCH_DEFAULTS, LANE_STRETCH_ORDERS, LANE_TRACKS, LEADER_DEFAULTS, LEADER_TYPES, LEVEL_HIGHWAY_DEFAULTS, LINKAGES, LINK_COMMUNITY_DEFAULTS, LOCAL_MESH, MANIFOLD_DEFAULTS, MANIFOLD_SIDES, MANY_GROUPS, MEASURES, MEASURE_BALANCE_REACH, MEASURE_LANE_WIDTH, MEET_DEFAULTS, MEMBER_FORMS, MESH_DEFAULTS, MINGLE_DEFAULTS, MIN_EFFECTS, MLSEB_DEFAULTS, MLS_FITS, MODULE_RULES, MOVE_NAMES, NESTED_DEFAULTS, OD_CELL_DEFAULTS, OUTSIDE_SLACK, Obstacles, PACKED_GRID, PICK, PIPELINE, PLAN_CHANGERS, PORTFOLIO_B1, PORTFOLIO_BANDS, PORTFOLIO_BASE_MEMBER, PORTFOLIO_CAPS, PORTFOLIO_FIT, PORTFOLIO_HASHES, PORTFOLIO_KS_API, PORTFOLIO_RULES, PORTFOLIO_SETS, POWER_DEFAULTS, PREFERENCE_DEFAULTS, PREFERENCE_FEATURES, PREFERENCE_PANEL, PROPOSED_RULES, P_HUB_DEFAULTS, QUICKBUNDLES_DEFAULTS, RECORD_EPS, REROUTE_DEFAULTS, REROUTE_SCHEMA, RESISTANCE_DEFAULTS, RIDGE_DEFAULTS, ROAD_CLASS_DEFAULTS, ROOM_FAMILIES, ROUTED_STEPS, ROUTERS, SAME_HIGHWAY, SBEB_DEFAULTS, SCALE_SPACE_DEFAULTS, SCREEN_FAMILY_BY, SCREEN_RULES, SCREEN_SETS, SCREEN_STEPS, SCREEN_V1, SCREEN_V2, SCREEN_V2_HELD_OUT, SCREEN_V3, SCREEN_V3_HELD_OUT, SCREEN_WRAPS, SEARCH_DEFAULTS, SEARCH_MOVES, SECTION_DEFAULTS, SELECT_DEFAULTS, SIDE_NORMAL, SKELETON_GROUPS, SKELETON_TARGETS, SLACK_SWEEP, SLOT_DEFAULTS, SLOT_KEYS, SMALL_CLUSTERED, SOFT_KEY_DEFAULTS, SPACING_LIMIT, SPARSE_LONG, SPECTRAL_DEFAULTS, SPIRAL_DEFAULTS, SPREAD_DEFAULTS, STABLE_ID_DEFAULTS, STEINER_DEFAULTS, STEINER_GROUPS, STEINER_METHODS, STEINER_METRICS, STEPS, STRATEGIES, STREET_DEFAULTS, STREET_SOURCES, STRETCH_DEFAULTS, STRETCH_SWEEP, STUB_DEFAULTS, SUITE_COLUMNS, SWARM_SEARCHES, SoftGraph, SplitTree, TERRITORY_DEFAULTS, TERRITORY_POINTS, THIN_BARS, TIGHT_DEFAULTS, TIGHT_FIRSTS, TIGHT_SCHEMA, TIGHT_TIES, TINY_UNIFORM, TOLERANCE, TRACING_DEFAULTS, TRACING_QUANTILES, TRACING_WEIGHTS, TRACLUS_DEFAULTS, TRAFFIC_RULES, TWO_HUBS, UNEVEN_SIZES, VENATION_BACKBONES, VENATION_DEFAULTS, WEISZFELD_DEFAULTS, WIDTH_SCALES, WSPD_DEFAULTS, WayFinder, ZIPPER_DEFAULTS, activationBase, activationReport, adamRouter, adamRoutes, adamStrategy, adjustedRandIndex, agreementOf, allSections, ambiguity, ambiguityGate, ambiguityPlan, annealWays, annealingRouter, annealingStrategy, arcCurve, arcsin, areaPlan, aroundBox, asRouter, assignEnds, assignWall, attraction, attractionRouter, attractionStrategy, backboneLinks, backtrackOf, balance, balanceOf, balancePlan, basePlan, benchBendRoom, benchCurveStrategies, benchCurves, benchHighways, benchLevelRoom, benchOne, benchRoom, benchRun, benchTracks, bendCount, bendingEnergy, bicliqueGroups, bigGroups, boardGaps, boardPortfolio, boardUnit, boardWins, bootstrapMedian, boundsFamilyName, boxDisplacement, boxExit, boxPush, boxUnit, boxesOverlap, breakEvenGate, breakEvenPlan, bronchialPlan, buildSections, bundleStretch, bundledShare, byCollection, byDataGroup, canalHubs, canalRouter, canalStrategy, canalWays, candidateArcs, candidatePlan, candidateScore, canonicalJson, capSettings, caseSeed, cellSteps, center, chainClusters, changeGraph, changedDimensions, channelOverflows, channelWidth, characteristicPoints, checkFamilies, checkLevels, checkOptions, checkParents, checkPlan, checkPort, checkProperties, checkSchema, checkSections, clampOptions, clothoidCurve, clusters1d, coAssociation, collapseLinks, commonEdges, compareAnyStep, compareMeasure, compareSpec, compareStep, compatibility, compatibilityMatrix, confluentPlan, consensusGroups, consensusLabels, consensusPlan, controlChain, cornersRouter, corpusManifest, corridorPlan, countCrossings, countOverlaps, createFamilyRegistry, createRegistry, crossbarPlan, crossesItself, crossingAngle, crossingAngles, cubicAt, cubuPlan, curriculum, curvatureVariation, curveDeviation, curveFaults, curveJoints, curveOf, curveRuns, curveSpace, curveStrategies, curvesHash, cutGroups, cutShare, declaresFamily, defineStrategy, denseGroupsBoard, densityPlan, densityRidges, depthLevels, detailLevels, detailWidth, detourSpread, diamondAngle, diffusionPlan, dimensionAt, dimensionUnit, dist, distanceDistortion, distinctPoints, divideHighway, dividedPlan, documentHash, dominates, drawnSegments, edgeBlocks, edgeEnds, edgeLengths, edgePathPlan, edgePaths, edgePlugs, edgeResistance, enumDimension, exactBoard, exactFamily, exactGenerator, exactSeed, exactStretch, exactStretches, exercised, facingEnds, familyCell, familyKind, familyOf, familySeed, farLevel, farLinks, fdebLines, fdebPlan, fft, findStrategy, finderOf, fireflies, firstLines, fitPreferences, fixPorts, fixedPortPoint, fixtureGroupOptions, fixtureParams, fixtureRngSeed, fixtureSpecOf, flowClusterPlan, flowClusters, flowDistance, flowFieldPlan, fnv1a32, follow, formatActivation, formatBendRoom, formatCapped, formatCurves, formatFaults, formatFronts, formatGap, formatHighways, formatInput, formatLevelRoom, formatLevels, formatMeasureTime, formatPaired, formatRoom, formatRules, formatScreen, formatSections, formatSummaries, formatTable, formatTracks, frameRoutes, frechet, frechetBundles, frechetPlan, freeLines, g1Defect, g2Defect, gapBaselines, gapCap, gapClosed, gapLaneCounts, gapLanes, gapNames, gapPlan, gapValues, gateStrategy, getStrategy, goesOutAndBack, graphInput, greedyBicliques, greedyCrossbars, groupEdges, groupFill, groupRun, groupSettings, groupStability, groupStrategies, groupedPlan, growthPlan, growthSettings, guardBreaks, gutterRoutes, halfPower, hasCusp, hdbscanClusters, hdbscanLabels, hdbscanPlan, hierarchyPlan, highwayChurn, highwayCurve, highwayCurves, highwayEdits, highwayIdKeep, highwayMoves, highwayRouter, highwayRouterStrategy, highwayRouters, highwayStrategies, highwaysRegistry, houghLines, houghPeaks, houghPlan, hubArcPlan, hubCandidates, hubChainBoard, hysteresisGate, hysteresisPlan, inflate, inflectionCount, inflectionCurve, inflectionSector, inkSaved, innerPoints, inputGraph, inputId, interchangeCandidates, interchangePlan, isRoutedStep, itemOverlaps, itemSizes, jaccard, jaccardIndex, jogPeaks, joinReports, jsonSafe, kMeans, kdGroups, kdeebLines, kdeebPlan, keepMembers, kendallTau, keyGroups, keyedSections, keysPlan, kneeOf, kneePlan, labelGroups, laneArea, laneCrossings, laneFidelity, laneOrder, laneRoutes, laneSeparation, laneSettings, laneStretches, lanesPlan, lanesThrough, leaderEnds, leafGroups, lengthBetween, levelCut, levelGrouping, levelHighwayPlan, levelMeasures, levelPairs, levelRatio, levelRoom, levelStrategies, levelsOf, lineDensity, linePoint, linkAgreement, linkCommunities, linkCommunityGroups, linkCommunityPlan, linkDensity, listOptions, listStrategies, madeUpPairs, makeFixture, makeRoom, manifestHash, manifoldPlan, manyGroupsBoard, matchHighways, maxStretch, mdf, meanLine, measureBoard, measureByKey, measureByName, measureHighways, measureJogs, measureLevel, measureLevelFaults, measureLinks, measureName, measureQuality, measureRouteFaults, measureStability, meetMember, meetPlan, meetingPoints, memberAt, memberStrategy, mergeAngle, meshPlan, meshWaypoints, minEffectOf, minHash, mingleBundles, minglePlan, mixedSegments, mixesCollections, mlsPoint, mlsebLines, mlsebPlan, modularity, modulesOf, moveResponse, mulberry32, namedObjectives, nearestCentre, nearestOnBoundary, nearestOnLine, nearestSide, nearestSkeleton, nestedGridBoard, nestedGroups, nestedPlan, nestingFaults, nestingViolations, nextRow, nodeAmbiguity, nodeIndex, nodeLinks, numberDimension, numberOf, occupiedArea, odCellPlan, odGroups, offsetLine, offsetPolyline, oneSteiner, openGaps, openLanes, optimaFile, optimumKey, optionDefaults, orderChanges, orderFragility, orderLanes, orderRows, orderStability, orderSuiteRows, orthogonality, outOfBoxes, outerGraph, outputGroups, outputHash, pHubPlan, pMedian, packedGridBoard, pairCosts, paramProblem, paretoFront, parseLines, partWithin, passSettings, pathPoints, peakCurvature, pickLevel, pickMoves, placePlug, planMoves, planOfResult, plugSpacing, plugStrategies, plugsRouter, pointAt, pointBoxDistance, pointDensity, pointGroups, pointOnSide, pointSegmentDistance, polylineLength, portOffset, portfolio, portfolioB1Spec, portfolioBand, portfolioFacts, portfolioKey, portfolioMember, portfolioMembers, portfolioName, portfolioRouter, portfolioStrategy, positionStability, powerPlan, preferences, pullApart, quadtreeGroups, quantile, quickBundles, quickBundlesPlan, randomInt, rankShares, rayToBox, recordLines, recordMoves, rectScattered, regionBounds, register, repairResult, repairStrategy, representative, rerouteRouter, rerouteStrategy, rerouteWays, resample, resistanceClusters, resistancePlan, resolvePorts, resultForm, resultHash, ridgeLines, ridgePlan, rng, roadClassPlan, roomDemand, roomLinks, roomOrderFaults, roomStrategies, roomValues, round3, roundCorners, roundedCurve, routeBalance, routeCrossings, routeInStableOrder, routeMeasures, routePortfolio, routeSeparation, routeStability, routeSymmetry, routerStrategies, routersOf, ruleCounts, runBenchmark, runKey, runPipeline, runProfile, runSuite, sameData, sampleCurve, samplesOf, sbebLines, sbebPlan, scaleClusters, scaleSpaceGroups, scaleSpacePlan, screen, screenInputs, screenSplit, searchPlan, searchScore, sectionsRouter, segmentBounds, segmentBoxDistance, segmentClusters, segmentDistance, segmentHitsBox, segmentHitsRect, segmentKey, segmentsCross, segmentsOf, selectBest, selectPlan, setManifest, settingAt, sha256Hex, shapeSkeleton, sharedRouter, sharedStretchStrategy, sharedStretches, sharedWaysAll, sharedWaysPlan, shuffleEdges, sideAngle, sideToward, signTestPower, silhouette, skeletonGroups, skeletonPath, slackSettings, slotJoin, slotPlan, slotsOf, smoothCurve, snapPlan, softDistance, softKeyClusters, softKeyPlan, softStep, spanningTree, spectralClusters, spectralLabels, spectralPlan, spinePart, spiralJoin, spiralPlan, spiralTree, splineCurve, splitFrames, splitPath, splitPoint, splitTargets, spreadEnds, spreadWith, stableIdGate, stableIdPlan, stableOrder, stableOrderStrategy, steinerPlan, stepRouterStrategy, stepRouters, stepSeed, straightCurve, straightRouter, strategyKey, streetEdges, streetPlan, streetPoint, streetRide, stretchGate, stretchLaneOrders, stretchPlan, stretchSettings, stubPlan, suiteFronts, sumFaults, summarize, summarizeGap, summarizeRows, swarmScore, sweepGrid, sweepOf, sweepRoom, sweepSections, sweepValues, symmetricEigen, territoryPlan, tightRouter, tightStrategy, toSvgPath, totalTurn, tracePlan, tracing, tracingLoads, tracingValue, traclusPlan, treeCost, treeDepth, trunksRouter, turns, turnsOf, unwrappedName, utf8, venationLevels, venationLinks, waySlacks, waypointWay, weberPoint, weiszfeldPlan, wholeBoard, wholeStrategies, withBends, withRepair, withStableOrder, wspdGroups, wspdPlan, zipLegs, zipperPlan };
 
 //# sourceMappingURL=index.js.map