@mark1russell7/packing 0.1.4 → 0.1.6

package/build/index.js

@@ -598,66 +598,6 @@ function pushCascade(placed, rects, options = {}) {
 	}
 	return [...moved];
 }
-// src/metrics.ts
-/**
-* This function measures a packing. It gives the hull and its aspect, the rows and the raggedness of the right side.
-* It also gives the part of the hull that the rectangles cover, and the widest rectangle against the median width.
-*
-* @example
-* ```ts
-* const { utilization, raggedness } = packingMetrics(Rect.packed(cards));
-* ```
-*/
-function packingMetrics(rects, options = {}) {
-	const tolerance = options.rowTolerance ?? 40;
-	const boxes = rects.filter((r) => r.size.x > 0 && r.size.y > 0);
-	if (boxes.length === 0) return {
-		count: 0,
-		hull: {
-			width: 0,
-			height: 0
-		},
-		hullAspect: 0,
-		rows: [],
-		raggedness: 0,
-		utilization: 0,
-		widestOverMedian: 0
-	};
-	const left = Math.min(...boxes.map((r) => r.position.x));
-	const top = Math.min(...boxes.map((r) => r.position.y));
-	const right = Math.max(...boxes.map((r) => r.right()));
-	const bottom = Math.max(...boxes.map((r) => r.bottom()));
-	const hull = {
-		width: right - left,
-		height: bottom - top
-	};
-	const rows = [];
-	for (const r of boxes.toSorted((a, b) => a.position.y - b.position.y)) {
-		const row = rows.at(-1);
-		if (row && Math.abs(r.position.y - row.top) <= tolerance) {
-			row.right = Math.max(row.right, r.right());
-			row.count += 1;
-		} else rows.push({
-			top: r.position.y,
-			right: r.right(),
-			count: 1
-		});
-	}
-	const rights = rows.map((row) => row.right);
-	const widths = boxes.map((r) => r.size.x).toSorted((a, b) => a - b);
-	const median = widths[Math.floor(widths.length / 2)] ?? 0;
-	const widest = widths.at(-1) ?? 0;
-	const area = boxes.reduce((sum, r) => sum + r.area(), 0);
-	return {
-		count: boxes.length,
-		hull,
-		hullAspect: hull.height > 0 ? hull.width / hull.height : 0,
-		rows: rows.map((row) => row.count),
-		raggedness: Math.max(...rights) - Math.min(...rights),
-		utilization: hull.width * hull.height > 0 ? area / (hull.width * hull.height) : 0,
-		widestOverMedian: median > 0 ? widest / median : 0
-	};
-}
 // src/contract.ts
 /** The tolerance for the comparison of two numbers in an engine. */
 const EPS = 1e-6;
@@ -750,28 +690,563 @@ function turnRegion(region, h) {
 	}
 }
 /**
-* 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.
+* 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/sha256.ts
+/** The round constants of SHA-256. */
+const K = new Uint32Array([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+/** The first hash value of SHA-256. */
+const H0 = [
+	1779033703,
+	3144134277,
+	1013904242,
+	2773480762,
+	1359893119,
+	2600822924,
+	528734635,
+	1541459225
+];
+/** This function turns a 32-bit word to the right by `n` bits. */
+const rotr = (x, n) => x >>> n | x << 32 - n;
+/**
+* This function gives the UTF-8 bytes of a string. A lone surrogate becomes U+FFFD, as with `TextEncoder`. The
+* package has no `TextEncoder` type, because its code operates on each runtime with no global types.
+*/
+function utf8(text) {
+	const out = [];
+	for (let i = 0; i < text.length; i++) {
+		let c = text.charCodeAt(i);
+		if (c >= 55296 && c <= 56319 && i + 1 < text.length) {
+			const next = text.charCodeAt(i + 1);
+			if (next >= 56320 && next <= 57343) {
+				c = 65536 + (c - 55296 << 10) + (next - 56320);
+				i++;
+			}
+		}
+		if (c >= 55296 && c <= 57343) c = 65533;
+		if (c < 128) out.push(c);
+		else if (c < 2048) out.push(192 | c >> 6, 128 | c & 63);
+		else if (c < 65536) out.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
+		else out.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
+	}
+	return Uint8Array.from(out);
+}
+/** This function gives the SHA-256 of the UTF-8 bytes of a string, as 64 lowercase hex characters. */
+function sha256Hex(text) {
+	const bytes = utf8(text);
+	const length = bytes.length;
+	const padded = new Uint8Array(((length + 9 + 63) / 64 | 0) * 64);
+	padded.set(bytes);
+	padded[length] = 128;
+	const view = new DataView(padded.buffer);
+	const bits = length * 8;
+	view.setUint32(padded.length - 8, Math.floor(bits / 4294967296));
+	view.setUint32(padded.length - 4, bits >>> 0);
+	const hash = [...H0];
+	const w = /* @__PURE__ */ new Uint32Array(64);
+	for (let block = 0; block < padded.length; block += 64) {
+		for (let t = 0; t < 16; t++) w[t] = view.getUint32(block + t * 4);
+		for (let t = 16; t < 64; t++) {
+			const a = w[t - 15];
+			const b = w[t - 2];
+			const s0 = rotr(a, 7) ^ rotr(a, 18) ^ a >>> 3;
+			const s1 = rotr(b, 17) ^ rotr(b, 19) ^ b >>> 10;
+			w[t] = w[t - 16] + s0 + w[t - 7] + s1 | 0;
+		}
+		let [a, b, c, d, e, f, g, h] = hash;
+		for (let t = 0; t < 64; t++) {
+			const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+			const ch = e & f ^ ~e & g;
+			const t1 = h + s1 + ch + K[t] + w[t] | 0;
+			const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+			h = g;
+			g = f;
+			f = e;
+			e = d + t1 | 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 | 0;
+		}
+		hash[0] = hash[0] + a | 0;
+		hash[1] = hash[1] + b | 0;
+		hash[2] = hash[2] + c | 0;
+		hash[3] = hash[3] + d | 0;
+		hash[4] = hash[4] + e | 0;
+		hash[5] = hash[5] + f | 0;
+		hash[6] = hash[6] + g | 0;
+		hash[7] = hash[7] + h | 0;
+	}
+	return hash.map((x) => (x >>> 0).toString(16).padStart(8, "0")).join("");
+}
+// src/layout-input.ts
+/** This function gives the `fnv1a32` hash of the UTF-8 bytes of a string, as `docs/FORMAT.md` gives it. */
+function fnv1a32(text) {
+	let h = 2166136261;
+	for (const b of utf8(text)) h = Math.imul(h ^ b, 16777619) >>> 0;
+	return h;
+}
+/** This function rounds the numbers of a file to 3 decimals. A half goes up, and the value `-0` becomes 0. */
+function round3(x) {
+	const v = Math.round(x * 1e3) / 1e3;
+	return Object.is(v, -0) ? 0 : v;
+}
+/**
+* This function gives the canonical form of a value: sorted keys, no whitespace and the numbers of `JSON.stringify`
+* after `round3`. A key with the value `undefined` is not in the form.
+*/
+function canonicalJson(value) {
+	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+	if (value !== null && typeof value === "object") return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(",")}}`;
+	return JSON.stringify(typeof value === "number" ? round3(value) : value);
+}
+/** This function gives the hash of an input file: the first 16 hex characters of the SHA-256 of its canonical form without `hash`. */
+function hashInput(file) {
+	const rest = { ...file };
+	delete rest.hash;
+	return sha256Hex(canonicalJson(rest)).slice(0, 16);
+}
+/** This function gives the scale of a count: the nearest of 1, 10, 100, 1000 and 10000 on a log scale. The count 0 gives `1`. */
+function countCell(count) {
+	if (count <= 3) return "1";
+	if (count <= 31) return "10";
+	if (count <= 316) return "100";
+	if (count <= 3162) return "1k";
+	return "10k";
+}
+/** This function gives the packing input of a file. The boxes become the items, and the edges go. */
+function toPackInput(file) {
+	const input = {
+		container: file.container,
+		items: file.boxes
+	};
+	if (file.obstacles !== void 0) input.obstacles = file.obstacles;
+	if (file.gap !== void 0) input.gap = file.gap;
+	return input;
+}
+// src/measures.ts
+const spec = (id, family, unit, direction, min, max) => ({
+	id,
+	family,
+	unit,
+	direction,
+	min,
+	max
+});
+/** The facts of each measure, by id. `docs/MEASURES.md` gives the full definitions. */
+const MEASURE_SPECS = Object.freeze({
+	"pack.area": spec("pack.area", "density", "square units", "lower", 0, Infinity),
+	"pack.fill": spec("pack.fill", "density", "share", "higher", 0, 1),
+	"pack.whitespace": spec("pack.whitespace", "density", "share", "lower", 0, 1),
+	"pack.aspect": spec("pack.aspect", "aspect", "ratio", "lower", 1, Infinity),
+	"pack.aspectError": spec("pack.aspectError", "aspect", "natural log", "lower", 0, Infinity),
+	"pack.order.inversions": spec("pack.order.inversions", "order", "share", "lower", 0, 1),
+	"pack.order.breaks": spec("pack.order.breaks", "order", "count", "lower", 0, Infinity),
+	"pack.raggedness": spec("pack.raggedness", "raggedness", "share", "lower", 0, 1),
+	"pack.overflow": spec("pack.overflow", "overflow", "count", "lower", 0, Infinity),
+	"pack.stability.moved": spec("pack.stability.moved", "stability", "share", "lower", 0, 1),
+	"pack.stability.mean": spec("pack.stability.mean", "stability", "container widths", "lower", 0, Infinity),
+	"pack.stability.q95": spec("pack.stability.q95", "stability", "container widths", "lower", 0, Infinity),
+	"pack.deterministic": spec("pack.deterministic", "determinism", "boolean", "higher", 0, 1),
+	"pack.search.widths": spec("pack.search.widths", "speed", "count", "lower", 0, Infinity),
+	"pack.search.ms": spec("pack.search.ms", "speed", "milliseconds", "lower", 0, Infinity)
+});
+/** This function gives the smallest rectangle around the boxes. No box gives a rectangle of size 0 at 0, 0. */
+function hullOf(boxes) {
+	if (boxes.length === 0) return {
+		x: 0,
+		y: 0,
+		w: 0,
+		h: 0
+	};
+	let left = Infinity;
+	let top = Infinity;
+	let right = -Infinity;
+	let bottom = -Infinity;
+	for (const b of boxes) {
+		left = Math.min(left, b.x);
+		top = Math.min(top, b.y);
+		right = Math.max(right, b.x + b.w);
+		bottom = Math.max(bottom, b.y + b.h);
+	}
+	return {
+		x: left,
+		y: top,
+		w: right - left,
+		h: bottom - top
+	};
+}
+/**
+* This function puts the boxes in rows. It sorts the boxes by their top, and keeps the order of the list for equal tops.
+* A box joins the last row when its top is within `tolerance` of the top of the first box of that row.
+*/
+function rowsOf$1(boxes, tolerance) {
+	const rows = [];
+	for (const b of boxes.toSorted((p, q) => p.y - q.y)) {
+		const row = rows.at(-1);
+		if (row && Math.abs(b.y - row.top) <= tolerance) {
+			row.right = Math.max(row.right, b.x + b.w);
+			row.count += 1;
+		} else rows.push({
+			top: b.y,
+			right: b.x + b.w,
+			count: 1
+		});
+	}
+	return rows;
+}
+/**
+* This function gives the placed boxes of an output, in the order of the items of the input. A box has the size of its
+* item after the turn. The list has no item without a placement, and no item with a width or a height of 0.
+*/
+function boxesOf$1(input, output) {
+	const placements = /* @__PURE__ */ new Map();
+	for (const p of output.placements) if (!placements.has(p.id)) placements.set(p.id, p);
+	const boxes = [];
+	for (const [index, item] of input.items.entries()) {
+		const p = placements.get(item.id);
+		if (p === void 0 || !(item.w > 0 && item.h > 0)) continue;
+		const turned = p.turn === 90;
+		boxes.push({
+			x: p.x,
+			y: p.y,
+			w: turned ? item.h : item.w,
+			h: turned ? item.w : item.h,
+			rank: item.rank ?? index
+		});
+	}
+	return boxes;
+}
+/**
+* This function tells if box `a` comes before box `b` in the reading order. Two boxes whose heights overlap by more than
+* `RECORD_EPS` are on one line, and the left box comes first. Otherwise the upper box comes first.
+*/
+function readsBefore(a, b) {
+	if (Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y) > .001) return a.x + RECORD_EPS < b.x;
+	return a.y < b.y;
+}
+/** This function sums one measure over the stages of a trace. A trace without the measure gives 0. */
+function traceSum(output, id) {
+	let sum = 0;
+	for (const stage of output.trace) sum += stage.measures[id] ?? 0;
+	return sum;
+}
+/**
+* This function gives the measures of one layout, by the ids of `docs/MEASURES.md`. The values are not rounded. A
+* record rounds them with `roundMeasures`.
+*
+* - The boxes are the placed items with a width and a height above 0. The hull is the smallest rectangle around them.
+* - An empty layout gives the area 0, the aspect 1 and the aspect error 0. Its fill is 0 and its whitespace is 1.
+* - The time `pack.search.ms` comes from the trace. It is not part of the determinism rule.
+*
+* @example
+* ```ts
+* const m = measure(input, packWith("shelf", input));
+* m["pack.fill"]; // the area of the boxes divided by the area of the hull
+* ```
+*/
+function measure(input, output, options = {}) {
+	const boxes = boxesOf$1(input, output);
+	const hull = hullOf(boxes);
+	const hullArea = hull.w * hull.h;
+	const boxArea = boxes.reduce((sum, b) => sum + b.w * b.h, 0);
+	const fill = hullArea > 0 ? boxArea / hullArea : 0;
+	const empty = boxes.length === 0;
+	const target = input.container.aspect ?? 1;
+	let pairs = 0;
+	let inversions = 0;
+	for (let i = 0; i < boxes.length; i++) for (let j = i + 1; j < boxes.length; j++) {
+		const a = boxes[i];
+		const b = boxes[j];
+		if (a.rank === b.rank) continue;
+		pairs += 1;
+		const first = a.rank < b.rank ? a : b;
+		if (readsBefore(first === a ? b : a, first)) inversions += 1;
+	}
+	const byRank = boxes.toSorted((a, b) => a.rank - b.rank);
+	let breaks = 0;
+	for (let k = 1; k < byRank.length; k++) {
+		const prev = byRank[k - 1];
+		const next = byRank[k];
+		if (prev.rank !== next.rank && readsBefore(next, prev)) breaks += 1;
+	}
+	const rights = rowsOf$1(boxes, options.rowTolerance ?? quantileOrZero(boxes.map((b) => b.h), .5) / 2).map((r) => r.right);
+	const spread = rights.length > 0 ? Math.max(...rights) - Math.min(...rights) : 0;
+	return {
+		"pack.area": hullArea,
+		"pack.fill": fill,
+		"pack.whitespace": 1 - fill,
+		"pack.aspect": empty ? 1 : Math.max(hull.w / hull.h, hull.h / hull.w),
+		"pack.aspectError": empty ? 0 : aspectError(hull.w, hull.h, target),
+		"pack.order.inversions": pairs > 0 ? inversions / pairs : 0,
+		"pack.order.breaks": breaks,
+		"pack.raggedness": hull.w > 0 ? spread / hull.w : 0,
+		"pack.overflow": new Set(output.overflow).size,
+		"pack.search.widths": traceSum(output, "pack.search.widths"),
+		"pack.search.ms": traceSum(output, "pack.search.ms")
+	};
+}
+/**
+* This function gives the stability measures of a change pair: the run on the base input and the run on the changed
+* input. The items match by id. The values are not rounded.
+*
+* - An item stays when both inputs have it and both outputs place it. The added and the removed items do not count.
+* - A staying item moved when its `x` or its `y` changed by more than `RECORD_EPS`, or when its turn changed.
+* - The distance of an item is the length of the move of its top-left corner. The unit is the width `W`.
+* - `W` is the larger width of the 2 output sizes. A `W` of 0 becomes 1, so the unit is then the unit of the input.
+* - No staying item gives 0 for each measure.
+*/
+function measureChange(baseInput, baseOutput, changeInput, changeOutput) {
+	const placed = (input, output) => {
+		const ids = new Set(input.items.map((i) => i.id));
+		const map = /* @__PURE__ */ new Map();
+		for (const p of output.placements) if (ids.has(p.id) && !map.has(p.id)) map.set(p.id, p);
+		return map;
+	};
+	const before = placed(baseInput, baseOutput);
+	const after = placed(changeInput, changeOutput);
+	const width = Math.max(baseOutput.size.w, changeOutput.size.w);
+	const unit = width > 0 ? width : 1;
+	const distances = [];
+	let moved = 0;
+	for (const [id, p] of before) {
+		const q = after.get(id);
+		if (q === void 0) continue;
+		const dx = q.x - p.x;
+		const dy = q.y - p.y;
+		if (Math.abs(dx) > .001 || Math.abs(dy) > .001 || (p.turn ?? 0) !== (q.turn ?? 0)) moved += 1;
+		distances.push(Math.hypot(dx, dy) / unit);
+	}
+	if (distances.length === 0) return {
+		"pack.stability.moved": 0,
+		"pack.stability.mean": 0,
+		"pack.stability.q95": 0
+	};
+	return {
+		"pack.stability.moved": moved / distances.length,
+		"pack.stability.mean": distances.reduce((sum, d) => sum + d, 0) / distances.length,
+		"pack.stability.q95": quantile(distances, .95)
+	};
+}
+/**
+* This function gives the measure `pack.deterministic` of two runs with the same input, options and seed. It gives
+* `true` when the runs have the same placements, overflow, size and moved obstacles.
+*
+* - The placements match by id, so their order in the list does not count. The numbers must be equal.
+* - The trace is not part of the rule, because its times change each time.
+*/
+function isDeterministic(first, second) {
+	const key = (list) => new Map(list.map((e) => [e.id, e]));
+	const samePlacements = (a, b) => {
+		if (a.length !== b.length) return false;
+		const other = key(b);
+		return a.every((p) => {
+			const q = other.get(p.id);
+			return q !== void 0 && q.x === p.x && q.y === p.y && (q.turn ?? 0) === (p.turn ?? 0);
+		});
+	};
+	const sameMoved = (a, b) => {
+		if (a.length !== b.length) return false;
+		const other = key(b);
+		return a.every((m) => {
+			const n = other.get(m.id);
+			return n !== void 0 && n.x === m.x && n.y === m.y;
+		});
+	};
+	const overflowA = new Set(first.overflow);
+	const overflowB = new Set(second.overflow);
+	return first.size.w === second.size.w && first.size.h === second.size.h && overflowA.size === overflowB.size && [...overflowA].every((id) => overflowB.has(id)) && samePlacements(first.placements, second.placements) && sameMoved(first.moved, second.moved);
+}
+/**
+* This function rounds each number of a record of measures with `round3`, as `docs/FORMAT.md` tells. A half goes up,
+* and `-0` becomes 0. The function keeps the other values, and it does not change its argument.
+*/
+function roundMeasures(measures) {
+	const out = {};
+	for (const [id, value] of Object.entries(measures)) out[id] = typeof value === "number" ? round3(value) : value;
+	return out;
+}
+/**
+* This function gives the paired ratio of a measure on one input: the value of the candidate against the value of the
+* current default. A ratio above 1 is worse, in the direction of the measure.
+*
+* - For `lower`, the ratio is `candidate / current`. For `higher`, it is `current / candidate`.
+* - When both values are 0, the ratio is 1. When only the divisor is 0, the ratio is `Infinity`.
+* - The values are 0 or more. A negative value or `NaN` throws a `RangeError`.
+*/
+function pairedRatio(candidate, current, direction) {
+	if (!(candidate >= 0 && current >= 0)) throw new RangeError("A paired ratio needs two values of 0 or more.");
+	const top = direction === "lower" ? candidate : current;
+	const bottom = direction === "lower" ? current : candidate;
+	if (bottom === 0) return top === 0 ? 1 : Infinity;
+	return top / bottom;
+}
+/**
+* This function gives the quantile `q` of a list of numbers, with linear interpolation between the sorted values. The
+* position in the sorted list is `(n - 1) * q`. An empty list or a `q` outside 0 to 1 throws a `RangeError`.
+*/
+function quantile(values, q) {
+	if (values.length === 0) throw new RangeError("A quantile needs one value or more.");
+	if (!(q >= 0 && q <= 1)) throw new RangeError("A quantile needs a q from 0 to 1.");
+	const sorted = values.toSorted((a, b) => a - b);
+	const at = (sorted.length - 1) * q;
+	const low = Math.floor(at);
+	const part = at - low;
+	const a = sorted[low];
+	if (part === 0) return a;
+	const b = sorted[low + 1];
+	if (a === b) return a;
+	return a + part * (b - a);
+}
+/** This function gives the quantile `q` of a list, and 0 for an empty list. */
+function quantileOrZero(values, q) {
+	return values.length === 0 ? 0 : quantile(values, q);
+}
+/** This function gives the median of the paired ratios of a corpus: the quantile 0.5. It is not a ratio of two medians. */
+function medianRatio(ratios) {
+	return quantile(ratios, .5);
+}
+/** This function gives the share of the paired ratios above a limit. An empty list throws a `RangeError`. */
+function tailShare(ratios, limit) {
+	if (ratios.length === 0) throw new RangeError("A tail share needs one ratio or more.");
+	return ratios.filter((r) => r > limit).length / ratios.length;
+}
+// src/metrics.ts
+/**
+* This function measures a packing. It gives the hull and its aspect, the rows and the raggedness of the right side.
+* It also gives the part of the hull that the rectangles cover, and the widest rectangle against the median width.
+*
+* @example
+* ```ts
+* const { utilization, raggedness } = packingMetrics(Rect.packed(cards));
+* ```
 */
-function turnItem(item) {
-	const turned = {
-		...item,
-		w: item.h,
-		h: item.w
+function packingMetrics(rects, options = {}) {
+	const tolerance = options.rowTolerance ?? 40;
+	const boxes = rects.filter((r) => r.size.x > 0 && r.size.y > 0).map((r) => ({
+		x: r.position.x,
+		y: r.position.y,
+		w: r.size.x,
+		h: r.size.y
+	}));
+	if (boxes.length === 0) return {
+		count: 0,
+		hull: {
+			width: 0,
+			height: 0
+		},
+		hullAspect: 0,
+		rows: [],
+		raggedness: 0,
+		utilization: 0,
+		widestOverMedian: 0
+	};
+	const box = hullOf(boxes);
+	const hull = {
+		width: box.w,
+		height: box.h
+	};
+	const rows = rowsOf$1(boxes, tolerance);
+	const rights = rows.map((row) => row.right);
+	const widths = boxes.map((r) => r.w).toSorted((a, b) => a - b);
+	const median = widths[Math.floor(widths.length / 2)] ?? 0;
+	const widest = widths.at(-1) ?? 0;
+	const area = boxes.reduce((sum, r) => sum + r.w * r.h, 0);
+	return {
+		count: boxes.length,
+		hull,
+		hullAspect: hull.height > 0 ? hull.width / hull.height : 0,
+		rows: rows.map((row) => row.count),
+		raggedness: Math.max(...rights) - Math.min(...rights),
+		utilization: hull.width * hull.height > 0 ? area / (hull.width * hull.height) : 0,
+		widestOverMedian: median > 0 ? widest / median : 0
 	};
-	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
 /**
@@ -1575,11 +2050,13 @@ function overlap(a, b, 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`.
+* - `in-container`: each item with its margin that goes out of a fixed side by more than `tolerance.overlap`. The inset of
+*   the container makes each fixed side smaller (decision 3 of `docs/PACKER.md`).
 * - `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.
+* The rules read a shape of the container, of an obstacle or of an item as its bounding box (decision 5). The bounding box
+* of an item shape is relative to the position of the item. The result has no tolerance in it.
 */
 function checkHard(input, output, tolerance = DEFAULT_TOLERANCE) {
 	const tol = tolerance.overlap;
@@ -1605,11 +2082,19 @@ function checkHard(input, output, tolerance = DEFAULT_TOLERANCE) {
 		}
 		const placed = p.turn === 90 ? turnItem(item) : item;
 		const m = marginOf(placed);
+		const area = placed.shape === void 0 ? {
+			x: 0,
+			y: 0,
+			w: placed.w,
+			h: placed.h
+		} : boundsOf(placed.shape);
+		const l = p.x + area.x;
+		const t = p.y + area.y;
 		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
+			l: l - m.left,
+			t: t - m.top,
+			r: l + area.w + m.right,
+			b: t + area.h + m.bottom
 		});
 	}
 	const moved = new Map(output.moved.map((m) => [m.id, m]));
@@ -1633,212 +2118,16 @@ function checkHard(input, output, tolerance = DEFAULT_TOLERANCE) {
 	const y = shape?.y ?? 0;
 	const w = shape?.w ?? container.w ?? Infinity;
 	const h = shape?.h ?? container.h ?? Infinity;
+	const inset = container.inset ?? 0;
 	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);
+		const outX = fixedW && (box.l < x + inset - tol || box.r > x + w - inset + tol);
+		const outY = fixedH && (box.t < y + inset - tol || box.b > y + h - inset + 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;
@@ -2751,6 +3040,6 @@ function corpus(name, specs) {
 		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 };
+export { DEFAULT_TOLERANCE, EPS, MEASURE_SPECS, RECORD_EPS, Rect, SORT_ORDERS, UnsupportedCell, Vector, aspectError, assertSupported, canonicalJson, cards, cellOf, checkHard, compareRects, corpus, countCell, createContext, dashboard, edgeCases, fnv1a32, fromRects, gallery, generator, generators, hashInput, isDeterministic, logSweep, lowestWindow, marginOf, measure, measureChange, medianRatio, mulberry32, pack, packFree, packRows, packShelf, packSkyline, packWith, packingMetrics, pairedRatio, push, pushCascade, quantile, rectGrid, rectScattered, round3, roundMeasures, rows, shelf, skyline, strategies, strategy, supportsCell, tailShare, toPackInput, toRects, turnItem, turnPoint, turnPort, turnRegion, unsupportedOf, wordCloud };
 
 //# sourceMappingURL=index.js.map