@mark1russell7/packing 0.1.3 → 0.1.4

package/build/index.js

@@ -824,7 +824,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 +862,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 +1642,1115 @@ 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/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/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, 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, logSweep, lowestWindow, marginOf, mulberry32, pack, packFree, packRows, packShelf, packSkyline, packWith, packingMetrics, push, pushCascade, rectGrid, rectScattered, round3, rows, shelf, skyline, strategies, strategy, supportsCell, toPackInput, toRects, turnItem, turnPoint, turnPort, turnRegion, unsupportedOf, wordCloud };
 
 //# sourceMappingURL=index.js.map