@mark1russell7/packing 0.1.2 → 0.1.3

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,990 @@ 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(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(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;
+}
+export { DEFAULT_TOLERANCE, EPS, RECORD_EPS, Rect, SORT_ORDERS, UnsupportedCell, Vector, aspectError, assertSupported, cellOf, checkHard, compareRects, createContext, fromRects, logSweep, lowestWindow, marginOf, mulberry32, pack, packFree, packRows, packShelf, packSkyline, packWith, packingMetrics, push, pushCascade, rows, shelf, skyline, strategies, strategy, supportsCell, toRects, turnItem, turnPoint, turnPort, turnRegion, unsupportedOf };
 
 //# sourceMappingURL=index.js.map