@mark1russell7/packing 0.2.4 → 0.2.5

package/build/index.js

@@ -154,7 +154,17 @@ const MOVES = Object.freeze({
 	/** 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"
+	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. */
@@ -241,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;
@@ -262,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;
 		}
@@ -311,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) {
@@ -325,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
@@ -335,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
 	};
@@ -344,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);
@@ -749,7 +778,7 @@ function spaceOf(input, frame) {
 		start,
 		end
 	}));
-	return {
+	const space = {
 		w: frame.w,
 		h: frame.h,
 		plain,
@@ -773,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
@@ -781,6 +837,366 @@ 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 = [
@@ -1446,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;
@@ -1464,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);
@@ -2737,30 +3154,61 @@ function supportsOf(cells) {
 		mode: [...cells.mode]
 	};
 }
-/** This function gives the fit of the options of a strategy: only `shelf` reads it. */
-function fitOf(id, options) {
-	return id === "shelf" && options.fit !== void 0 ? { fit: options.fit } : {};
+/**
+* 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. */
-function movesOf(id, fit) {
+/**
+* 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 (fit.fit !== void 0) for (const move of [MOVES.firstFit, MOVES.bestFit]) out[move] = moveCount(move);
+	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 fit = fitOf(id, options);
+	const extras = extrasOf(id, options, frame);
 	clearMoves();
 	if (frame.w > 0) pack(rects, outerOf(frame), {
 		strategy: id,
 		sortOrder: options.sortOrder,
 		space: spaceOf(input, frame),
-		...fit
+		...extras
 	});
-	const output = readFrame(input, frame, []);
+	const output = readFrame(input, frame, [], [], turnsOf(extras, transposed));
 	return {
 		...output,
 		trace: [{
@@ -2768,13 +3216,13 @@ function packFixedWidth(id, input, options) {
 			ms: now() - start,
 			measures: {
 				"pack.overflow": output.overflow.length,
-				...movesOf(id, fit)
+				...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,
@@ -2783,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);
@@ -2795,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);
 			}
@@ -2803,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
@@ -2815,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`.
@@ -2823,7 +3273,7 @@ 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`.
@@ -2836,24 +3286,48 @@ 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 fit = fitOf(id, o);
+		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,
@@ -2861,11 +3335,11 @@ const logSweep = {
 			samples: o.samples,
 			aspect: input.container.aspect ?? 1,
 			aspectWeight: input.container.aspectWeight ?? 1,
-			...fit
+			...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: [{
@@ -2880,7 +3354,7 @@ const logSweep = {
 				ms: ms / runs,
 				measures: {
 					"pack.overflow": output.overflow.length,
-					...movesOf(id, fit)
+					...movesOf(id, extras)
 				}
 			}]
 		};
@@ -3078,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) {
@@ -4131,6 +4606,6 @@ function corpus(name, specs) {
 		inputs
 	};
 }
-export { DEFAULT_TOLERANCE, EPS, 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, 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