@mark1russell7/packing 0.1.2 → 0.1.4

package/build/index.js

@@ -370,7 +370,7 @@ function packRow(rects, outer, order) {
 		if (fillGaps && row.length > 1) {
 			const rectInRow = row[row.length - 1];
 			const outerLeft = new Rect();
-			outerLeft.position.set(rectInRow.position.x, rectInRow.bottom());
+			outerLeft.position.set(rectInRow.position.x - outer.position.x, rectInRow.bottom() - outer.position.y);
 			outerLeft.size.set(rectInRow.size.x, rowRect.size.y - rectInRow.size.y);
 			outerLeft.fixedWidth = true;
 			outerLeft.fixedSize = true;
@@ -658,6 +658,2099 @@ function packingMetrics(rects, options = {}) {
 		widestOverMedian: median > 0 ? widest / median : 0
 	};
 }
-export { Rect, SORT_ORDERS, Vector, aspectError, compareRects, lowestWindow, pack, packFree, packRows, packShelf, packSkyline, packingMetrics, pushCascade };
+// src/contract.ts
+/** The tolerance for the comparison of two numbers in an engine. */
+const EPS = 1e-6;
+/** The tolerance for the comparison of two numbers of a file. The files round to 3 decimals. */
+const RECORD_EPS = .001;
+/** The default tolerances of the hard rules. Each record writes its tolerances in its top-level field `tolerance`. */
+const DEFAULT_TOLERANCE = Object.freeze({
+	overlap: .001,
+	through: .5
+});
+/** This function gives the margin of an item on each side. A number is the same margin on each side. */
+function marginOf(item) {
+	const m = item.margin ?? 0;
+	if (typeof m === "number") return {
+		top: m,
+		right: m,
+		bottom: m,
+		left: m
+	};
+	return {
+		top: m.top,
+		right: m.right,
+		bottom: m.bottom,
+		left: m.left
+	};
+}
+/** The side of a port after a turn of 90 degrees clockwise. */
+const TURNED_SIDE = {
+	top: "right",
+	right: "bottom",
+	bottom: "left",
+	left: "top"
+};
+/** This function gives the point `px`, `py` of an item of height `h` after a turn of 90 degrees clockwise. */
+function turnPoint(px, py, h) {
+	return [h - py, px];
+}
+/** This function turns a port of an item of height `h` by 90 degrees clockwise. The side turns from top to right. */
+function turnPort(port, h) {
+	const turned = {
+		id: port.id,
+		side: TURNED_SIDE[port.side]
+	};
+	if (port.x !== void 0 && port.y !== void 0) {
+		const [x, y] = turnPoint(port.x, port.y, h);
+		turned.x = x;
+		turned.y = y;
+	} else if (port.x !== void 0) turned.y = port.x;
+	else if (port.y !== void 0) turned.x = h - port.y;
+	return turned;
+}
+/** This function turns a region relative to an item of height `h` by 90 degrees clockwise. */
+function turnRegion(region, h) {
+	switch (region.kind) {
+		case "rect": return {
+			kind: "rect",
+			x: h - region.y - region.h,
+			y: region.x,
+			w: region.h,
+			h: region.w
+		};
+		case "circle": {
+			const [cx, cy] = turnPoint(region.cx, region.cy, h);
+			return {
+				kind: "circle",
+				cx,
+				cy,
+				r: region.r
+			};
+		}
+		case "ellipse": {
+			const [cx, cy] = turnPoint(region.cx, region.cy, h);
+			return {
+				kind: "ellipse",
+				cx,
+				cy,
+				rx: region.ry,
+				ry: region.rx
+			};
+		}
+		case "polygon": {
+			const turnRing = (ring) => ring.map(([x, y]) => turnPoint(x, y, h));
+			const turned = {
+				kind: "polygon",
+				points: turnRing(region.points)
+			};
+			if (region.holes) turned.holes = region.holes.map(turnRing);
+			return turned;
+		}
+	}
+}
+/**
+* This function gives an item after a turn of 90 degrees clockwise, with the y axis down (decision 1 of
+* `docs/PACKER.md`). The width and the height change places. The top-left corner, the id and the other fields stay.
+* The ports, the shape and the margin turn with the item. The function does not change its argument.
+*/
+function turnItem(item) {
+	const turned = {
+		...item,
+		w: item.h,
+		h: item.w
+	};
+	if (item.ports) turned.ports = item.ports.map((p) => turnPort(p, item.h));
+	if (item.shape) turned.shape = turnRegion(item.shape, item.h);
+	if (item.margin !== void 0 && typeof item.margin !== "number") {
+		const m = item.margin;
+		turned.margin = {
+			top: m.left,
+			right: m.top,
+			bottom: m.right,
+			left: m.bottom
+		};
+	}
+	return turned;
+}
+// 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
+* strategy.
+*/
+var UnsupportedCell = class extends Error {
+	/** The dimension of the taxonomy. */
+	dimension;
+	/** The value of the input that the strategy does not support. */
+	value;
+	constructor(dimension, value) {
+		super(`The strategy does not support the value "${value}" of the dimension "${dimension}".`);
+		this.name = "UnsupportedCell";
+		this.dimension = dimension;
+		this.value = value;
+	}
+};
+/** This function gives a generator of random numbers in `[0, 1)`: `mulberry32` of `docs/FORMAT.md`. */
+function mulberry32(seed) {
+	let s = seed >>> 0;
+	return () => {
+		s = s + 1831565813 | 0;
+		let t = Math.imul(s ^ s >>> 15, 1 | s);
+		t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/** This function makes the context of one packing from a seed. */
+function createContext(seed = 0, more = {}) {
+	return {
+		...more,
+		seed,
+		rng: mulberry32(seed)
+	};
+}
+/** This function tells if a polygon ring is convex. A ring with fewer than 3 points is convex. */
+function isConvex(points) {
+	let sign = 0;
+	const n = points.length;
+	for (let i = 0; i < n; i++) {
+		const [ax, ay] = points[i];
+		const [bx, by] = points[(i + 1) % n];
+		const [cx, cy] = points[(i + 2) % n];
+		const cross = (bx - ax) * (cy - by) - (by - ay) * (cx - bx);
+		if (cross === 0) continue;
+		if (sign === 0) sign = Math.sign(cross);
+		else if (Math.sign(cross) !== sign) return false;
+	}
+	return true;
+}
+/** This function gives the value of `containerShape` of one region. */
+function shapeOf$1(region) {
+	switch (region.kind) {
+		case "rect":
+		case "circle":
+		case "ellipse": return region.kind;
+		case "polygon":
+			if (region.holes && region.holes.length > 0) return "holes";
+			return isConvex(region.points) ? "convex" : "polygon";
+	}
+}
+/** This function gives the value of `itemShape` of one item shape. An ellipse is convex. */
+function itemShapeOf(region) {
+	if (region === void 0) return "rect";
+	switch (region.kind) {
+		case "rect":
+		case "circle": return region.kind;
+		case "ellipse": return "convex";
+		case "polygon": return !region.holes?.length && isConvex(region.points) ? "convex" : "polygon";
+	}
+}
+/**
+* This function gives the cell of an input: the values of the packer dimensions that the input tells.
+*
+* - `containerSize` comes from `fixed`. The value `none` gives `freeArea` when `aspectWeight` is 0, and `freeAspect` if not.
+* - `containerShape` comes from the shape. A rectangle container with an obstacle of another region gives `holes`.
+* - `obstacleMove` is the hardest value of the obstacles and the locked items: `costly`, then `free`, then `fixed`.
+* - `order` is `soft` when an item has a rank, and `free` if not. The input does not tell a hard order.
+* - `groups` is `nested` when an item has a parent, `flat` when an item has a group, and `none` if not.
+*/
+function cellOf(input) {
+	const { container, items } = input;
+	const obstacles = input.obstacles ?? [];
+	const containerSize = {
+		size: "fixed",
+		width: "freeHeight",
+		height: "freeWidth",
+		none: container.aspectWeight === 0 ? "freeArea" : "freeAspect"
+	}[container.fixed];
+	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) {
+		const move = o.move === void 0 ? "fixed" : o.move.cost > 0 ? "costly" : "free";
+		if (move === "costly" || obstacleMove === void 0 || move === "free" && obstacleMove === "fixed") obstacleMove = move;
+	}
+	const shapes = new Set(items.map((i) => itemShapeOf(i.shape)));
+	const itemShape = shapes.size > 1 ? "mixed" : [...shapes][0] ?? "rect";
+	const cell = {
+		containerSize,
+		containerShape,
+		itemShape,
+		rotation: items.some((i) => i.turnable === true) ? "quarter" : "none",
+		order: items.some((i) => i.rank !== void 0) ? "soft" : "free",
+		groups: items.some((i) => i.parent !== void 0) ? "nested" : items.some((i) => i.group !== void 0) ? "flat" : "none"
+	};
+	if (obstacleMove !== void 0) cell.obstacleMove = obstacleMove;
+	return cell;
+}
+/** This function gives the first dimension of a cell that `supports` does not hold, or `undefined` when it holds each one. */
+function unsupportedOf(supports, cell) {
+	for (const dimension of Object.keys(supports)) {
+		const value = cell[dimension];
+		if (value === void 0) continue;
+		if (!supports[dimension].includes(value)) return {
+			dimension,
+			value
+		};
+	}
+}
+/** This function tells if `supports` holds each value of a cell. A dimension that the cell does not have is held. */
+function supportsCell(supports, cell) {
+	return unsupportedOf(supports, cell) === void 0;
+}
+/** This function throws `UnsupportedCell` for the first value of the cell of an input that `supports` does not hold. */
+function assertSupported(supports, input) {
+	const miss = unsupportedOf(supports, cellOf(input));
+	if (miss) throw new UnsupportedCell(miss.dimension, miss.value);
+}
+// src/frame.ts
+const clock = globalThis.performance;
+/** This function gives the time in milliseconds. */
+function now() {
+	return clock ? clock.now() : Date.now();
+}
+/** This function gives the bounding box of a region. */
+function boundsOf(region) {
+	switch (region.kind) {
+		case "rect": return {
+			x: region.x,
+			y: region.y,
+			w: region.w,
+			h: region.h
+		};
+		case "circle": return {
+			x: region.cx - region.r,
+			y: region.cy - region.r,
+			w: 2 * region.r,
+			h: 2 * region.r
+		};
+		case "ellipse": return {
+			x: region.cx - region.rx,
+			y: region.cy - region.ry,
+			w: 2 * region.rx,
+			h: 2 * region.ry
+		};
+		case "polygon": {
+			const xs = region.points.map((p) => p[0]);
+			const ys = region.points.map((p) => p[1]);
+			const x = Math.min(...xs);
+			const y = Math.min(...ys);
+			return {
+				x,
+				y,
+				w: Math.max(...xs) - x,
+				h: Math.max(...ys) - y
+			};
+		}
+	}
+}
+/** This function gives the rectangle of a container. A rectangle shape gives the origin and the sizes of the fixed sides. */
+function containerBounds(input) {
+	const { container } = input;
+	const shape = container.shape === void 0 ? void 0 : boundsOf(container.shape);
+	const fixedW = container.fixed === "size" || container.fixed === "width";
+	const fixedH = container.fixed === "size" || container.fixed === "height";
+	const w = shape?.w ?? container.w;
+	const h = shape?.h ?? container.h;
+	if (fixedW && w === void 0) throw new TypeError(`A container with fixed "${container.fixed}" needs a width.`);
+	if (fixedH && h === void 0) throw new TypeError(`A container with fixed "${container.fixed}" needs a height.`);
+	return {
+		x: shape?.x ?? 0,
+		y: shape?.y ?? 0,
+		w: fixedW ? w : Infinity,
+		h: fixedH ? h : Infinity
+	};
+}
+/** This function gives the items in the order of their rank. The index in the array is the rank of an item without one. */
+function byRank(items) {
+	return items.map((item, index) => ({
+		item,
+		rank: item.rank ?? index
+	})).toSorted((a, b) => a.rank - b.rank).map((e) => e.item);
+}
+/**
+* This function makes the frame of an input. A locked item with a position and an obstacle without `move` are locked
+* rectangles. An obstacle with `move` is a free rectangle only when `movable` is `true`.
+*/
+function buildFrame(input, movable = false) {
+	const bounds = containerBounds(input);
+	const inset = input.container.inset ?? 0;
+	const half = (input.gap ?? 0) / 2;
+	const ox = bounds.x + inset - half;
+	const oy = bounds.y + inset - half;
+	const w = bounds.w - 2 * inset + 2 * half;
+	const h = bounds.h - 2 * inset + 2 * half;
+	const entries = [];
+	const tooLarge = [];
+	for (const item of byRank(input.items)) {
+		const m = marginOf(item);
+		const rect = new Rect();
+		rect.size.set(item.w + m.left + m.right + 2 * half, item.h + m.top + m.bottom + 2 * half);
+		const dx = m.left + half;
+		const dy = m.top + half;
+		if (item.locked === true && item.x !== void 0 && item.y !== void 0) {
+			rect.locked = true;
+			rect.position.set(item.x - dx - ox, item.y - dy - oy);
+		} else if (rect.size.x > w + 1e-6 || rect.size.y > h + 1e-6) {
+			tooLarge.push(item.id);
+			continue;
+		}
+		entries.push({
+			rect,
+			item,
+			dx,
+			dy
+		});
+	}
+	for (const obstacle of input.obstacles ?? []) {
+		const b = boundsOf(obstacle.region);
+		const rect = new Rect();
+		rect.size.set(b.w + 2 * half, b.h + 2 * half);
+		rect.position.set(b.x - half - ox, b.y - half - oy);
+		rect.locked = !(movable && obstacle.move !== void 0);
+		entries.push({
+			rect,
+			obstacle,
+			dx: half,
+			dy: half
+		});
+	}
+	return {
+		ox,
+		oy,
+		w,
+		h,
+		bounds,
+		inset,
+		entries,
+		tooLarge
+	};
+}
+/** This function gives the outer rectangle of 0.1 for a frame. A free height starts at 0 and grows. */
+function outerOf(frame) {
+	const outer = new Rect();
+	const fixedSize = Number.isFinite(frame.h);
+	outer.size.set(frame.w, fixedSize ? frame.h : 0);
+	outer.fixedWidth = true;
+	outer.fixedSize = fixedSize;
+	return outer;
+}
+/** This function gives the rectangles of a frame, in the order of the entries. */
+function rectsOf(frame) {
+	return frame.entries.map((e) => e.rect);
+}
+/**
+* This function reads the output from the rectangles of a frame after a packing of 0.1. A locked item keeps its
+* position exactly. Each other item that the packer did not place goes to the overflow.
+*/
+function readFrame(input, frame, trace, moved = []) {
+	const placements = [];
+	const overflow = [...frame.tooLarge];
+	for (const e of frame.entries) {
+		const item = e.item;
+		if (item === void 0) continue;
+		if (item.locked === true && item.x !== void 0 && item.y !== void 0) placements.push({
+			id: item.id,
+			x: item.x,
+			y: item.y
+		});
+		else if (e.rect.wasPacked) placements.push({
+			id: item.id,
+			x: e.rect.position.x + e.dx + frame.ox,
+			y: e.rect.position.y + e.dy + frame.oy
+		});
+		else overflow.push(item.id);
+	}
+	return {
+		placements,
+		overflow,
+		size: sizeOf(input, frame, placements, moved),
+		moved,
+		trace
+	};
+}
+/**
+* This function gives the size of the container after a packing. A fixed side keeps its size. A free side goes to the
+* far edge of the items with their margins and the inset, or of the obstacles.
+*/
+function sizeOf(input, frame, placements, moved) {
+	const items = new Map(input.items.map((i) => [i.id, i]));
+	let right = 0;
+	let bottom = 0;
+	for (const p of placements) {
+		const item = items.get(p.id);
+		const m = marginOf(item);
+		right = Math.max(right, p.x + item.w + m.right + frame.inset - frame.bounds.x);
+		bottom = Math.max(bottom, p.y + item.h + m.bottom + frame.inset - frame.bounds.y);
+	}
+	const movedById = new Map(moved.map((m) => [m.id, m]));
+	for (const o of input.obstacles ?? []) {
+		const b = boundsOf(o.region);
+		const at = movedById.get(o.id) ?? b;
+		right = Math.max(right, at.x + b.w - frame.bounds.x);
+		bottom = Math.max(bottom, at.y + b.h - frame.bounds.y);
+	}
+	return {
+		w: Number.isFinite(frame.bounds.w) ? frame.bounds.w : right,
+		h: Number.isFinite(frame.bounds.h) ? frame.bounds.h : bottom
+	};
+}
+/** This function gives a region with the axes changed: x for y, and w for h. */
+function transposeRegion(region) {
+	switch (region.kind) {
+		case "rect": return {
+			kind: "rect",
+			x: region.y,
+			y: region.x,
+			w: region.h,
+			h: region.w
+		};
+		case "circle": return {
+			kind: "circle",
+			cx: region.cy,
+			cy: region.cx,
+			r: region.r
+		};
+		case "ellipse": return {
+			kind: "ellipse",
+			cx: region.cy,
+			cy: region.cx,
+			rx: region.ry,
+			ry: region.rx
+		};
+		case "polygon": {
+			const swap = (ring) => ring.map(([x, y]) => [y, x]);
+			const turned = {
+				kind: "polygon",
+				points: swap(region.points)
+			};
+			if (region.holes) turned.holes = region.holes.map(swap);
+			return turned;
+		}
+	}
+}
+/** This function gives an item with the axes changed. The ports go, because the adapters of 0.1 do not read them. */
+function transposeItem(item) {
+	const { ports: _ports, ...rest } = item;
+	const turned = {
+		...rest,
+		w: item.h,
+		h: item.w
+	};
+	delete turned.x;
+	delete turned.y;
+	if (item.y !== void 0) turned.x = item.y;
+	if (item.x !== void 0) turned.y = item.x;
+	if (item.shape) turned.shape = transposeRegion(item.shape);
+	if (item.margin !== void 0 && typeof item.margin !== "number") {
+		const m = item.margin;
+		turned.margin = {
+			top: m.left,
+			right: m.bottom,
+			bottom: m.right,
+			left: m.top
+		};
+	}
+	return turned;
+}
+/** This function gives an input with the axes changed. A fixed height becomes a fixed width. */
+function transposeInput(input) {
+	const c = input.container;
+	const container = { fixed: c.fixed === "height" ? "width" : c.fixed === "width" ? "height" : c.fixed };
+	if (c.h !== void 0) container.w = c.h;
+	if (c.w !== void 0) container.h = c.w;
+	if (c.aspect !== void 0) container.aspect = 1 / c.aspect;
+	if (c.aspectWeight !== void 0) container.aspectWeight = c.aspectWeight;
+	if (c.shape !== void 0) container.shape = transposeRegion(c.shape);
+	if (c.inset !== void 0) container.inset = c.inset;
+	const turned = {
+		container,
+		items: input.items.map(transposeItem)
+	};
+	if (input.obstacles) turned.obstacles = input.obstacles.map((o) => ({
+		...o,
+		region: transposeRegion(o.region)
+	}));
+	if (input.gap !== void 0) turned.gap = input.gap;
+	return turned;
+}
+/** This function gives an output with the axes changed. */
+function transposeOutput(output) {
+	return {
+		placements: output.placements.map((p) => ({
+			...p,
+			x: p.y,
+			y: p.x
+		})),
+		overflow: [...output.overflow],
+		size: {
+			w: output.size.h,
+			h: output.size.w
+		},
+		moved: output.moved.map((m) => ({
+			id: m.id,
+			x: m.y,
+			y: m.x
+		})),
+		trace: output.trace
+	};
+}
+/**
+* This function packs an input with a fixed height through the turn of the axes. It changes x for y in the input.
+* Then it packs with a fixed width, and changes the axes of the output back.
+*/
+function viaAxes(input, previous, run) {
+	const start = now();
+	const inner = run(transposeInput(input), previous === void 0 ? void 0 : transposeOutput(previous));
+	const output = transposeOutput(inner);
+	output.trace = [{
+		id: "axes",
+		ms: now() - start,
+		measures: {}
+	}, ...inner.trace];
+	return output;
+}
+// src/adapters.ts
+/** The cells of `rows`, `skyline` and `shelf`, without the movement of the obstacles. */
+const LAYOUT_CELLS = {
+	containerSize: [
+		"fixed",
+		"freeHeight",
+		"freeWidth",
+		"freeAspect",
+		"freeArea"
+	],
+	containerShape: ["rect"],
+	itemShape: ["rect"],
+	rotation: ["none"],
+	groups: ["none"],
+	mode: ["offline"]
+};
+/** This function makes the supports of a strategy, with copies of each list. */
+function supportsOf(cells) {
+	return {
+		containerSize: [...cells.containerSize],
+		containerShape: [...cells.containerShape],
+		obstacleMove: [...cells.obstacleMove],
+		itemShape: [...cells.itemShape],
+		rotation: [...cells.rotation],
+		order: [...cells.order],
+		groups: [...cells.groups],
+		mode: [...cells.mode]
+	};
+}
+/** This function packs an input with a fixed size or a fixed width with one strategy of `pack`. */
+function packFixedWidth(id, input, options) {
+	const start = now();
+	const frame = buildFrame(input);
+	const rects = rectsOf(frame);
+	if (frame.w > 0) pack(rects, outerOf(frame), {
+		strategy: id,
+		sortOrder: options.sortOrder
+	});
+	const output = readFrame(input, frame, []);
+	output.trace.push({
+		id,
+		ms: now() - start,
+		measures: { "pack.overflow": output.overflow.length }
+	});
+	return output;
+}
+/** This function makes the strategy of one function of `pack`. */
+function layoutStrategy(id, family, catalog, cells) {
+	const self = {
+		id,
+		family,
+		catalog,
+		supports: supportsOf({
+			...LAYOUT_CELLS,
+			...cells
+		}),
+		defaults: {
+			sortOrder: "height-desc",
+			samples: 48
+		},
+		deterministic: true,
+		pack(input, options, context) {
+			assertSupported(self.supports, input);
+			const o = {
+				...self.defaults,
+				...options
+			};
+			switch (input.container.fixed) {
+				case "height": return viaAxes(input, context.previous, (turned) => packFixedWidth(id, turned, o));
+				case "none": return logSweep.search(input, self, context, o);
+				default: return packFixedWidth(id, input, o);
+			}
+		}
+	};
+	return self;
+}
+/**
+* The strategy `rows` uses `packRows`: a guillotine row packing with a recursive gap fill. It supports no obstacle and
+* no locked item, because `packRows` does not go around them. Turnable items, groups and shapes throw `UnsupportedCell`.
+*/
+const rows = layoutStrategy("rows", "shelf", ["rows-gap-fill", "rows-input"], {
+	obstacleMove: [],
+	order: [
+		"free",
+		"soft",
+		"hard"
+	]
+});
+/**
+* The strategy `skyline` uses `packSkyline`: each item goes to the lowest place where it fits. It packs around the
+* locked items and the fixed obstacles. Turnable items, groups and shapes throw `UnsupportedCell`.
+*/
+const skyline = layoutStrategy("skyline", "skyline", ["skyline-bl"], {
+	obstacleMove: ["fixed"],
+	order: ["free", "soft"]
+});
+/**
+* The strategy `shelf` uses `packShelf`: rows filled left to right, around the locked items and the fixed obstacles.
+* With the sort order `input`, the rows keep the rank order. Turnable items, groups and shapes throw `UnsupportedCell`.
+*/
+const shelf = layoutStrategy("shelf", "shelf", ["shelf-nf", "shelf-nfdh"], {
+	obstacleMove: ["fixed"],
+	order: [
+		"free",
+		"soft",
+		"hard"
+	]
+});
+/**
+* The size search `log-sweep` uses `packFree` of 0.1.2: widths on a log scale, then the widths near the best width. It
+* wraps `rows`, `skyline` and `shelf`. The objective is the area of the frame times `1 + aspectWeight * aspectError`.
+*/
+const logSweep = {
+	id: "log-sweep",
+	search(input, inner, context, options) {
+		if (input.container.fixed !== "none") return inner.pack(input, options ?? inner.defaults, context);
+		const id = inner.id;
+		if (id !== "rows" && id !== "skyline" && id !== "shelf") throw new UnsupportedCell("containerSize", cellOf(input).containerSize);
+		const o = {
+			...inner.defaults,
+			...options
+		};
+		const start = now();
+		const frame = buildFrame(input);
+		const result = packFree(rectsOf(frame), new Rect(), {
+			strategy: id,
+			sortOrder: o.sortOrder,
+			samples: o.samples,
+			aspect: input.container.aspect ?? 1,
+			aspectWeight: input.container.aspectWeight ?? 1
+		});
+		const ms = now() - start;
+		const runs = result.tried.length + 1;
+		const output = readFrame(input, frame, []);
+		output.trace.push({
+			id: "log-sweep",
+			ms,
+			measures: {
+				"pack.search.widths": result.tried.length,
+				"pack.search.ms": ms
+			}
+		}, {
+			id,
+			ms: ms / runs,
+			measures: { "pack.overflow": output.overflow.length }
+		});
+		return output;
+	}
+};
+/** This function tells if the insides of two rectangles overlap by more than `EPS`. */
+function overlaps(a, b) {
+	return Math.min(a.right(), b.right()) - Math.max(a.position.x, b.position.x) > 1e-6 && Math.min(a.bottom(), b.bottom()) - Math.max(a.position.y, b.position.y) > 1e-6;
+}
+/** This function packs an input with a fixed size or a fixed width with a push cascade. */
+function pushFixedWidth(input, options, previous) {
+	const start = now();
+	const frame = buildFrame(input, true);
+	const before = new Map(previous?.placements.map((p) => [p.id, p]));
+	const positioned = [];
+	const pending = [];
+	const obstacles = frame.entries.filter((e) => e.obstacle !== void 0);
+	const starts = new Map(obstacles.map((e) => [e, {
+		x: e.rect.position.x,
+		y: e.rect.position.y
+	}]));
+	const lockedItems = frame.entries.filter((e) => e.item !== void 0 && e.rect.locked);
+	for (const e of frame.entries) {
+		const item = e.item;
+		if (item === void 0 || e.rect.locked) continue;
+		const x = item.x ?? before.get(item.id)?.x;
+		const y = item.y ?? before.get(item.id)?.y;
+		if (x === void 0 || y === void 0) {
+			pending.push(e);
+			continue;
+		}
+		e.rect.position.set(x - e.dx - frame.ox, y - e.dy - frame.oy);
+		positioned.push(e);
+	}
+	const inPlay = frame.entries.filter((e) => !pending.includes(e)).map((e) => e.rect);
+	const maxShoves = options.maxShovesPerItem * Math.max(1, inPlay.length);
+	for (const e of positioned) {
+		pushCascade(e.rect, inPlay, {
+			gap: 0,
+			maxShoves
+		});
+		e.rect.locked = true;
+	}
+	const { bounds } = frame;
+	const moved = [];
+	for (const e of obstacles) {
+		const startAt = starts.get(e);
+		const x = e.rect.position.x + e.dx + frame.ox;
+		const y = e.rect.position.y + e.dy + frame.oy;
+		const b = boundsOf(e.obstacle.region);
+		if (x < bounds.x - 1e-6 || y < bounds.y - 1e-6 || x + b.w > bounds.x + bounds.w + 1e-6 || y + b.h > bounds.y + bounds.h + 1e-6 || lockedItems.some((l) => overlaps(l.rect, e.rect))) e.rect.position.set(startAt.x, startAt.y);
+		else if (Math.abs(e.rect.position.x - startAt.x) > 1e-6 || Math.abs(e.rect.position.y - startAt.y) > 1e-6) moved.push({
+			id: e.obstacle.id,
+			x,
+			y
+		});
+	}
+	const pushMs = now() - start;
+	const kept = [...obstacles, ...lockedItems].map((e) => e.rect);
+	for (const e of positioned) {
+		const r = e.rect;
+		if (r.position.x >= -1e-6 && r.position.y >= -1e-6 && r.right() <= frame.w + 1e-6 && r.bottom() <= frame.h + 1e-6 && !kept.some((k) => overlaps(k, r))) kept.push(r);
+		else pending.push(e);
+	}
+	const skylineStart = now();
+	for (const r of kept) {
+		r.locked = true;
+		r.wasPacked = true;
+	}
+	if (pending.length > 0 && frame.w > 0) {
+		for (const e of pending) {
+			e.rect.locked = false;
+			e.rect.wasPacked = false;
+		}
+		packSkyline([...pending.map((e) => e.rect), ...kept], outerOf(frame), { sortOrder: options.sortOrder });
+	}
+	const output = readFrame(input, frame, [], moved);
+	output.trace.push({
+		id: "push",
+		ms: pushMs,
+		measures: { "pack.push.moved": moved.length }
+	}, {
+		id: "skyline",
+		ms: now() - skylineStart,
+		measures: {
+			"pack.push.replaced": pending.length,
+			"pack.overflow": output.overflow.length
+		}
+	});
+	return output;
+}
+/**
+* The strategy `push` uses `pushCascade`. Each item starts at its `x` and `y`, or at its place in `context.previous`.
+* Each item in rank order pushes the items and the movable obstacles that it overlaps. Then `packSkyline` places the
+* items with no start, and the items that still overlap. The output tells each obstacle that moved.
+*/
+const push = {
+	id: "push",
+	family: "incremental",
+	catalog: ["incremental-push"],
+	supports: supportsOf({
+		containerSize: [
+			"fixed",
+			"freeHeight",
+			"freeWidth"
+		],
+		containerShape: ["rect"],
+		obstacleMove: ["fixed", "free"],
+		itemShape: ["rect"],
+		rotation: ["none"],
+		order: ["free", "soft"],
+		groups: ["none"],
+		mode: ["incremental"]
+	}),
+	defaults: {
+		sortOrder: "height-desc",
+		maxShovesPerItem: 8
+	},
+	deterministic: true,
+	pack(input, options, context) {
+		assertSupported(push.supports, input);
+		const o = {
+			...push.defaults,
+			...options
+		};
+		if (input.container.fixed === "height") return viaAxes(input, context.previous, (turned, previous) => pushFixedWidth(turned, o, previous));
+		return pushFixedWidth(input, o, context.previous);
+	}
+};
+// src/convert.ts
+/**
+* This function makes a `PackInput` from the `Rect` objects of 0.1. The id of each item is the index of its rectangle.
+*
+* - `fixedSize` gives `fixed` set to `size`, `fixedWidth` gives `width`, and an outer rectangle without them gives `none`.
+* - A locked rectangle gives a locked item at its position.
+* - An outer rectangle at a position other than 0, 0 gives a rectangle shape at that position.
+*/
+function fromRects(rects, outer) {
+	const fixed = outer.fixedSize ? "size" : outer.fixedWidth ? "width" : "none";
+	const container = { fixed };
+	if (fixed !== "none") container.w = outer.size.x;
+	if (fixed === "size") container.h = outer.size.y;
+	if (outer.position.x !== 0 || outer.position.y !== 0) container.shape = {
+		kind: "rect",
+		x: outer.position.x,
+		y: outer.position.y,
+		w: outer.size.x,
+		h: outer.size.y
+	};
+	return {
+		container,
+		items: rects.map((r, i) => {
+			const item = {
+				id: String(i),
+				w: r.size.x,
+				h: r.size.y
+			};
+			if (r.locked) {
+				item.locked = true;
+				item.x = r.position.x;
+				item.y = r.position.y;
+			}
+			return item;
+		})
+	};
+}
+/**
+* This function writes an output back into the `Rect` objects of `fromRects`. It sets the position and `wasPacked` of
+* each rectangle, and the free sides of the outer rectangle. It gives the outer rectangle.
+*/
+function toRects(output, rects, outer) {
+	const placements = new Map(output.placements.map((p) => [p.id, p]));
+	for (const [i, r] of rects.entries()) {
+		const p = placements.get(String(i));
+		if (p === void 0) {
+			r.wasPacked = r.locked;
+			continue;
+		}
+		r.position.set(p.x, p.y);
+		r.wasPacked = true;
+	}
+	if (!outer.fixedSize) {
+		if (!outer.fixedWidth) outer.size.x = output.size.w;
+		outer.size.y = output.size.h;
+	}
+	return outer;
+}
+// src/registry.ts
+/** Each strategy of the package. The benchmark starts each one on each input of the corpus. */
+const strategies = Object.freeze([
+	rows,
+	skyline,
+	shelf,
+	push
+]);
+/** This function gives the strategy with an id. It throws a `RangeError` for an id that the registry does not have. */
+function strategy(id) {
+	const found = strategies.find((s) => s.id === id);
+	if (found === void 0) throw new RangeError(`The registry has no strategy "${id}".`);
+	return found;
+}
+/**
+* This function packs an input with the strategy of an id. The options go over the defaults of the strategy. The
+* context gets `mulberry32` with the seed. The default seed is 0.
+*/
+function packWith(id, input, options, seed = 0) {
+	const s = strategy(id);
+	const merged = {
+		...s.defaults,
+		...options
+	};
+	return s.pack(input, merged, createContext(seed));
+}
+// src/check.ts
+/** This function tells if the insides of two boxes overlap by more than a tolerance on each axis. */
+function overlap(a, b, tolerance) {
+	return Math.min(a.r, b.r) - Math.max(a.l, b.l) > tolerance && Math.min(a.b, b.b) - Math.max(a.t, b.t) > tolerance;
+}
+/**
+* This function counts the breaks of the 4 hard rules of the packer for an output.
+*
+* - `no-overlap`: each pair of items with their margins, and each pair of an item and an obstacle, that overlap by more than `tolerance.overlap`.
+* - `in-container`: each item with its margin that goes out of a fixed side by more than `tolerance.overlap`.
+* - `locked-kept`: each locked item that moved by more than `RECORD_EPS`, or that has no position.
+* - `complete`: each item with no position that is not in the overflow.
+*
+* The rules read a shape of the container or of an obstacle as its bounding box. The result has no tolerance in it.
+*/
+function checkHard(input, output, tolerance = DEFAULT_TOLERANCE) {
+	const tol = tolerance.overlap;
+	const placements = /* @__PURE__ */ new Map();
+	for (const p of output.placements) if (!placements.has(p.id)) placements.set(p.id, p);
+	const overflow = new Set(output.overflow);
+	const breaks = {
+		"no-overlap": 0,
+		"in-container": 0,
+		"locked-kept": 0,
+		complete: 0
+	};
+	const boxes = [];
+	for (const item of input.items) {
+		const p = placements.get(item.id);
+		if (p === void 0) {
+			if (item.locked === true && item.x !== void 0 && item.y !== void 0) breaks["locked-kept"] += 1;
+			if (!overflow.has(item.id)) breaks.complete += 1;
+			continue;
+		}
+		if (item.locked === true && item.x !== void 0 && item.y !== void 0) {
+			if (Math.abs(p.x - item.x) > .001 || Math.abs(p.y - item.y) > .001) breaks["locked-kept"] += 1;
+		}
+		const placed = p.turn === 90 ? turnItem(item) : item;
+		const m = marginOf(placed);
+		boxes.push({
+			l: p.x - m.left,
+			t: p.y - m.top,
+			r: p.x + placed.w + m.right,
+			b: p.y + placed.h + m.bottom
+		});
+	}
+	const moved = new Map(output.moved.map((m) => [m.id, m]));
+	const obstacles = (input.obstacles ?? []).map((o) => {
+		const b = boundsOf(o.region);
+		const at = moved.get(o.id) ?? b;
+		return {
+			l: at.x,
+			t: at.y,
+			r: at.x + b.w,
+			b: at.y + b.h
+		};
+	});
+	for (const [i, a] of boxes.entries()) {
+		for (let j = i + 1; j < boxes.length; j++) if (overlap(a, boxes[j], tol)) breaks["no-overlap"] += 1;
+		for (const o of obstacles) if (overlap(a, o, tol)) breaks["no-overlap"] += 1;
+	}
+	const { container } = input;
+	const shape = container.shape === void 0 ? void 0 : boundsOf(container.shape);
+	const x = shape?.x ?? 0;
+	const y = shape?.y ?? 0;
+	const w = shape?.w ?? container.w ?? Infinity;
+	const h = shape?.h ?? container.h ?? Infinity;
+	const fixedW = container.fixed === "size" || container.fixed === "width";
+	const fixedH = container.fixed === "size" || container.fixed === "height";
+	for (const box of boxes) {
+		const outX = fixedW && (box.l < x - tol || box.r > x + w + tol);
+		const outY = fixedH && (box.t < y - tol || box.b > y + h + tol);
+		if (outX || outY) breaks["in-container"] += 1;
+	}
+	return breaks;
+}
+// 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