@mark1russell7/packing 0.2.3 → 0.2.5

package/build/index.js

@@ -138,16 +138,33 @@ var Rect = class {
 	}
 };
 // src/moves.ts
-/** The id of the characteristic move of each strategy. The trace of each strategy has its id, also with the count 0. */
+/** The id of the characteristic move of each strategy and of each shelf fit. The trace of each strategy has its id, also with the count 0. */
 const MOVES = Object.freeze({
 	/** A rectangle that the gap fill of `packRow` places in a gap of a row: under a shorter neighbor, or at the row break. */
 	rows: "move.gapFill",
-	/** A rectangle that `packShelf` puts on an open shelf with a taller rectangle. The strip above it stays empty. */
+	/**
+	* A rectangle that `packShelf` puts on an open shelf with a taller rectangle. The strip above it stays empty. With a
+	* `fit`, the move is a rectangle in the strip above a shorter rectangle of a shelf.
+	*/
 	shelf: "move.stack",
 	/** A rectangle that the skyline puts in a lower window, not in the leftmost window where it fits. */
 	skyline: "move.lowerWindow",
 	/** A rectangle that a push cascade moves. */
-	push: "move.cascade"
+	push: "move.cascade",
+	/** A rectangle that a shelf fit puts on a shelf that is not the open shelf. The open shelf is the last shelf that the packing opened. */
+	firstFit: "move.firstFit",
+	/** A rectangle that the fit `best` puts on a shelf that is not the first shelf where it fits. */
+	bestFit: "move.bestFit",
+	/** A rectangle that the rule `bssf` of `maxrects` puts in another place than the rule `bl` on the same free rectangles. */
+	bssf: "move.bssf",
+	/** A rectangle that the rule `blsf` of `maxrects` puts in another place than the rule `bl` on the same free rectangles. */
+	blsf: "move.blsf",
+	/** A rectangle that the rule `baf` of `maxrects` puts in another place than the rule `bl` on the same free rectangles. */
+	baf: "move.baf",
+	/** A rectangle that the rule `cp` of `maxrects` puts in another place than the rule `bl` on the same free rectangles. */
+	cp: "move.cp",
+	/** A rectangle of `maxrects` that cuts two free rectangles or more. A shelf or a skyline has no such step. */
+	split: "move.split"
 });
 const counts = /* @__PURE__ */ new Map();
 /** This function adds `n` to the count of a move. */
@@ -234,9 +251,10 @@ function byRank(items) {
 }
 /**
 * 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`.
+* rectangles. An obstacle with `move` is a free rectangle only when `movable` is `true`. With `turnable`, a turnable item
+* is too large only when it is too large in the two directions.
 */
-function buildFrame(input, movable = false) {
+function buildFrame(input, movable = false, turnable = false) {
 	const bounds = containerBounds(input);
 	const inset = input.container.inset ?? 0;
 	const half = (input.gap ?? 0) / 2;
@@ -255,7 +273,7 @@ function buildFrame(input, movable = false) {
 		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 + EPS || rect.size.y > h + EPS) {
+		} else if ((rect.size.x > w + EPS || rect.size.y > h + EPS) && !(turnable && item.turnable === true && rect.size.y <= w + EPS && rect.size.x <= h + EPS)) {
 			tooLarge.push(item.id);
 			continue;
 		}
@@ -304,10 +322,18 @@ function rectsOf(frame) {
 	return frame.entries.map((e) => e.rect);
 }
 /**
+* This function gives the turn of an item for a frame. A frame of `viaAxes` has the axes changed. The turn of the input
+* goes through that change, thus the item turns the other way in the frame.
+*/
+function frameTurn(transposed) {
+	return transposed ? (item) => transposeItem(turnItem(transposeItem(item))) : turnItem;
+}
+/**
 * 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.
+* position exactly. Each other item that the packer did not place goes to the overflow. With `turns`, each rectangle
+* that turned gives a placement with `turn: 90`.
 */
-function readFrame(input, frame, trace, moved = []) {
+function readFrame(input, frame, trace, moved = [], turns) {
 	const placements = [];
 	const overflow = [...frame.tooLarge];
 	for (const e of frame.entries) {
@@ -318,7 +344,16 @@ function readFrame(input, frame, trace, moved = []) {
 			x: item.x,
 			y: item.y
 		});
-		else if (e.rect.wasPacked) placements.push({
+		else if (e.rect.wasPacked && turns?.rects.has(e.rect) === true) {
+			const half = e.dx - marginOf(item).left;
+			const m = marginOf(turns.turn(item));
+			placements.push({
+				id: item.id,
+				x: e.rect.position.x + m.left + half + frame.ox,
+				y: e.rect.position.y + m.top + half + frame.oy,
+				turn: 90
+			});
+		} 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
@@ -328,7 +363,7 @@ function readFrame(input, frame, trace, moved = []) {
 	return {
 		placements,
 		overflow,
-		size: sizeOf(input, frame, placements, moved),
+		size: sizeOf(input, frame, placements, moved, turns),
 		moved,
 		trace
 	};
@@ -337,12 +372,13 @@ function readFrame(input, frame, trace, moved = []) {
 * 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) {
+function sizeOf(input, frame, placements, moved, turns) {
 	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 given = items.get(p.id);
+		const item = p.turn === 90 && turns !== void 0 ? turns.turn(given) : given;
 		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);
@@ -742,7 +778,7 @@ function spaceOf(input, frame) {
 		start,
 		end
 	}));
-	return {
+	const space = {
 		w: frame.w,
 		h: frame.h,
 		plain,
@@ -766,6 +802,33 @@ function spaceOf(input, frame) {
 			return nextOf(layer, y0, y1, w);
 		}
 	};
+	const bare = {
+		...layer,
+		holes: []
+	};
+	let bottom = 0;
+	for (const b of blockers) bottom = Math.max(bottom, b.c1 + Math.max(0, b.g));
+	PARTS.set(space, {
+		kind: layer.kind,
+		d,
+		holes: holes.map((r) => ({
+			x: r.a0,
+			y: r.c0,
+			w: r.a1 - r.a0,
+			h: r.c1 - r.c0
+		})),
+		bottom: Number.isFinite(frame.h) ? frame.h : bottom,
+		bare: (y0, y1) => spansOf(bare, y0, y1).map(([start, end]) => ({
+			start,
+			end
+		}))
+	});
+	return space;
+}
+const PARTS = /* @__PURE__ */ new WeakMap();
+/** This function gives the parts of a free space of `spaceOf`, or `undefined` for another free space. */
+function spaceParts(space) {
+	return PARTS.get(space);
 }
 /**
 * This function gives the free space of an input, in the coordinates of the frame of the adapters. The origin of the
@@ -774,7 +837,373 @@ function spaceOf(input, frame) {
 function freeSpace(input) {
 	return spaceOf(input, buildFrame(input));
 }
+// src/maxrects.ts
+/**
+* The rules of `maxrects` to choose a free rectangle for a box.
+*
+* - `bssf`: the best short side fit. The smaller leftover side is the smallest.
+* - `blsf`: the best long side fit. The larger leftover side is the smallest.
+* - `baf`: the best area fit. The leftover area is the smallest.
+* - `bl`: the bottom-left rule. The bottom edge of the box is the highest, then the left edge is the leftmost.
+* - `cp`: the contact point rule. The box touches the most length of the edges of the frame, the boxes and the obstacles.
+*/
+const MAXRECTS_RULES = Object.freeze([
+	"bssf",
+	"blsf",
+	"baf",
+	"bl",
+	"cp"
+]);
+/** The number of bands that the default band height gives. The default band height is the height to cut divided by this number. */
+const MAXRECTS_BANDS = 128;
+/** This function tells if the box `a` is fully in the box `b`. */
+function inside(a, b) {
+	return a.x0 >= b.x0 && a.y0 >= b.y0 && a.x1 <= b.x1 && a.y1 <= b.y1;
+}
+/**
+* This function cuts each free rectangle that the box `b` hits into at most four parts. A part with a side less than
+* `minW` or `minH` goes, because no box fits in it. A part that is in another rectangle of the list goes.
+* The function gives the new list and the number of free rectangles that the box hit.
+*/
+function cut(free, b, minW, minH) {
+	const kept = [];
+	const parts = [];
+	let hits = 0;
+	const add = (x0, y0, x1, y1) => {
+		if (x1 - x0 >= minW && y1 - y0 >= minH) parts.push({
+			x0,
+			y0,
+			x1,
+			y1
+		});
+	};
+	for (const f of free) {
+		if (b.x0 >= f.x1 || b.x1 <= f.x0 || b.y0 >= f.y1 || b.y1 <= f.y0) {
+			kept.push(f);
+			continue;
+		}
+		hits++;
+		if (b.x0 > f.x0) add(f.x0, f.y0, b.x0, f.y1);
+		if (b.x1 < f.x1) add(b.x1, f.y0, f.x1, f.y1);
+		if (b.y0 > f.y0) add(f.x0, f.y0, f.x1, b.y0);
+		if (b.y1 < f.y1) add(f.x0, b.y1, f.x1, f.y1);
+	}
+	const count = kept.length;
+	for (let i = 0; i < parts.length; i++) {
+		const p = parts[i];
+		let drop = false;
+		for (let j = 0; j < parts.length && !drop; j++) {
+			if (j === i) continue;
+			const q = parts[j];
+			if (inside(p, q) && (j < i || !inside(q, p))) drop = true;
+		}
+		for (let k = 0; k < count && !drop; k++) if (inside(p, kept[k])) drop = true;
+		if (!drop) kept.push(p);
+	}
+	return {
+		free: kept,
+		hits
+	};
+}
+/** This function adds a range to the edges at a coordinate. */
+function addEdge(edges, at, a, b) {
+	const list = edges.get(at);
+	if (list === void 0) edges.set(at, [a, b]);
+	else list.push(a, b);
+}
+/** This function gives the length of the common part of the range from `a` to `b` and the edges at a coordinate. */
+function touch(edges, at, a, b) {
+	const list = edges.get(at);
+	if (list === void 0) return 0;
+	let sum = 0;
+	for (let i = 0; i < list.length; i += 2) sum += Math.max(0, Math.min(b, list[i + 1]) - Math.max(a, list[i]));
+	return sum;
+}
+/**
+* This function gives the walls of a space that is not plain: the parts of the bands that are not free. The bands cut the
+* height from 0 to `top`. Two walls of neighbour bands with the same span become one wall.
+*/
+function bandWalls(query, w, top, bandHeight, grow, end) {
+	const walls = [];
+	const count = Math.max(1, Math.ceil(top / bandHeight));
+	let open = /* @__PURE__ */ new Map();
+	for (let k = 0; k < count; k++) {
+		const y0 = top * k / count;
+		const y1 = k === count - 1 ? top : top * (k + 1) / count;
+		const spans = query(Math.max(0, y0 - grow), Math.min(end, y1 + grow));
+		const next = /* @__PURE__ */ new Map();
+		let x = 0;
+		const block = (a, b) => {
+			if (!(b > a)) return;
+			const key = `${a}|${b}`;
+			const wall = open.get(key);
+			if (wall !== void 0) {
+				wall.y1 = y1;
+				open.delete(key);
+				next.set(key, wall);
+			} else next.set(key, {
+				x0: a,
+				y0,
+				x1: b,
+				y1
+			});
+		};
+		for (const s of spans) {
+			const start = Math.max(0, Math.min(w, s.start));
+			const stop = Math.max(0, Math.min(w, s.end));
+			if (!(stop > start)) continue;
+			block(x, start);
+			x = Math.max(x, stop);
+		}
+		block(x, w);
+		walls.push(...open.values());
+		open = next;
+	}
+	walls.push(...open.values());
+	return walls;
+}
+/**
+* This function packs rectangles with MaxRects, as `packMaxRects` tells. It also gives the free rectangles at the end.
+* The tests read them. The package root does not export this function.
+*/
+function runMaxRects(rects, outer, options = {}) {
+	const rule = options.rule ?? "bssf";
+	if (!MAXRECTS_RULES.includes(rule)) throw new RangeError(`The rule of maxrects is one of ${MAXRECTS_RULES.join(", ")}, not "${String(rule)}".`);
+	const turned = options.turned;
+	if (turned !== void 0) {
+		for (const r of rects) if (turned.has(r)) r.size.set(r.size.y, r.size.x);
+		turned.clear();
+	}
+	for (const r of rects) if (r.locked) r.wasPacked = true;
+	const W = outer.size.x;
+	if (!(W > 0)) return {
+		outer,
+		free: []
+	};
+	const ox = outer.position.x;
+	const oy = outer.position.y;
+	const fixed = outer.fixedSize;
+	const space = options.space;
+	const parts = space === void 0 ? void 0 : spaceParts(space);
+	const turnable = options.turnable;
+	const sorted = rects.toSorted(compareRects(options.sortOrder ?? "height-desc")).filter((r) => !r.wasPacked && r.size.x > 0 && r.size.y > 0);
+	let minW = Infinity;
+	let minH = Infinity;
+	let heights = 0;
+	for (const r of sorted) {
+		const turns = turnable?.has(r) === true;
+		const short = Math.min(r.size.x, r.size.y);
+		minW = Math.min(minW, turns ? short : r.size.x);
+		minH = Math.min(minH, turns ? short : r.size.y);
+		heights += turns ? Math.max(r.size.x, r.size.y) : r.size.y;
+	}
+	const holes = [];
+	if (parts !== void 0) for (const h of parts.holes) holes.push({
+		x0: h.x - ox,
+		y0: h.y - oy,
+		x1: h.x + h.w - ox,
+		y1: h.y + h.h - oy
+	});
+	else if (space === void 0 || space.plain) {
+		for (const r of rects) if (r.locked) holes.push({
+			x0: r.position.x - ox,
+			y0: r.position.y - oy,
+			x1: r.right() - ox,
+			y1: r.bottom() - oy
+		});
+	}
+	let floor = parts?.bottom ?? 0;
+	for (const h of holes) floor = Math.max(floor, h.y1);
+	const H = fixed ? outer.size.y : floor + heights;
+	const walls = [];
+	for (const h of holes) {
+		const wall = {
+			x0: Math.max(0, h.x0),
+			y0: Math.max(0, h.y0),
+			x1: Math.min(W, h.x1),
+			y1: Math.min(H, h.y1)
+		};
+		if (wall.x1 > wall.x0 && wall.y1 > wall.y0) walls.push(wall);
+	}
+	if (space !== void 0 && !space.plain) {
+		const top = parts === void 0 ? H : fixed ? H : Math.min(H, parts.bottom);
+		if (top > 0) {
+			const bandHeight = options.bandHeight ?? top / 128;
+			if (!(bandHeight > 0)) throw new RangeError(`The band height of maxrects is more than 0, not ${String(bandHeight)}.`);
+			const query = parts === void 0 ? (y0, y1) => space.band(y0 + oy, y1 + oy) : (y0, y1) => parts.bare(y0 + oy, y1 + oy);
+			const shifted = (y0, y1) => query(y0, y1).map((s) => ({
+				start: s.start - ox,
+				end: s.end - ox
+			}));
+			walls.push(...bandWalls(shifted, W, top, bandHeight, parts === void 0 ? 0 : Math.max(0, -parts.d), fixed ? H : Infinity));
+		}
+	}
+	let free = [{
+		x0: 0,
+		y0: 0,
+		x1: W,
+		y1: H
+	}];
+	for (const wall of walls) free = cut(free, wall, minW, minH).free;
+	const cp = rule === "cp";
+	const vertical = /* @__PURE__ */ new Map();
+	const horizontal = /* @__PURE__ */ new Map();
+	const mark = (b) => {
+		if (!cp) return;
+		addEdge(vertical, b.x0, b.y0, b.y1);
+		addEdge(vertical, b.x1, b.y0, b.y1);
+		addEdge(horizontal, b.y0, b.x0, b.x1);
+		addEdge(horizontal, b.y1, b.x0, b.x1);
+	};
+	for (const wall of walls) mark(wall);
+	const contact = (x, y, w, h) => {
+		let sum = 0;
+		if (x === 0) sum += h;
+		if (x + w === W) sum += h;
+		if (y === 0) sum += w;
+		if (fixed && y + h === H) sum += w;
+		return sum + touch(vertical, x, y, y + h) + touch(vertical, x + w, y, y + h) + touch(horizontal, y, x, x + w) + touch(horizontal, y + h, x, x + w);
+	};
+	const check = space !== void 0 && !space.plain;
+	let bottom = 0;
+	for (const wall of walls) bottom = Math.max(bottom, wall.y1);
+	for (const rect of sorted) {
+		const w = rect.size.x;
+		const h = rect.size.y;
+		const turns = turnable?.has(rect) === true && w !== h;
+		const banned = /* @__PURE__ */ new Set();
+		let best;
+		let low;
+		for (;;) {
+			best = void 0;
+			low = void 0;
+			for (let i = 0; i < free.length; i++) {
+				const f = free[i];
+				for (let t = 0; t < (turns ? 2 : 1); t++) {
+					if (banned.has(2 * i + t)) continue;
+					const bw = t === 1 ? h : w;
+					const bh = t === 1 ? w : h;
+					if (f.x0 + bw > f.x1 || f.y0 + bh > f.y1) continue;
+					const lw = f.x1 - f.x0 - bw;
+					const lh = f.y1 - f.y0 - bh;
+					let s1;
+					let s2;
+					switch (rule) {
+						case "bssf":
+							s1 = Math.min(lw, lh);
+							s2 = Math.max(lw, lh);
+							break;
+						case "blsf":
+							s1 = Math.max(lw, lh);
+							s2 = Math.min(lw, lh);
+							break;
+						case "baf":
+							s1 = (f.x1 - f.x0) * (f.y1 - f.y0) - bw * bh;
+							s2 = Math.min(lw, lh);
+							break;
+						case "bl":
+							s1 = f.y0 + bh;
+							s2 = f.x0;
+							break;
+						case "cp":
+							s1 = -contact(f.x0, f.y0, bw, bh);
+							s2 = f.y0 + bh;
+					}
+					const c = {
+						index: i,
+						turn: t === 1,
+						x: f.x0,
+						y: f.y0,
+						w: bw,
+						h: bh,
+						s1,
+						s2
+					};
+					if (best === void 0 || s1 < best.s1 || s1 === best.s1 && (s2 < best.s2 || s2 === best.s2 && (c.y < best.y || c.y === best.y && c.x < best.x))) best = c;
+					const ly = f.y0 + bh;
+					if (low === void 0 || ly < low.s1 || ly === low.s1 && f.x0 < low.s2) low = {
+						...c,
+						s1: ly,
+						s2: f.x0
+					};
+				}
+			}
+			if (best === void 0 || !check || space.fits({
+				x: best.x + ox,
+				y: best.y + oy,
+				w: best.w,
+				h: best.h
+			})) break;
+			banned.add(2 * best.index + (best.turn ? 1 : 0));
+		}
+		let place;
+		if (best !== void 0) {
+			place = {
+				x0: best.x,
+				y0: best.y,
+				x1: best.x + best.w,
+				y1: best.y + best.h
+			};
+			if (rule !== "bl" && low !== void 0 && (low.x !== best.x || low.y !== best.y || low.turn !== best.turn)) countMove(MOVES[rule]);
+			if (best.turn) {
+				rect.size.set(best.w, best.h);
+				turned?.add(rect);
+			}
+		} else {
+			if (fixed) continue;
+			place = {
+				x0: 0,
+				y0: bottom,
+				x1: w,
+				y1: bottom + h
+			};
+		}
+		rect.position.set(place.x0 + ox, place.y0 + oy);
+		rect.wasPacked = true;
+		bottom = Math.max(bottom, place.y1);
+		const result = cut(free, {
+			x0: place.x0,
+			y0: place.y0,
+			x1: Math.min(W, place.x1),
+			y1: place.y1
+		}, minW, minH);
+		free = result.free;
+		if (result.hits >= 2) countMove(MOVES.split);
+		mark(place);
+		if (!fixed) outer.size.y = Math.max(outer.size.y, place.y1);
+	}
+	return {
+		outer,
+		free: free.map((f) => ({
+			x: f.x0 + ox,
+			y: f.y0 + oy,
+			w: f.x1 - f.x0,
+			h: f.y1 - f.y0
+		}))
+	};
+}
+/**
+* This function packs rectangles into an outer rectangle with MaxRects of Jylänki (2010). It keeps the list of the maximal
+* free rectangles, and it does not change the width of the outer rectangle.
+*
+* - Each box goes to the top-left corner of the free rectangle that `options.rule` chooses. `MAXRECTS_RULES` tells the rules.
+* - A tie goes to the higher place, then to the place on the left, then to the first free rectangle of the list.
+* - A `locked` rectangle keeps its position, and the free rectangles go around it.
+* - With a space that is not plain, the free rectangles start from bands of the outline. `MaxRectsOptions` tells the bands.
+* - Without `fixedSize`, the height of the outer rectangle grows to the content. With `fixedSize`, a box that does not fit
+*   is not packed: its `wasPacked` stays `false`.
+* - The default sort order is `height-desc`. The order of the array of the caller stays.
+*/
+function packMaxRects(rects, outer, options = {}) {
+	return runMaxRects(rects, outer, options).outer;
+}
 // src/shelf.ts
+/** This constant lists each shelf fit. */
+const SHELF_FITS = [
+	"next",
+	"first",
+	"best"
+];
 /**
 * This function gives the first x from `start` where a rectangle of width `w` crosses no obstacle in the band from
 * `top` to `bottom`.
@@ -809,8 +1238,10 @@ function nextTop(obstacles, top, bottom) {
 * - It does not change the width. Without `fixedSize`, the height grows to the content. With `fixedSize`, a
 *   rectangle that does not fit is not packed: its `wasPacked` stays `false`.
 * - With a space that is not plain, `packRowsInSpace` packs the rows into the outline of the space and around its holes.
+* - With `fit`, `packShelvesInSpace` packs the rectangles, in each container shape. A `fit` that is not in `SHELF_FITS` throws a `RangeError`.
 */
 function packShelf(rects, outer, options = {}) {
+	if (options.fit !== void 0) return packShelvesInSpace(rects, outer, options.sortOrder ?? "height-desc", options.fit, options.space);
 	if (options.space !== void 0 && !options.space.plain) return packRowsInSpace(rects, outer, options.sortOrder ?? "height-desc", options.space);
 	const width = outer.size.x;
 	const obstacles = [];
@@ -973,6 +1404,181 @@ function packRowsInSpace(rects, outer, order, space) {
 	if (!outer.fixedSize) outer.size.y = Math.max(outer.size.y, contentBottom);
 	return outer;
 }
+/**
+* This function packs rectangles into shelves with a fit: `next`, `first` or `best`. `packShelf` uses it when its
+* options have a `fit`. It sets the position of each rectangle and gives the outer rectangle.
+*
+* - A shelf opens at the bottom edge of the last shelf, at the first x where the rectangle fits in the free space.
+*   When no x fits, the shelf steps down to `nextY` of the space, as an empty row of `packRowsInSpace` does.
+* - The first rectangle of a shelf sets its height. A rectangle goes on the floor of a shelf at its cursor, or into
+*   the strip above a shorter rectangle of the shelf. The strip is the move `move.stack`.
+* - The fit `next` uses only the open shelf: the last shelf that the packing opened. The fit `first` uses the first
+*   shelf from the top where the rectangle fits. The fit `best` uses the place with the least height left over.
+* - In a shelf, the rectangle takes the place with the least height left over. A tie goes to a strip, from left to right.
+* - When no shelf has a place, the last shelf grows for a taller rectangle, if it fits. Else a new shelf opens.
+* - A rectangle wider than the outer rectangle overflows. Without `fixedSize`, it goes on a closed shelf of its own at the left edge.
+* - Each place is in the free space and crosses no locked rectangle. Without a space, the outer rectangle and the
+*   locked rectangles give the free space.
+*/
+function packShelvesInSpace(rects, outer, order, fit, space) {
+	if (!SHELF_FITS.includes(fit)) throw new RangeError(`The shelf fit "${String(fit)}" is not one of ${SHELF_FITS.join(", ")}.`);
+	const width = outer.size.x;
+	const ox = outer.position.x;
+	const oy = outer.position.y;
+	const limit = outer.fixedSize ? outer.size.y : Infinity;
+	const obstacles = [];
+	let contentBottom = 0;
+	for (const rect of rects) {
+		if (!rect.locked) continue;
+		rect.wasPacked = true;
+		const left = rect.position.x - ox;
+		const top = rect.position.y - oy;
+		obstacles.push({
+			left,
+			top,
+			right: left + rect.size.x,
+			bottom: top + rect.size.y
+		});
+		contentBottom = Math.max(contentBottom, top + rect.size.y);
+	}
+	const whole = [{
+		start: 0,
+		end: Infinity
+	}];
+	const place = (start, w, top, h) => {
+		const spans = space === void 0 ? whole : space.band(top + oy, top + h + oy).map((s) => ({
+			start: s.start - ox,
+			end: s.end - ox
+		}));
+		return placeInBand(obstacles, spans, start, w, top, top + h);
+	};
+	const stepDown = (top, w, h) => Math.min(space === void 0 ? Infinity : space.nextY(top + oy, top + h + oy, w) - oy, nextTop(obstacles, top, top + h));
+	const spotsOn = (shelf, w, h, grow) => {
+		const ceiling = shelf.top + shelf.height;
+		const spots = [];
+		if (!grow) {
+			for (const strip of shelf.strips) if (w <= strip.w && strip.bottom + h <= ceiling) spots.push({
+				shelf,
+				x: strip.x,
+				y: strip.bottom,
+				left: ceiling - strip.bottom - h,
+				strip
+			});
+		}
+		const tall = grow ? h > shelf.height && shelf.top + h <= limit : h <= shelf.height;
+		if (Number.isFinite(shelf.cursor) && tall) spots.push({
+			shelf,
+			x: shelf.cursor,
+			y: shelf.top,
+			left: grow ? 0 : shelf.height - h,
+			...grow ? { grow } : {}
+		});
+		return spots.toSorted((a, b) => a.left - b.left);
+	};
+	const verify = (spot, w, h) => {
+		const x = place(spot.x, w, spot.y, h);
+		if (spot.strip !== void 0) return x === spot.x ? spot : void 0;
+		return x + w <= width ? {
+			...spot,
+			x
+		} : void 0;
+	};
+	const firstOn = (shelf, w, h) => {
+		for (const spot of spotsOn(shelf, w, h, false)) {
+			const found = verify(spot, w, h);
+			if (found !== void 0) return found;
+		}
+	};
+	const shelves = [];
+	for (const rect of rects.toSorted(compareRects(order))) {
+		if (rect.wasPacked) continue;
+		const w = rect.size.x;
+		const h = rect.size.y;
+		if (!(w > 0 && h > 0)) continue;
+		const open = shelves.at(-1);
+		const floor = open === void 0 ? 0 : open.top + open.height;
+		if (w > width) {
+			if (outer.fixedSize) continue;
+			let top = floor;
+			while (firstFreeX(obstacles, 0, w, top, top + h) !== 0) {
+				const next = nextTop(obstacles, top, top + h);
+				if (!Number.isFinite(next)) break;
+				top = next;
+			}
+			rect.position.set(ox, top + oy);
+			rect.wasPacked = true;
+			shelves.push({
+				top,
+				height: h,
+				cursor: Infinity,
+				strips: []
+			});
+			contentBottom = Math.max(contentBottom, top + h);
+			continue;
+		}
+		let spot;
+		let firstShelf;
+		if (fit === "best") {
+			for (const s of shelves.flatMap((shelf) => spotsOn(shelf, w, h, false)).toSorted((a, b) => a.left - b.left)) {
+				spot = verify(s, w, h);
+				if (spot !== void 0) break;
+			}
+			if (spot !== void 0) firstShelf = shelves.find((shelf) => shelf === spot.shelf || firstOn(shelf, w, h) !== void 0);
+		} else for (const shelf of fit === "next" ? shelves.slice(-1) : shelves) {
+			spot = firstOn(shelf, w, h);
+			if (spot !== void 0) break;
+		}
+		if (spot === void 0 && open !== void 0) {
+			const grown = spotsOn(open, w, h, true)[0];
+			if (grown !== void 0) spot = verify(grown, w, h);
+		}
+		if (spot === void 0) {
+			let top = floor;
+			let x = place(0, w, top, h);
+			while (!(x + w <= width) && top + h <= limit) {
+				const next = stepDown(top, w, h);
+				if (!Number.isFinite(next)) break;
+				top = next;
+				x = place(0, w, top, h);
+			}
+			if (!(x + w <= width) || top + h > limit) continue;
+			const shelf = {
+				top,
+				height: h,
+				cursor: x,
+				strips: []
+			};
+			shelves.push(shelf);
+			spot = {
+				shelf,
+				x,
+				y: top,
+				left: 0
+			};
+		} else {
+			if (spot.shelf !== open) countMove(MOVES.firstFit);
+			if (firstShelf !== void 0 && spot.shelf !== firstShelf) countMove(MOVES.bestFit);
+		}
+		const { shelf } = spot;
+		rect.position.set(spot.x + ox, spot.y + oy);
+		rect.wasPacked = true;
+		if (spot.strip !== void 0) {
+			countMove(MOVES.shelf);
+			spot.strip.bottom = spot.y + h;
+		} else {
+			shelf.cursor = spot.x + w;
+			shelf.strips.push({
+				x: spot.x,
+				w,
+				bottom: spot.y + h
+			});
+			if (spot.grow === true) shelf.height = h;
+		}
+		contentBottom = Math.max(contentBottom, spot.y + h);
+	}
+	if (!outer.fixedSize) outer.size.y = Math.max(outer.size.y, contentBottom);
+	return outer;
+}
 // src/skyline.ts
 /**
 * This function finds the lowest window of width `rw` on a skyline. For each `x` in `[0, width - rw]`, the height
@@ -1256,7 +1862,7 @@ function packRows(rects, outer, options = {}) {
 *   This width is not less than the width of the widest rectangle. The height grows until all rectangles fit.
 * - With `fixedWidth`, the width stays. A rectangle wider than that width goes on its own row and overflows.
 * - With `fixedSize`, a rectangle that does not fit is not packed: its `wasPacked` stays `false`.
-* - `options.strategy` selects `packRows` (the default), `packSkyline` or `packShelf` after the width is set.
+* - `options.strategy` selects `packRows` (the default), `packSkyline`, `packShelf` or `packMaxRects` after the width is set.
 */
 function pack(rects, outer = new Rect(), options = {}) {
 	let totalArea = 0;
@@ -1274,6 +1880,7 @@ function pack(rects, outer = new Rect(), options = {}) {
 	if (!outer.fixedSize) outer.size.setTo(outer.fixedWidth ? new Vector(outer.size.x, ideal.y) : ideal);
 	if (options.strategy === "skyline") packSkyline(rects, outer, options);
 	else if (options.strategy === "shelf") packShelf(rects, outer, options);
+	else if (options.strategy === "maxrects") packMaxRects(rects, outer, options);
 	else packRows(rects, outer, options);
 	if (!outer.fixedSize) {
 		const contentRight = Rect.maxRight(rects);
@@ -1993,6 +2600,8 @@ const REL = Object.freeze({ rel: .01 });
 * - A share of an area from 0 to 1 has 0.005. A guard has its tolerance.
 * - An area and a ratio of lengths have `{ rel: 0.01 }`: 1% of the larger value.
 * - The time has no minimum effect, because the times of CI change each time.
+* - `pack.overflow.forcedAreaMin` is a deprecated alias of `pack.overflow.forcedArea`. Its spec is the same, except the id.
+*   The alias stays until the next minor version.
 */
 const MEASURE_SPECS = Object.freeze({
 	"pack.area": spec("pack.area", "density", "square units", "lower", 0, Infinity, REL),
@@ -2125,7 +2734,8 @@ function traceSum(output, id) {
 * - The time `pack.search.ms` comes from the trace. It is not part of the determinism rule.
 * - The overflow measures count each id once. `pack.overflow.forced` is the lower bound of `overflowBound`.
 * - `pack.overflow.excess` is the overflow less the forced overflow. A container with no fixed side gives 0 for both.
-* - `pack.overflow.forcedAreaMin` is a lower bound of the overflow area. `pack.overflow.excessArea` is the overflow area above it.
+* - `pack.overflow.forcedArea` is a lower bound of the overflow area. `pack.overflow.excessArea` is the overflow area above it.
+* - `pack.overflow.forcedAreaMin` is a deprecated alias of `pack.overflow.forcedArea`, with the same value.
 *
 * @example
 * ```ts
@@ -2170,7 +2780,7 @@ function measure(input, output, options = {}) {
 	}
 	const bound = overflowBound(input);
 	const overflowArea = itemArea > 0 ? unplacedArea / itemArea : 0;
-	const forcedAreaMin = itemArea > 0 ? Math.min(1, bound.area / itemArea) : 0;
+	const forcedArea = itemArea > 0 ? Math.min(1, bound.area / itemArea) : 0;
 	return {
 		"pack.area": hullArea,
 		"pack.fill": fill,
@@ -2184,10 +2794,10 @@ function measure(input, output, options = {}) {
 		"pack.overflow.rate": input.items.length > 0 ? unplaced.size / input.items.length : 0,
 		"pack.overflow.area": overflowArea,
 		"pack.overflow.forced": bound.forced,
-		"pack.overflow.forcedArea": forcedAreaMin,
+		"pack.overflow.forcedArea": forcedArea,
 		"pack.overflow.excess": Math.max(0, unplaced.size - bound.forced),
-		"pack.overflow.forcedAreaMin": forcedAreaMin,
-		"pack.overflow.excessArea": excessAreaOf(overflowArea, forcedAreaMin),
+		"pack.overflow.forcedAreaMin": forcedArea,
+		"pack.overflow.excessArea": excessAreaOf(overflowArea, forcedArea),
 		"pack.search.widths": traceSum(output, "pack.search.widths"),
 		"pack.search.ms": traceSum(output, "pack.search.ms")
 	};
@@ -2196,8 +2806,8 @@ function measure(input, output, options = {}) {
 * This function gives the overflow area above its lower bound. A value from `-AREA_NOISE` to 0 becomes 0. A value below
 * `-AREA_NOISE` stays, because it shows a bug of the bound or of the packer.
 */
-function excessAreaOf(overflowArea, forcedAreaMin) {
-	const excess = overflowArea - forcedAreaMin;
+function excessAreaOf(overflowArea, forcedArea) {
+	const excess = overflowArea - forcedArea;
 	return excess < 0 && excess >= -1e-9 ? 0 : excess;
 }
 /**
@@ -2544,18 +3154,61 @@ function supportsOf(cells) {
 		mode: [...cells.mode]
 	};
 }
+/**
+* This function gives the options of `pack` that a strategy adds: the fit of `shelf`, or the rule, the bands and the turns
+* of `maxrects`. A turnable item turns only with `rotate`, and a locked item does not turn.
+*/
+function extrasOf(id, options, frame) {
+	if (id === "shelf") return options.fit !== void 0 ? { fit: options.fit } : {};
+	if (id !== "maxrects") return {};
+	const out = {
+		rule: options.rule ?? "bssf",
+		...options.bandHeight === void 0 ? {} : { bandHeight: options.bandHeight }
+	};
+	if (options.rotate !== true) return out;
+	const turnable = new Set(frame.entries.filter((e) => e.item?.turnable === true && !e.rect.locked).map((e) => e.rect));
+	return {
+		...out,
+		turnable,
+		turned: /* @__PURE__ */ new Set()
+	};
+}
+/**
+* This function gives the move counts of the trace of a strategy: its own move, and the moves of a shelf fit. The trace of
+* `maxrects` has the move of its rule and `move.split`. The rule `bl` has only `move.split`.
+*/
+function movesOf(id, extras) {
+	if (id === "maxrects") {
+		const rule = extras.rule ?? "bssf";
+		const out = rule === "bl" ? {} : { [MOVES[rule]]: moveCount(MOVES[rule]) };
+		out[MOVES.split] = moveCount(MOVES.split);
+		return out;
+	}
+	const out = { [MOVES[id]]: moveCount(MOVES[id]) };
+	if (extras.fit !== void 0) for (const move of [MOVES.firstFit, MOVES.bestFit]) out[move] = moveCount(move);
+	return out;
+}
+/** This function gives the turns of a packing for `readFrame`, or `undefined` when no rectangle can turn. */
+function turnsOf(extras, transposed) {
+	return extras.turned === void 0 ? void 0 : {
+		rects: extras.turned,
+		turn: frameTurn(transposed)
+	};
+}
 /** This function packs an input with a fixed size or a fixed width with one strategy of `pack`. */
-function packFixedWidth(id, input, options) {
+function packFixedWidth(id, input, options, transposed = false) {
 	const start = now();
-	const frame = buildFrame(input);
+	const frame = buildFrame(input, false, id === "maxrects" && options.rotate === true);
 	const rects = rectsOf(frame);
+	const extras = extrasOf(id, options, frame);
 	clearMoves();
 	if (frame.w > 0) pack(rects, outerOf(frame), {
 		strategy: id,
 		sortOrder: options.sortOrder,
-		space: spaceOf(input, frame)
+		space: spaceOf(input, frame),
+		...extras
 	});
-	const output = readFrame(input, frame, []);
+	const output = readFrame(input, frame, [], [], turnsOf(extras, transposed));
 	return {
 		...output,
 		trace: [{
@@ -2563,13 +3216,13 @@ function packFixedWidth(id, input, options) {
 			ms: now() - start,
 			measures: {
 				"pack.overflow": output.overflow.length,
-				[MOVES[id]]: moveCount(MOVES[id])
+				...movesOf(id, extras)
 			}
 		}]
 	};
 }
 /** This function makes the strategy of one function of `pack`. */
-function layoutStrategy(id, family, catalog, cells) {
+function layoutStrategy(id, family, catalog, cells, defaults) {
 	const self = {
 		id,
 		family,
@@ -2578,10 +3231,7 @@ function layoutStrategy(id, family, catalog, cells) {
 			...LAYOUT_CELLS,
 			...cells
 		}),
-		defaults: {
-			sortOrder: "height-desc",
-			samples: 48
-		},
+		defaults: { ...defaults },
 		deterministic: true,
 		pack(input, options, context) {
 			assertSupported(self.supports, input);
@@ -2590,7 +3240,7 @@ function layoutStrategy(id, family, catalog, cells) {
 				...options
 			};
 			switch (input.container.fixed) {
-				case "height": return viaAxes(input, context.previous, (turned) => packFixedWidth(id, turned, o));
+				case "height": return viaAxes(input, context.previous, (turned) => packFixedWidth(id, turned, o, true));
 				case "none": return logSweep.search(input, self, context, o);
 				default: return packFixedWidth(id, input, o);
 			}
@@ -2598,6 +3248,11 @@ function layoutStrategy(id, family, catalog, cells) {
 	};
 	return self;
 }
+/** The defaults of `rows`, `skyline` and `shelf`. */
+const LAYOUT_DEFAULTS = {
+	sortOrder: "height-desc",
+	samples: 48
+};
 /**
 * The strategy `rows` uses `packRows`: a guillotine row packing with a recursive gap fill. With obstacles, locked items or a
 * container shape, the rows go around the holes of the free space and lose the gap fill. Turnable items, groups and item
@@ -2610,7 +3265,7 @@ const rows = layoutStrategy("rows", "shelf", ["rows-gap-fill", "rows-input"], {
 		"soft",
 		"hard"
 	]
-});
+}, LAYOUT_DEFAULTS);
 /**
 * 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, in each container shape. Turnable items, groups and item shapes throw `UnsupportedCell`.
@@ -2618,10 +3273,11 @@ const rows = layoutStrategy("rows", "shelf", ["rows-gap-fill", "rows-input"], {
 const skyline = layoutStrategy("skyline", "skyline", ["skyline-bl"], {
 	obstacleMove: ["fixed"],
 	order: ["free", "soft"]
-});
+}, LAYOUT_DEFAULTS);
 /**
 * 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 item shapes throw `UnsupportedCell`.
+* The option `fit` selects a shelf rule of roadmap item k21: `next`, `first` or `best`. The default has no `fit`.
 */
 const shelf = layoutStrategy("shelf", "shelf", ["shelf-nf", "shelf-nfdh"], {
 	obstacleMove: ["fixed"],
@@ -2630,34 +3286,60 @@ const shelf = layoutStrategy("shelf", "shelf", ["shelf-nf", "shelf-nfdh"], {
 		"soft",
 		"hard"
 	]
+}, LAYOUT_DEFAULTS);
+/**
+* The strategy `maxrects` uses `packMaxRects`: the MaxRects packer of roadmap item k24. It keeps the list of the maximal
+* free rectangles, and the option `rule` chooses the free rectangle for each item. The default rule is `bssf`.
+*
+* - The free rectangles go around the locked items and the fixed obstacles. A plain rectangle container gives exact free
+*   rectangles. Another shape gives an inner approximation with horizontal bands.
+* - With `rotate`, each turnable item that is not locked can turn by 90 degrees. Groups and item shapes throw `UnsupportedCell`.
+*/
+const maxrects = layoutStrategy("maxrects", "maxrects", [
+	"maxrects-bssf",
+	"maxrects-blsf",
+	"maxrects-baf",
+	"maxrects-bl",
+	"maxrects-cp",
+	"maxrects-locked"
+], {
+	obstacleMove: ["fixed"],
+	order: ["free", "soft"],
+	rotation: ["none", "quarter"]
+}, {
+	...LAYOUT_DEFAULTS,
+	rule: "bssf",
+	rotate: false
 });
 /**
 * 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`.
+* wraps `rows`, `skyline`, `shelf` and `maxrects`. 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);
+		if (id !== "rows" && id !== "skyline" && id !== "shelf" && id !== "maxrects") throw new UnsupportedCell("containerSize", cellOf(input).containerSize);
 		const o = {
 			...inner.defaults,
 			...options
 		};
 		const start = now();
-		const frame = buildFrame(input);
+		const frame = buildFrame(input, false, id === "maxrects" && o.rotate === true);
+		const extras = extrasOf(id, o, frame);
 		const result = packFree(rectsOf(frame), new Rect(), {
 			strategy: id,
 			sortOrder: o.sortOrder,
 			space: spaceOf(input, frame),
 			samples: o.samples,
 			aspect: input.container.aspect ?? 1,
-			aspectWeight: input.container.aspectWeight ?? 1
+			aspectWeight: input.container.aspectWeight ?? 1,
+			...extras
 		});
 		const ms = now() - start;
 		const runs = result.tried.length + 1;
-		const output = readFrame(input, frame, []);
+		const output = readFrame(input, frame, [], [], turnsOf(extras, false));
 		return {
 			...output,
 			trace: [{
@@ -2672,7 +3354,7 @@ const logSweep = {
 				ms: ms / runs,
 				measures: {
 					"pack.overflow": output.overflow.length,
-					[MOVES[id]]: moveCount(MOVES[id])
+					...movesOf(id, extras)
 				}
 			}]
 		};
@@ -2870,7 +3552,8 @@ const strategies = Object.freeze([
 	rows,
 	skyline,
 	shelf,
-	push
+	push,
+	maxrects
 ]);
 /** This function gives the strategy with an id. It throws a `RangeError` for an id that the registry does not have. */
 function strategy(id) {
@@ -3923,6 +4606,6 @@ function corpus(name, specs) {
 		inputs
 	};
 }
-export { DEFAULT_TOLERANCE, EPS, MEASURE_SPECS, RECORD_EPS, Rect, SORT_ORDERS, UnsupportedCell, Vector, aspectError, assertSupported, canonicalJson, cards, cellOf, checkHard, checkInput, compareRects, corpus, countCell, createContext, dashboard, edgeCases, fnv1a32, freeSpace, 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 };
+export { DEFAULT_TOLERANCE, EPS, MAXRECTS_BANDS, MAXRECTS_RULES, MEASURE_SPECS, RECORD_EPS, Rect, SHELF_FITS, SORT_ORDERS, UnsupportedCell, Vector, aspectError, assertSupported, canonicalJson, cards, cellOf, checkHard, checkInput, compareRects, corpus, countCell, createContext, dashboard, edgeCases, fnv1a32, freeSpace, fromRects, gallery, generator, generators, hashInput, isDeterministic, logSweep, lowestWindow, marginOf, maxrects, measure, measureChange, medianRatio, mulberry32, pack, packFree, packMaxRects, 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