@mark1russell7/packing 0.1.3 → 0.1.5

package/build/index.js

@@ -598,66 +598,6 @@ function pushCascade(placed, rects, options = {}) {
 	}
 	return [...moved];
 }
-// src/metrics.ts
-/**
-* This function measures a packing. It gives the hull and its aspect, the rows and the raggedness of the right side.
-* It also gives the part of the hull that the rectangles cover, and the widest rectangle against the median width.
-*
-* @example
-* ```ts
-* const { utilization, raggedness } = packingMetrics(Rect.packed(cards));
-* ```
-*/
-function packingMetrics(rects, options = {}) {
-	const tolerance = options.rowTolerance ?? 40;
-	const boxes = rects.filter((r) => r.size.x > 0 && r.size.y > 0);
-	if (boxes.length === 0) return {
-		count: 0,
-		hull: {
-			width: 0,
-			height: 0
-		},
-		hullAspect: 0,
-		rows: [],
-		raggedness: 0,
-		utilization: 0,
-		widestOverMedian: 0
-	};
-	const left = Math.min(...boxes.map((r) => r.position.x));
-	const top = Math.min(...boxes.map((r) => r.position.y));
-	const right = Math.max(...boxes.map((r) => r.right()));
-	const bottom = Math.max(...boxes.map((r) => r.bottom()));
-	const hull = {
-		width: right - left,
-		height: bottom - top
-	};
-	const rows = [];
-	for (const r of boxes.toSorted((a, b) => a.position.y - b.position.y)) {
-		const row = rows.at(-1);
-		if (row && Math.abs(r.position.y - row.top) <= tolerance) {
-			row.right = Math.max(row.right, r.right());
-			row.count += 1;
-		} else rows.push({
-			top: r.position.y,
-			right: r.right(),
-			count: 1
-		});
-	}
-	const rights = rows.map((row) => row.right);
-	const widths = boxes.map((r) => r.size.x).toSorted((a, b) => a - b);
-	const median = widths[Math.floor(widths.length / 2)] ?? 0;
-	const widest = widths.at(-1) ?? 0;
-	const area = boxes.reduce((sum, r) => sum + r.area(), 0);
-	return {
-		count: boxes.length,
-		hull,
-		hullAspect: hull.height > 0 ? hull.width / hull.height : 0,
-		rows: rows.map((row) => row.count),
-		raggedness: Math.max(...rights) - Math.min(...rights),
-		utilization: hull.width * hull.height > 0 ? area / (hull.width * hull.height) : 0,
-		widestOverMedian: median > 0 ? widest / median : 0
-	};
-}
 // src/contract.ts
 /** The tolerance for the comparison of two numbers in an engine. */
 const EPS = 1e-6;
@@ -773,6 +713,541 @@ function turnItem(item) {
 	}
 	return turned;
 }
+// src/sha256.ts
+/** The round constants of SHA-256. */
+const K = new Uint32Array([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+/** The first hash value of SHA-256. */
+const H0 = [
+	1779033703,
+	3144134277,
+	1013904242,
+	2773480762,
+	1359893119,
+	2600822924,
+	528734635,
+	1541459225
+];
+/** This function turns a 32-bit word to the right by `n` bits. */
+const rotr = (x, n) => x >>> n | x << 32 - n;
+/**
+* This function gives the UTF-8 bytes of a string. A lone surrogate becomes U+FFFD, as with `TextEncoder`. The
+* package has no `TextEncoder` type, because its code operates on each runtime with no global types.
+*/
+function utf8(text) {
+	const out = [];
+	for (let i = 0; i < text.length; i++) {
+		let c = text.charCodeAt(i);
+		if (c >= 55296 && c <= 56319 && i + 1 < text.length) {
+			const next = text.charCodeAt(i + 1);
+			if (next >= 56320 && next <= 57343) {
+				c = 65536 + (c - 55296 << 10) + (next - 56320);
+				i++;
+			}
+		}
+		if (c >= 55296 && c <= 57343) c = 65533;
+		if (c < 128) out.push(c);
+		else if (c < 2048) out.push(192 | c >> 6, 128 | c & 63);
+		else if (c < 65536) out.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
+		else out.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
+	}
+	return Uint8Array.from(out);
+}
+/** This function gives the SHA-256 of the UTF-8 bytes of a string, as 64 lowercase hex characters. */
+function sha256Hex(text) {
+	const bytes = utf8(text);
+	const length = bytes.length;
+	const padded = new Uint8Array(((length + 9 + 63) / 64 | 0) * 64);
+	padded.set(bytes);
+	padded[length] = 128;
+	const view = new DataView(padded.buffer);
+	const bits = length * 8;
+	view.setUint32(padded.length - 8, Math.floor(bits / 4294967296));
+	view.setUint32(padded.length - 4, bits >>> 0);
+	const hash = [...H0];
+	const w = /* @__PURE__ */ new Uint32Array(64);
+	for (let block = 0; block < padded.length; block += 64) {
+		for (let t = 0; t < 16; t++) w[t] = view.getUint32(block + t * 4);
+		for (let t = 16; t < 64; t++) {
+			const a = w[t - 15];
+			const b = w[t - 2];
+			const s0 = rotr(a, 7) ^ rotr(a, 18) ^ a >>> 3;
+			const s1 = rotr(b, 17) ^ rotr(b, 19) ^ b >>> 10;
+			w[t] = w[t - 16] + s0 + w[t - 7] + s1 | 0;
+		}
+		let [a, b, c, d, e, f, g, h] = hash;
+		for (let t = 0; t < 64; t++) {
+			const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+			const ch = e & f ^ ~e & g;
+			const t1 = h + s1 + ch + K[t] + w[t] | 0;
+			const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+			h = g;
+			g = f;
+			f = e;
+			e = d + t1 | 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 | 0;
+		}
+		hash[0] = hash[0] + a | 0;
+		hash[1] = hash[1] + b | 0;
+		hash[2] = hash[2] + c | 0;
+		hash[3] = hash[3] + d | 0;
+		hash[4] = hash[4] + e | 0;
+		hash[5] = hash[5] + f | 0;
+		hash[6] = hash[6] + g | 0;
+		hash[7] = hash[7] + h | 0;
+	}
+	return hash.map((x) => (x >>> 0).toString(16).padStart(8, "0")).join("");
+}
+// src/layout-input.ts
+/** This function gives the `fnv1a32` hash of the UTF-8 bytes of a string, as `docs/FORMAT.md` gives it. */
+function fnv1a32(text) {
+	let h = 2166136261;
+	for (const b of utf8(text)) h = Math.imul(h ^ b, 16777619) >>> 0;
+	return h;
+}
+/** This function rounds the numbers of a file to 3 decimals. A half goes up, and the value `-0` becomes 0. */
+function round3(x) {
+	const v = Math.round(x * 1e3) / 1e3;
+	return Object.is(v, -0) ? 0 : v;
+}
+/**
+* This function gives the canonical form of a value: sorted keys, no whitespace and the numbers of `JSON.stringify`
+* after `round3`. A key with the value `undefined` is not in the form.
+*/
+function canonicalJson(value) {
+	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+	if (value !== null && typeof value === "object") return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(",")}}`;
+	return JSON.stringify(typeof value === "number" ? round3(value) : value);
+}
+/** This function gives the hash of an input file: the first 16 hex characters of the SHA-256 of its canonical form without `hash`. */
+function hashInput(file) {
+	const rest = { ...file };
+	delete rest.hash;
+	return sha256Hex(canonicalJson(rest)).slice(0, 16);
+}
+/** This function gives the scale of a count: the nearest of 1, 10, 100, 1000 and 10000 on a log scale. The count 0 gives `1`. */
+function countCell(count) {
+	if (count <= 3) return "1";
+	if (count <= 31) return "10";
+	if (count <= 316) return "100";
+	if (count <= 3162) return "1k";
+	return "10k";
+}
+/** This function gives the packing input of a file. The boxes become the items, and the edges go. */
+function toPackInput(file) {
+	const input = {
+		container: file.container,
+		items: file.boxes
+	};
+	if (file.obstacles !== void 0) input.obstacles = file.obstacles;
+	if (file.gap !== void 0) input.gap = file.gap;
+	return input;
+}
+// src/measures.ts
+const spec = (id, family, unit, direction, min, max) => ({
+	id,
+	family,
+	unit,
+	direction,
+	min,
+	max
+});
+/** The facts of each measure, by id. `docs/MEASURES.md` gives the full definitions. */
+const MEASURE_SPECS = Object.freeze({
+	"pack.area": spec("pack.area", "density", "square units", "lower", 0, Infinity),
+	"pack.fill": spec("pack.fill", "density", "share", "higher", 0, 1),
+	"pack.whitespace": spec("pack.whitespace", "density", "share", "lower", 0, 1),
+	"pack.aspect": spec("pack.aspect", "aspect", "ratio", "lower", 1, Infinity),
+	"pack.aspectError": spec("pack.aspectError", "aspect", "natural log", "lower", 0, Infinity),
+	"pack.order.inversions": spec("pack.order.inversions", "order", "share", "lower", 0, 1),
+	"pack.order.breaks": spec("pack.order.breaks", "order", "count", "lower", 0, Infinity),
+	"pack.raggedness": spec("pack.raggedness", "raggedness", "share", "lower", 0, 1),
+	"pack.overflow": spec("pack.overflow", "overflow", "count", "lower", 0, Infinity),
+	"pack.stability.moved": spec("pack.stability.moved", "stability", "share", "lower", 0, 1),
+	"pack.stability.mean": spec("pack.stability.mean", "stability", "container widths", "lower", 0, Infinity),
+	"pack.stability.q95": spec("pack.stability.q95", "stability", "container widths", "lower", 0, Infinity),
+	"pack.deterministic": spec("pack.deterministic", "determinism", "boolean", "higher", 0, 1),
+	"pack.search.widths": spec("pack.search.widths", "speed", "count", "lower", 0, Infinity),
+	"pack.search.ms": spec("pack.search.ms", "speed", "milliseconds", "lower", 0, Infinity)
+});
+/** This function gives the smallest rectangle around the boxes. No box gives a rectangle of size 0 at 0, 0. */
+function hullOf(boxes) {
+	if (boxes.length === 0) return {
+		x: 0,
+		y: 0,
+		w: 0,
+		h: 0
+	};
+	let left = Infinity;
+	let top = Infinity;
+	let right = -Infinity;
+	let bottom = -Infinity;
+	for (const b of boxes) {
+		left = Math.min(left, b.x);
+		top = Math.min(top, b.y);
+		right = Math.max(right, b.x + b.w);
+		bottom = Math.max(bottom, b.y + b.h);
+	}
+	return {
+		x: left,
+		y: top,
+		w: right - left,
+		h: bottom - top
+	};
+}
+/**
+* This function puts the boxes in rows. It sorts the boxes by their top, and keeps the order of the list for equal tops.
+* A box joins the last row when its top is within `tolerance` of the top of the first box of that row.
+*/
+function rowsOf$1(boxes, tolerance) {
+	const rows = [];
+	for (const b of boxes.toSorted((p, q) => p.y - q.y)) {
+		const row = rows.at(-1);
+		if (row && Math.abs(b.y - row.top) <= tolerance) {
+			row.right = Math.max(row.right, b.x + b.w);
+			row.count += 1;
+		} else rows.push({
+			top: b.y,
+			right: b.x + b.w,
+			count: 1
+		});
+	}
+	return rows;
+}
+/**
+* This function gives the placed boxes of an output, in the order of the items of the input. A box has the size of its
+* item after the turn. The list has no item without a placement, and no item with a width or a height of 0.
+*/
+function boxesOf$1(input, output) {
+	const placements = /* @__PURE__ */ new Map();
+	for (const p of output.placements) if (!placements.has(p.id)) placements.set(p.id, p);
+	const boxes = [];
+	for (const [index, item] of input.items.entries()) {
+		const p = placements.get(item.id);
+		if (p === void 0 || !(item.w > 0 && item.h > 0)) continue;
+		const turned = p.turn === 90;
+		boxes.push({
+			x: p.x,
+			y: p.y,
+			w: turned ? item.h : item.w,
+			h: turned ? item.w : item.h,
+			rank: item.rank ?? index
+		});
+	}
+	return boxes;
+}
+/**
+* This function tells if box `a` comes before box `b` in the reading order. Two boxes whose heights overlap by more than
+* `RECORD_EPS` are on one line, and the left box comes first. Otherwise the upper box comes first.
+*/
+function readsBefore(a, b) {
+	if (Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y) > .001) return a.x + RECORD_EPS < b.x;
+	return a.y < b.y;
+}
+/** This function sums one measure over the stages of a trace. A trace without the measure gives 0. */
+function traceSum(output, id) {
+	let sum = 0;
+	for (const stage of output.trace) sum += stage.measures[id] ?? 0;
+	return sum;
+}
+/**
+* This function gives the measures of one layout, by the ids of `docs/MEASURES.md`. The values are not rounded. A
+* record rounds them with `roundMeasures`.
+*
+* - The boxes are the placed items with a width and a height above 0. The hull is the smallest rectangle around them.
+* - An empty layout gives the area 0, the aspect 1 and the aspect error 0. Its fill is 0 and its whitespace is 1.
+* - The time `pack.search.ms` comes from the trace. It is not part of the determinism rule.
+*
+* @example
+* ```ts
+* const m = measure(input, packWith("shelf", input));
+* m["pack.fill"]; // the area of the boxes divided by the area of the hull
+* ```
+*/
+function measure(input, output, options = {}) {
+	const boxes = boxesOf$1(input, output);
+	const hull = hullOf(boxes);
+	const hullArea = hull.w * hull.h;
+	const boxArea = boxes.reduce((sum, b) => sum + b.w * b.h, 0);
+	const fill = hullArea > 0 ? boxArea / hullArea : 0;
+	const empty = boxes.length === 0;
+	const target = input.container.aspect ?? 1;
+	let pairs = 0;
+	let inversions = 0;
+	for (let i = 0; i < boxes.length; i++) for (let j = i + 1; j < boxes.length; j++) {
+		const a = boxes[i];
+		const b = boxes[j];
+		if (a.rank === b.rank) continue;
+		pairs += 1;
+		const first = a.rank < b.rank ? a : b;
+		if (readsBefore(first === a ? b : a, first)) inversions += 1;
+	}
+	const byRank = boxes.toSorted((a, b) => a.rank - b.rank);
+	let breaks = 0;
+	for (let k = 1; k < byRank.length; k++) {
+		const prev = byRank[k - 1];
+		const next = byRank[k];
+		if (prev.rank !== next.rank && readsBefore(next, prev)) breaks += 1;
+	}
+	const rights = rowsOf$1(boxes, options.rowTolerance ?? quantileOrZero(boxes.map((b) => b.h), .5) / 2).map((r) => r.right);
+	const spread = rights.length > 0 ? Math.max(...rights) - Math.min(...rights) : 0;
+	return {
+		"pack.area": hullArea,
+		"pack.fill": fill,
+		"pack.whitespace": 1 - fill,
+		"pack.aspect": empty ? 1 : Math.max(hull.w / hull.h, hull.h / hull.w),
+		"pack.aspectError": empty ? 0 : aspectError(hull.w, hull.h, target),
+		"pack.order.inversions": pairs > 0 ? inversions / pairs : 0,
+		"pack.order.breaks": breaks,
+		"pack.raggedness": hull.w > 0 ? spread / hull.w : 0,
+		"pack.overflow": new Set(output.overflow).size,
+		"pack.search.widths": traceSum(output, "pack.search.widths"),
+		"pack.search.ms": traceSum(output, "pack.search.ms")
+	};
+}
+/**
+* This function gives the stability measures of a change pair: the run on the base input and the run on the changed
+* input. The items match by id. The values are not rounded.
+*
+* - An item stays when both inputs have it and both outputs place it. The added and the removed items do not count.
+* - A staying item moved when its `x` or its `y` changed by more than `RECORD_EPS`, or when its turn changed.
+* - The distance of an item is the length of the move of its top-left corner. The unit is the width `W`.
+* - `W` is the larger width of the 2 output sizes. A `W` of 0 becomes 1, so the unit is then the unit of the input.
+* - No staying item gives 0 for each measure.
+*/
+function measureChange(baseInput, baseOutput, changeInput, changeOutput) {
+	const placed = (input, output) => {
+		const ids = new Set(input.items.map((i) => i.id));
+		const map = /* @__PURE__ */ new Map();
+		for (const p of output.placements) if (ids.has(p.id) && !map.has(p.id)) map.set(p.id, p);
+		return map;
+	};
+	const before = placed(baseInput, baseOutput);
+	const after = placed(changeInput, changeOutput);
+	const width = Math.max(baseOutput.size.w, changeOutput.size.w);
+	const unit = width > 0 ? width : 1;
+	const distances = [];
+	let moved = 0;
+	for (const [id, p] of before) {
+		const q = after.get(id);
+		if (q === void 0) continue;
+		const dx = q.x - p.x;
+		const dy = q.y - p.y;
+		if (Math.abs(dx) > .001 || Math.abs(dy) > .001 || (p.turn ?? 0) !== (q.turn ?? 0)) moved += 1;
+		distances.push(Math.hypot(dx, dy) / unit);
+	}
+	if (distances.length === 0) return {
+		"pack.stability.moved": 0,
+		"pack.stability.mean": 0,
+		"pack.stability.q95": 0
+	};
+	return {
+		"pack.stability.moved": moved / distances.length,
+		"pack.stability.mean": distances.reduce((sum, d) => sum + d, 0) / distances.length,
+		"pack.stability.q95": quantile(distances, .95)
+	};
+}
+/**
+* This function gives the measure `pack.deterministic` of two runs with the same input, options and seed. It gives
+* `true` when the runs have the same placements, overflow, size and moved obstacles.
+*
+* - The placements match by id, so their order in the list does not count. The numbers must be equal.
+* - The trace is not part of the rule, because its times change each time.
+*/
+function isDeterministic(first, second) {
+	const key = (list) => new Map(list.map((e) => [e.id, e]));
+	const samePlacements = (a, b) => {
+		if (a.length !== b.length) return false;
+		const other = key(b);
+		return a.every((p) => {
+			const q = other.get(p.id);
+			return q !== void 0 && q.x === p.x && q.y === p.y && (q.turn ?? 0) === (p.turn ?? 0);
+		});
+	};
+	const sameMoved = (a, b) => {
+		if (a.length !== b.length) return false;
+		const other = key(b);
+		return a.every((m) => {
+			const n = other.get(m.id);
+			return n !== void 0 && n.x === m.x && n.y === m.y;
+		});
+	};
+	const overflowA = new Set(first.overflow);
+	const overflowB = new Set(second.overflow);
+	return first.size.w === second.size.w && first.size.h === second.size.h && overflowA.size === overflowB.size && [...overflowA].every((id) => overflowB.has(id)) && samePlacements(first.placements, second.placements) && sameMoved(first.moved, second.moved);
+}
+/**
+* This function rounds each number of a record of measures with `round3`, as `docs/FORMAT.md` tells. A half goes up,
+* and `-0` becomes 0. The function keeps the other values, and it does not change its argument.
+*/
+function roundMeasures(measures) {
+	const out = {};
+	for (const [id, value] of Object.entries(measures)) out[id] = typeof value === "number" ? round3(value) : value;
+	return out;
+}
+/**
+* This function gives the paired ratio of a measure on one input: the value of the candidate against the value of the
+* current default. A ratio above 1 is worse, in the direction of the measure.
+*
+* - For `lower`, the ratio is `candidate / current`. For `higher`, it is `current / candidate`.
+* - When both values are 0, the ratio is 1. When only the divisor is 0, the ratio is `Infinity`.
+* - The values are 0 or more. A negative value or `NaN` throws a `RangeError`.
+*/
+function pairedRatio(candidate, current, direction) {
+	if (!(candidate >= 0 && current >= 0)) throw new RangeError("A paired ratio needs two values of 0 or more.");
+	const top = direction === "lower" ? candidate : current;
+	const bottom = direction === "lower" ? current : candidate;
+	if (bottom === 0) return top === 0 ? 1 : Infinity;
+	return top / bottom;
+}
+/**
+* This function gives the quantile `q` of a list of numbers, with linear interpolation between the sorted values. The
+* position in the sorted list is `(n - 1) * q`. An empty list or a `q` outside 0 to 1 throws a `RangeError`.
+*/
+function quantile(values, q) {
+	if (values.length === 0) throw new RangeError("A quantile needs one value or more.");
+	if (!(q >= 0 && q <= 1)) throw new RangeError("A quantile needs a q from 0 to 1.");
+	const sorted = values.toSorted((a, b) => a - b);
+	const at = (sorted.length - 1) * q;
+	const low = Math.floor(at);
+	const part = at - low;
+	const a = sorted[low];
+	if (part === 0) return a;
+	const b = sorted[low + 1];
+	if (a === b) return a;
+	return a + part * (b - a);
+}
+/** This function gives the quantile `q` of a list, and 0 for an empty list. */
+function quantileOrZero(values, q) {
+	return values.length === 0 ? 0 : quantile(values, q);
+}
+/** This function gives the median of the paired ratios of a corpus: the quantile 0.5. It is not a ratio of two medians. */
+function medianRatio(ratios) {
+	return quantile(ratios, .5);
+}
+/** This function gives the share of the paired ratios above a limit. An empty list throws a `RangeError`. */
+function tailShare(ratios, limit) {
+	if (ratios.length === 0) throw new RangeError("A tail share needs one ratio or more.");
+	return ratios.filter((r) => r > limit).length / ratios.length;
+}
+// src/metrics.ts
+/**
+* This function measures a packing. It gives the hull and its aspect, the rows and the raggedness of the right side.
+* It also gives the part of the hull that the rectangles cover, and the widest rectangle against the median width.
+*
+* @example
+* ```ts
+* const { utilization, raggedness } = packingMetrics(Rect.packed(cards));
+* ```
+*/
+function packingMetrics(rects, options = {}) {
+	const tolerance = options.rowTolerance ?? 40;
+	const boxes = rects.filter((r) => r.size.x > 0 && r.size.y > 0).map((r) => ({
+		x: r.position.x,
+		y: r.position.y,
+		w: r.size.x,
+		h: r.size.y
+	}));
+	if (boxes.length === 0) return {
+		count: 0,
+		hull: {
+			width: 0,
+			height: 0
+		},
+		hullAspect: 0,
+		rows: [],
+		raggedness: 0,
+		utilization: 0,
+		widestOverMedian: 0
+	};
+	const box = hullOf(boxes);
+	const hull = {
+		width: box.w,
+		height: box.h
+	};
+	const rows = rowsOf$1(boxes, tolerance);
+	const rights = rows.map((row) => row.right);
+	const widths = boxes.map((r) => r.w).toSorted((a, b) => a - b);
+	const median = widths[Math.floor(widths.length / 2)] ?? 0;
+	const widest = widths.at(-1) ?? 0;
+	const area = boxes.reduce((sum, r) => sum + r.w * r.h, 0);
+	return {
+		count: boxes.length,
+		hull,
+		hullAspect: hull.height > 0 ? hull.width / hull.height : 0,
+		rows: rows.map((row) => row.count),
+		raggedness: Math.max(...rights) - Math.min(...rights),
+		utilization: hull.width * hull.height > 0 ? area / (hull.width * hull.height) : 0,
+		widestOverMedian: median > 0 ? widest / median : 0
+	};
+}
 // src/strategy.ts
 /**
 * The error of a strategy for an input outside its cells. The benchmark records this result. It is not a failure of the
@@ -824,7 +1299,7 @@ function isConvex(points) {
 	return true;
 }
 /** This function gives the value of `containerShape` of one region. */
-function shapeOf(region) {
+function shapeOf$1(region) {
 	switch (region.kind) {
 		case "rect":
 		case "circle":
@@ -862,7 +1337,7 @@ function cellOf(input) {
 		height: "freeWidth",
 		none: container.aspectWeight === 0 ? "freeArea" : "freeAspect"
 	}[container.fixed];
-	let containerShape = container.shape ? shapeOf(container.shape) : "rect";
+	let containerShape = container.shape ? shapeOf$1(container.shape) : "rect";
 	if (containerShape === "rect" && obstacles.some((o) => o.region.kind !== "rect")) containerShape = "holes";
 	let obstacleMove = items.some((i) => i.locked === true) ? "fixed" : void 0;
 	for (const o of obstacles) {
@@ -1642,6 +2117,918 @@ function checkHard(input, output, tolerance = DEFAULT_TOLERANCE) {
 	}
 	return breaks;
 }
-export { DEFAULT_TOLERANCE, EPS, RECORD_EPS, Rect, SORT_ORDERS, UnsupportedCell, Vector, aspectError, assertSupported, cellOf, checkHard, compareRects, createContext, fromRects, logSweep, lowestWindow, marginOf, mulberry32, pack, packFree, packRows, packShelf, packSkyline, packWith, packingMetrics, push, pushCascade, rows, shelf, skyline, strategies, strategy, supportsCell, toRects, turnItem, turnPoint, turnPort, turnRegion, unsupportedOf };
+// src/generators.ts
+/** The largest count of boxes that a generator makes. */
+const MAX_COUNT = 1e5;
+/** This function gives the random numbers of one step of a seed. */
+const stepRandom = (seed, step) => mulberry32(fnv1a32(`${seed}:${step}`));
+/** A whole number from lo to hi, both included. */
+const int = (r, lo, hi) => lo + Math.floor(r() * (hi - lo + 1));
+/** A whole number from the floor of lo to the floor of hi, both included. The upper end is not less than the lower end at any time. */
+const span = (r, lo, hi) => {
+	const a = Math.floor(lo);
+	return int(r, a, Math.max(a, Math.floor(hi)));
+};
+/** A number from lo to hi. */
+const between = (r, lo, hi) => lo + r() * (hi - lo);
+/** This function gives an index with a probability in proportion to its weight. */
+const pick = (r, weights) => {
+	let x = r() * weights.reduce((a, b) => a + b, 0);
+	for (const [i, w] of weights.entries()) {
+		x -= w;
+		if (x < 0) return i;
+	}
+	return weights.length - 1;
+};
+/** This function gives a copy of a value with each number rounded by `round3`. A key with the value `undefined` goes. */
+function roundNumbers(value) {
+	if (typeof value === "number") return round3(value);
+	if (Array.isArray(value)) return value.map(roundNumbers);
+	if (value !== null && typeof value === "object") {
+		const out = {};
+		for (const [k, v] of Object.entries(value)) if (v !== void 0) out[k] = roundNumbers(v);
+		return out;
+	}
+	return value;
+}
+/** This function gives the cell of an input with rectangle items, no rotation, no order and no groups. */
+function cellWith(containerSize, containerShape, obstacles, sizes, count, locked = false) {
+	const cell = {
+		containerSize,
+		containerShape,
+		itemShape: "rect",
+		rotation: "none",
+		order: "free",
+		groups: "none",
+		obstacles,
+		sizes,
+		count: countCell(count),
+		mode: "offline"
+	};
+	if (obstacles !== "none" || locked) cell.obstacleMove = "fixed";
+	return cell;
+}
+/** This function makes a generator from its data. It adds the defaults, the checks, the stamp, the rounding and the hash. */
+function defineGenerator(spec) {
+	const withDefaults = (params = {}) => {
+		const full = { ...spec.defaults };
+		for (const [key, value] of Object.entries(params)) {
+			if (value === void 0) continue;
+			if (!(key in spec.defaults)) throw new RangeError(`The generator "${spec.name}" has no parameter "${key}".`);
+			full[key] = value;
+		}
+		for (const [key, allowed] of Object.entries(spec.values)) if (allowed !== void 0 && !allowed.includes(full[key])) throw new RangeError(`The parameter "${key}" of the generator "${spec.name}" has no value "${String(full[key])}".`);
+		const count = full["count"];
+		if (count !== void 0 && (typeof count !== "number" || !Number.isInteger(count) || count < 0 || count > MAX_COUNT)) throw new RangeError(`The parameter "count" of the generator "${spec.name}" is a whole number from 0 to ${MAX_COUNT}.`);
+		return full;
+	};
+	return Object.freeze({
+		name: spec.name,
+		version: spec.version,
+		set: spec.set,
+		defaults: Object.freeze({ ...spec.defaults }),
+		values: spec.values,
+		withDefaults,
+		cell: (params) => spec.cell(withDefaults(params)),
+		generate(seed, params, set = spec.set) {
+			if (!Number.isInteger(seed) || seed < 0) throw new RangeError(`The seed is a whole number from 0. It is ${seed}.`);
+			const full = withDefaults(params);
+			const family = spec.family(full);
+			const { container, obstacles, boxes } = spec.build(seed, full);
+			const file = roundNumbers({
+				schema: "layout-input/1",
+				id: `${set}/${family}/s${seed}`,
+				set,
+				family,
+				seed,
+				source: "made-up",
+				generator: {
+					name: spec.name,
+					version: spec.version,
+					params: full,
+					seed
+				},
+				container,
+				obstacles,
+				boxes,
+				edges: []
+			});
+			return {
+				...file,
+				hash: hashInput(file)
+			};
+		}
+	});
+}
+/** The shared generator `rect-scattered` of `docs/FORMAT.md`, version 1: rectangle obstacles at random places in a fixed rectangle. */
+const rectScattered = defineGenerator({
+	name: "rect-scattered",
+	version: 1,
+	set: "xcheck-v1",
+	defaults: { count: 40 },
+	values: {},
+	family: () => "rect-scattered",
+	cell: (p) => cellWith("fixed", "rect", "scattered", "uniform", p.count),
+	build(seed, { count }) {
+		let r = stepRandom(seed, "container");
+		const w = int(r, 600, 1e3);
+		const h = int(r, 400, 800);
+		const container = {
+			w,
+			h,
+			fixed: "size"
+		};
+		r = stepRandom(seed, "obstacles");
+		const n = int(r, 3, 8);
+		const obstacles = [];
+		for (let i = 0; i < n; i++) {
+			const ow = int(r, 40, 160);
+			const oh = int(r, 40, 160);
+			const x = int(r, 0, w - ow);
+			const y = int(r, 0, h - oh);
+			obstacles.push({
+				id: `o${i}`,
+				region: {
+					kind: "rect",
+					x,
+					y,
+					w: ow,
+					h: oh
+				}
+			});
+		}
+		r = stepRandom(seed, "boxes");
+		const boxes = [];
+		for (let i = 0; i < count; i++) {
+			const bw = int(r, 20, 120);
+			const bh = int(r, 20, 80);
+			boxes.push({
+				id: `b${i}`,
+				w: bw,
+				h: bh
+			});
+		}
+		return {
+			container,
+			obstacles,
+			boxes
+		};
+	}
+});
+/** The values of `containerSize` that the generators make. */
+const CONTAINER_SIZES = [
+	"fixed",
+	"freeHeight",
+	"freeWidth",
+	"freeAspect",
+	"freeArea"
+];
+/** The values of `containerShape`. */
+const CONTAINER_SHAPES = [
+	"rect",
+	"convex",
+	"polygon",
+	"circle",
+	"ellipse",
+	"holes"
+];
+/** The values of `obstacles`. */
+const OBSTACLE_LAYOUTS = [
+	"none",
+	"center",
+	"scattered",
+	"wall",
+	"corridors",
+	"touching",
+	"edge"
+];
+/** The values of `sizes`. */
+const SIZE_DISTRIBUTIONS = [
+	"identical",
+	"nearIdentical",
+	"uniform",
+	"heavyTail",
+	"bimodal",
+	"extremeAspect"
+];
+/** This function gives the container of a size value for the nominal rectangle `w` by `h`, with an optional shape. */
+function containerOf(size, w, h, shape) {
+	const container = {
+		fixed: {
+			w,
+			h,
+			fixed: "size"
+		},
+		freeHeight: {
+			w,
+			fixed: "width"
+		},
+		freeWidth: {
+			h,
+			fixed: "height"
+		},
+		freeAspect: {
+			fixed: "none",
+			aspect: round3(w / h)
+		},
+		freeArea: {
+			fixed: "none",
+			aspectWeight: 0
+		}
+	}[size];
+	if (shape !== void 0) container.shape = shape;
+	return container;
+}
+/** This function gives the 4 corners of a rectangle, clockwise from the top left. */
+const corners = (x, y, w, h) => [
+	[x, y],
+	[x + w, y],
+	[x + w, y + h],
+	[x, y + h]
+];
+/**
+* This function gives the shape of a container in the rectangle `w` by `h`, and its frame. The frame is a rectangle in
+* the shape. The obstacles and the sizes of the boxes come from the frame.
+*/
+function shapeOf(r, shape, w, h) {
+	const m = Math.min(w, h);
+	switch (shape) {
+		case "rect": return { frame: {
+			x: 0,
+			y: 0,
+			w,
+			h
+		} };
+		case "convex": {
+			const [a, b, c, d] = [
+				0,
+				1,
+				2,
+				3
+			].map(() => span(r, m * .1, m * .25));
+			const points = [
+				[a, 0],
+				[w - b, 0],
+				[w, b],
+				[w, h - c],
+				[w - c, h],
+				[d, h],
+				[0, h - d],
+				[0, a]
+			];
+			const top = Math.max(a, b);
+			const bottom = Math.max(c, d);
+			return {
+				region: {
+					kind: "polygon",
+					points
+				},
+				frame: {
+					x: 0,
+					y: top,
+					w,
+					h: h - top - bottom
+				}
+			};
+		}
+		case "polygon": {
+			const nw = span(r, w * .25, w * .45);
+			const nh = span(r, h * .25, h * .45);
+			return {
+				region: {
+					kind: "polygon",
+					points: [
+						[0, 0],
+						[w, 0],
+						[w, h - nh],
+						[w - nw, h - nh],
+						[w - nw, h],
+						[0, h]
+					]
+				},
+				frame: {
+					x: 0,
+					y: 0,
+					w: w - nw,
+					h
+				}
+			};
+		}
+		case "circle": {
+			const cx = Math.floor(w / 2);
+			const cy = Math.floor(h / 2);
+			const radius = Math.min(cx, cy);
+			const side = 2 * Math.floor((radius * Math.SQRT2 - 1) / 2);
+			return {
+				region: {
+					kind: "circle",
+					cx,
+					cy,
+					r: radius
+				},
+				frame: {
+					x: cx - side / 2,
+					y: cy - side / 2,
+					w: side,
+					h: side
+				}
+			};
+		}
+		case "ellipse": {
+			const rx = Math.floor(w / 2);
+			const ry = Math.floor(h / 2);
+			const a = Math.floor(rx / Math.SQRT2);
+			const b = Math.floor(ry / Math.SQRT2);
+			return {
+				region: {
+					kind: "ellipse",
+					cx: rx,
+					cy: ry,
+					rx,
+					ry
+				},
+				frame: {
+					x: rx - a,
+					y: ry - b,
+					w: 2 * a,
+					h: 2 * b
+				}
+			};
+		}
+		case "holes": {
+			const count = int(r, 1, 2);
+			const holes = [];
+			for (let i = 0; i < count; i++) {
+				const hw = span(r, w * .08, w * .15);
+				const hh = span(r, h * .1, h * .25);
+				const x = i === 0 ? span(r, 20, w / 2 - hw - 10) : span(r, w / 2 + 10, w - hw - 20);
+				const y = span(r, 20, h - hh - 20);
+				holes.push(corners(x, y, hw, hh));
+			}
+			return {
+				region: {
+					kind: "polygon",
+					points: corners(0, 0, w, h),
+					holes
+				},
+				frame: {
+					x: 0,
+					y: 0,
+					w,
+					h
+				}
+			};
+		}
+	}
+}
+/** This function gives the obstacles of a layout in a frame. Each obstacle is a rectangle with whole-number sides. */
+function obstaclesOf(r, layout, f) {
+	const m = Math.min(f.w, f.h);
+	const rects = [];
+	switch (layout) {
+		case "none": break;
+		case "center": {
+			const w = span(r, f.w * .15, f.w * .3);
+			const h = span(r, f.h * .15, f.h * .3);
+			const jx = Math.floor(f.w * .05);
+			const jy = Math.floor(f.h * .05);
+			rects.push({
+				x: f.x + Math.floor((f.w - w) / 2) + int(r, -jx, jx),
+				y: f.y + Math.floor((f.h - h) / 2) + int(r, -jy, jy),
+				w,
+				h
+			});
+			break;
+		}
+		case "scattered": {
+			const n = int(r, 3, 8);
+			for (let i = 0; i < n; i++) {
+				const w = span(r, m * .05, m * .2);
+				const h = span(r, m * .05, m * .2);
+				rects.push({
+					x: int(r, f.x, f.x + f.w - w),
+					y: int(r, f.y, f.y + f.h - h),
+					w,
+					h
+				});
+			}
+			break;
+		}
+		case "wall": {
+			const vertical = r() < .5;
+			const across = vertical ? f.w : f.h;
+			const along = vertical ? f.h : f.w;
+			const thick = span(r, Math.max(1, across * .03), Math.max(1, across * .06));
+			const length = span(r, along * .7, along * .85);
+			const at = span(r, across * .3, across * .7 - thick);
+			const from = r() < .5 ? 0 : along - length;
+			rects.push(vertical ? {
+				x: f.x + at,
+				y: f.y + from,
+				w: thick,
+				h: length
+			} : {
+				x: f.x + from,
+				y: f.y + at,
+				w: length,
+				h: thick
+			});
+			break;
+		}
+		case "corridors": {
+			const cols = int(r, 2, 4);
+			const rows = int(r, 2, 3);
+			const path = span(r, m * .08, m * .15);
+			const bw = Math.floor((f.w - (cols + 1) * path) / cols);
+			const bh = Math.floor((f.h - (rows + 1) * path) / rows);
+			for (let j = 0; j < rows; j++) for (let i = 0; i < cols; i++) rects.push({
+				x: f.x + path + i * (bw + path),
+				y: f.y + path + j * (bh + path),
+				w: bw,
+				h: bh
+			});
+			break;
+		}
+		case "touching": {
+			const n = int(r, 2, 4);
+			let w = span(r, m * .08, m * .15);
+			let h = span(r, m * .08, m * .15);
+			let x = span(r, f.x + f.w * .15, f.x + f.w * .35);
+			let y = span(r, f.y + f.h * .15, f.y + f.h * .35);
+			rects.push({
+				x,
+				y,
+				w,
+				h
+			});
+			for (let i = 1; i < n; i++) {
+				const right = r() < .5;
+				const nw = span(r, m * .08, m * .15);
+				const nh = span(r, m * .08, m * .15);
+				if (right) {
+					y = int(r, y, y + Math.floor(h / 2));
+					x += w;
+				} else {
+					x = int(r, x, x + Math.floor(w / 2));
+					y += h;
+				}
+				w = nw;
+				h = nh;
+				rects.push({
+					x,
+					y,
+					w,
+					h
+				});
+			}
+			break;
+		}
+		case "edge": {
+			const n = int(r, 2, 5);
+			for (let i = 0; i < n; i++) {
+				const side = int(r, 0, 3);
+				const w = span(r, m * .06, m * .15);
+				const h = span(r, m * .06, m * .15);
+				const x = side === 1 ? f.x + f.w - w : side === 3 ? f.x : int(r, f.x, f.x + f.w - w);
+				const y = side === 0 ? f.y : side === 2 ? f.y + f.h - h : int(r, f.y, f.y + f.h - h);
+				rects.push({
+					x,
+					y,
+					w,
+					h
+				});
+			}
+			break;
+		}
+	}
+	return rects.map((rect, i) => ({
+		id: `o${i}`,
+		region: {
+			kind: "rect",
+			...rect
+		}
+	}));
+}
+/**
+* This function gives the boxes of a size distribution for a frame. The mean box has an area of 40 percent of the
+* frame divided by the count. No box is wider or higher than the frame.
+*/
+function boxesOf(r, sizes, count, f) {
+	const unit = Math.sqrt(f.w * f.h * .4 / Math.max(count, 1));
+	const fit = (x, max) => Math.min(Math.max(round3(x), .01), max);
+	const boxes = new Array(count);
+	const put = (i, w, h) => {
+		boxes[i] = {
+			id: `b${i}`,
+			w: fit(w, f.w),
+			h: fit(h, f.h)
+		};
+	};
+	switch (sizes) {
+		case "identical":
+		case "nearIdentical": {
+			const aspect = Math.sqrt(between(r, .6, 1.6));
+			const bw = unit * aspect;
+			const bh = unit / aspect;
+			for (let i = 0; i < count; i++) if (sizes === "identical") put(i, bw, bh);
+			else put(i, bw * (1 + between(r, -.03, .03)), bh * (1 + between(r, -.03, .03)));
+			break;
+		}
+		case "uniform":
+			for (let i = 0; i < count; i++) put(i, unit * between(r, .5, 1.5), unit * between(r, .5, 1.5));
+			break;
+		case "heavyTail": {
+			const cap = .6 * Math.min(f.w, f.h);
+			for (let i = 0; i < count; i++) {
+				const s = Math.min(.6 * unit * (1 - r()) ** (-1 / 1.6), cap);
+				put(i, s * between(r, .75, 1.33), s * between(r, .75, 1.33));
+			}
+			break;
+		}
+		case "bimodal":
+			for (let i = 0; i < count; i++) {
+				const s = r() < .25 ? 1.8 * unit : .6 * unit;
+				put(i, s * between(r, .85, 1.15), s * between(r, .85, 1.15));
+			}
+			break;
+		case "extremeAspect": for (let i = 0; i < count; i++) {
+			const long = unit * between(r, 2.5, 4);
+			const short = unit * between(r, .15, .35);
+			if (r() < .5) put(i, long, short);
+			else put(i, short, long);
+		}
+	}
+	return boxes;
+}
+/**
+* The generator `rect-grid`, version 1: rectangle boxes for each value of `containerSize`, `containerShape`, `obstacles`
+* and `sizes`, with each count. The container is a nominal rectangle of 600 to 1000 by 400 to 800.
+*/
+const rectGrid = defineGenerator({
+	name: "rect-grid",
+	version: 1,
+	set: "corpus-v1",
+	defaults: {
+		containerSize: "fixed",
+		containerShape: "rect",
+		obstacles: "none",
+		sizes: "uniform",
+		count: 100
+	},
+	values: {
+		containerSize: CONTAINER_SIZES,
+		containerShape: CONTAINER_SHAPES,
+		obstacles: OBSTACLE_LAYOUTS,
+		sizes: SIZE_DISTRIBUTIONS
+	},
+	family: (p) => `rect-grid.${p.containerSize}.${p.containerShape}.${p.obstacles}.${p.sizes}.n${p.count}`,
+	cell: (p) => cellWith(p.containerSize, p.containerShape, p.obstacles, p.sizes, p.count),
+	build(seed, p) {
+		let r = stepRandom(seed, "container");
+		const w = int(r, 600, 1e3);
+		const h = int(r, 400, 800);
+		const { region, frame } = shapeOf(r, p.containerShape, w, h);
+		const container = containerOf(p.containerSize, w, h, region);
+		r = stepRandom(seed, "obstacles");
+		const obstacles = obstaclesOf(r, p.obstacles, frame);
+		r = stepRandom(seed, "boxes");
+		return {
+			container,
+			obstacles,
+			boxes: boxesOf(r, p.sizes, p.count, frame)
+		};
+	}
+});
+/** This function makes the generator of a family of a user interface. The container is 800 to 1400 by 600 to 1000, with no obstacle. */
+function uiGenerator(name, sizes, count, boxes) {
+	return defineGenerator({
+		name,
+		version: 1,
+		set: "corpus-v1",
+		defaults: {
+			containerSize: "freeHeight",
+			count
+		},
+		values: { containerSize: CONTAINER_SIZES },
+		family: (p) => `${name}.${p.containerSize}.n${p.count}`,
+		cell: (p) => cellWith(p.containerSize, "rect", "none", sizes, p.count),
+		build(seed, p) {
+			const r = stepRandom(seed, "container");
+			const w = int(r, 800, 1400);
+			const h = int(r, 600, 1e3);
+			return {
+				container: containerOf(p.containerSize, w, h),
+				obstacles: [],
+				boxes: boxes(stepRandom(seed, "boxes"), p.count)
+			};
+		}
+	});
+}
+/** The aspects of the thumbnails of a gallery. */
+const THUMBNAIL_ASPECTS = [
+	1,
+	4 / 3,
+	3 / 2,
+	16 / 9
+];
+/** The generator `gallery`, version 1: thumbnails with one size and one aspect (1, 4:3, 3:2 or 16:9). The default container has a fixed width. */
+const gallery = uiGenerator("gallery", "identical", 100, (r, count) => {
+	const aspect = THUMBNAIL_ASPECTS[int(r, 0, THUMBNAIL_ASPECTS.length - 1)];
+	const w = int(r, 120, 240);
+	return Array.from({ length: count }, (_, i) => ({
+		id: `b${i}`,
+		w,
+		h: round3(w / aspect)
+	}));
+});
+/** The spans of the dashboard tiles in grid units, and their weights. */
+const TILE_SPANS = [
+	[1, 1],
+	[2, 1],
+	[1, 2],
+	[2, 2],
+	[3, 2],
+	[4, 2]
+];
+const TILE_WEIGHTS = [
+	4,
+	3,
+	2,
+	3,
+	1,
+	1
+];
+/** The generator `dashboard`, version 1: tiles in 6 standard sizes, from 1 by 1 to 4 by 2 grid units of 60 to 100. */
+const dashboard = uiGenerator("dashboard", "bimodal", 10, (r, count) => {
+	const unit = int(r, 60, 100);
+	return Array.from({ length: count }, (_, i) => {
+		const [cw, ch] = TILE_SPANS[pick(r, TILE_WEIGHTS)];
+		return {
+			id: `b${i}`,
+			w: cw * unit,
+			h: ch * unit
+		};
+	});
+});
+/** The generator `cards`, version 1: cards with one width from 200 to 320, and a height from 120 to 420 each. */
+const cards = uiGenerator("cards", "uniform", 100, (r, count) => {
+	const w = int(r, 200, 320);
+	return Array.from({ length: count }, (_, i) => ({
+		id: `b${i}`,
+		w,
+		h: int(r, 120, 420)
+	}));
+});
+/** The font sizes of a word cloud, and their weights: many small words and few large words. */
+const FONT_SIZES = [
+	12,
+	14,
+	16,
+	20,
+	28,
+	40
+];
+const FONT_WEIGHTS = [
+	30,
+	25,
+	20,
+	12,
+	8,
+	5
+];
+/** The generator `word-cloud`, version 1: boxes of text. The height comes from 6 font sizes, the width from 3 to 12 letters. */
+const wordCloud = uiGenerator("word-cloud", "heavyTail", 100, (r, count) => Array.from({ length: count }, (_, i) => {
+	const font = FONT_SIZES[pick(r, FONT_WEIGHTS)];
+	const letters = int(r, 3, 12);
+	return {
+		id: `b${i}`,
+		w: round3(letters * font * .6),
+		h: round3(font * 1.25)
+	};
+}));
+/** The values of `case`. */
+const EDGE_CASES = [
+	"empty",
+	"one",
+	"oversize",
+	"exactTiling",
+	"touchObstacles"
+];
+/** This function gives the largest divisor of `n` that is not more than the square root of `n`. */
+const rowsOf = (n) => {
+	for (let d = Math.floor(Math.sqrt(n)); d > 1; d--) if (n % d === 0) return d;
+	return 1;
+};
+/**
+* The generator `edge-cases`, version 1. Each case has a fixed rectangle container.
+*
+* - `empty`: no box.
+* - `one`: one box.
+* - `oversize`: `count` boxes. One box is wider than the container.
+* - `exactTiling`: `count` identical boxes that fill the container with no free space.
+* - `touchObstacles`: a locked box on the top of an obstacle, and boxes as wide as the path between 2 obstacles.
+*/
+const edgeCases = defineGenerator({
+	name: "edge-cases",
+	version: 1,
+	set: "corpus-v1",
+	defaults: {
+		case: "oversize",
+		count: 12
+	},
+	values: { case: EDGE_CASES },
+	family: (p) => p.case === "empty" || p.case === "one" ? `edge-cases.${p.case}` : `edge-cases.${p.case}.n${p.count}`,
+	cell: (p) => {
+		switch (p.case) {
+			case "empty": return cellWith("fixed", "rect", "none", "identical", 0);
+			case "one": return cellWith("fixed", "rect", "none", "identical", 1);
+			case "oversize": return cellWith("fixed", "rect", "none", "heavyTail", p.count);
+			case "exactTiling": return cellWith("fixed", "rect", "none", "identical", p.count);
+			case "touchObstacles": return cellWith("fixed", "rect", "corridors", "uniform", p.count, true);
+		}
+	},
+	build(seed, p) {
+		if ((p.case === "oversize" || p.case === "exactTiling" || p.case === "touchObstacles") && p.count < 1) throw new RangeError(`The case "${p.case}" of "edge-cases" needs a count of 1 or more.`);
+		let r = stepRandom(seed, "container");
+		let w;
+		let h;
+		let tile = {
+			w: 0,
+			h: 0,
+			cols: 0,
+			rows: 0
+		};
+		if (p.case === "exactTiling") {
+			const rows = rowsOf(p.count);
+			tile = {
+				w: int(r, 40, 120),
+				h: int(r, 30, 90),
+				cols: p.count / rows,
+				rows
+			};
+			w = tile.cols * tile.w;
+			h = tile.rows * tile.h;
+		} else {
+			w = int(r, 600, 1e3);
+			h = int(r, 400, 800);
+		}
+		const container = {
+			w,
+			h,
+			fixed: "size"
+		};
+		r = stepRandom(seed, "obstacles");
+		const obstacles = [];
+		let path = 0;
+		let first = {
+			x: 0,
+			y: 0
+		};
+		if (p.case === "touchObstacles") {
+			path = int(r, 40, 100);
+			const ow = int(r, 60, 150);
+			const oh = int(r, 100, 200);
+			first = {
+				x: span(r, w * .1, w * .25),
+				y: span(r, h * .2, h * .4)
+			};
+			obstacles.push({
+				id: "o0",
+				region: {
+					kind: "rect",
+					x: first.x,
+					y: first.y,
+					w: ow,
+					h: oh
+				}
+			});
+			obstacles.push({
+				id: "o1",
+				region: {
+					kind: "rect",
+					x: first.x + ow + path,
+					y: first.y,
+					w: int(r, 60, 150),
+					h: oh
+				}
+			});
+		}
+		r = stepRandom(seed, "boxes");
+		const boxes = [];
+		switch (p.case) {
+			case "empty": break;
+			case "one":
+				boxes.push({
+					id: "b0",
+					w: int(r, 40, 200),
+					h: int(r, 30, 150)
+				});
+				break;
+			case "oversize": {
+				const big = int(r, 0, p.count - 1);
+				for (let i = 0; i < p.count; i++) if (i === big) boxes.push({
+					id: `b${i}`,
+					w: w + int(r, 10, 200),
+					h: int(r, 40, 100)
+				});
+				else boxes.push({
+					id: `b${i}`,
+					w: int(r, 20, 120),
+					h: int(r, 20, 80)
+				});
+				break;
+			}
+			case "exactTiling":
+				for (let i = 0; i < p.count; i++) boxes.push({
+					id: `b${i}`,
+					w: tile.w,
+					h: tile.h
+				});
+				break;
+			case "touchObstacles": {
+				const lw = int(r, 30, 80);
+				const lh = int(r, 20, 60);
+				boxes.push({
+					id: "b0",
+					w: lw,
+					h: lh,
+					x: first.x,
+					y: first.y - lh,
+					locked: true
+				});
+				for (let i = 1; i < p.count; i++) boxes.push({
+					id: `b${i}`,
+					w: path,
+					h: int(r, 20, 80)
+				});
+				break;
+			}
+		}
+		return {
+			container,
+			obstacles,
+			boxes
+		};
+	}
+});
+/** Each generator of the package. */
+const generators = Object.freeze([
+	rectScattered,
+	rectGrid,
+	gallery,
+	dashboard,
+	cards,
+	wordCloud,
+	edgeCases
+]);
+/** This function gives the generator with a name. It throws a `RangeError` for a name that the package does not have. */
+function generator(name) {
+	const found = generators.find((g) => g.name === name);
+	if (found === void 0) throw new RangeError(`The package has no generator "${name}".`);
+	return found;
+}
+// src/corpus.ts
+/**
+* This function generates a corpus from specs. Each input gets the name of the corpus as its set. The function throws a
+* `RangeError` for an unknown generator, a different version or 2 inputs with the same id.
+*/
+function corpus(name, specs) {
+	const manifest = {
+		schema: "layout-corpus/1",
+		corpus: name,
+		specs: [],
+		inputs: []
+	};
+	const inputs = [];
+	const ids = /* @__PURE__ */ new Set();
+	for (const spec of specs) {
+		const gen = generator(spec.generator);
+		if (spec.version !== void 0 && spec.version !== gen.version) throw new RangeError(`The generator "${gen.name}" has the version ${gen.version}, not ${spec.version}.`);
+		const params = gen.withDefaults(spec.params);
+		const cell = gen.cell(params);
+		manifest.specs.push({
+			generator: gen.name,
+			version: gen.version,
+			params,
+			seeds: [...spec.seeds]
+		});
+		for (const seed of spec.seeds) {
+			const file = gen.generate(seed, params, name);
+			if (ids.has(file.id)) throw new RangeError(`The corpus has 2 inputs with the id "${file.id}".`);
+			ids.add(file.id);
+			inputs.push(file);
+			manifest.inputs.push({
+				id: file.id,
+				hash: file.hash,
+				cell
+			});
+		}
+	}
+	return {
+		manifest,
+		inputs
+	};
+}
+export { DEFAULT_TOLERANCE, EPS, MEASURE_SPECS, RECORD_EPS, Rect, SORT_ORDERS, UnsupportedCell, Vector, aspectError, assertSupported, canonicalJson, cards, cellOf, checkHard, compareRects, corpus, countCell, createContext, dashboard, edgeCases, fnv1a32, fromRects, gallery, generator, generators, hashInput, isDeterministic, logSweep, lowestWindow, marginOf, measure, measureChange, medianRatio, mulberry32, pack, packFree, packRows, packShelf, packSkyline, packWith, packingMetrics, pairedRatio, push, pushCascade, quantile, rectGrid, rectScattered, round3, roundMeasures, rows, shelf, skyline, strategies, strategy, supportsCell, tailShare, toPackInput, toRects, turnItem, turnPoint, turnPort, turnRegion, unsupportedOf, wordCloud };
 
 //# sourceMappingURL=index.js.map