@mark1russell7/packing 0.2.3 → 0.2.4

package/README.md

@@ -35,6 +35,17 @@ pack(rects, outer, { strategy: "skyline", sortOrder: "area-desc" });
 - `packSkyline`: each rectangle goes to the lowest place where it fits. It packs around a `locked` rectangle.
 - `packShelf`: it fills rows left to right in the sort order, and goes around each `locked` rectangle. With the sort order `input`, the rows read in your order.
 
+Since 0.2.4, `packShelf` and the strategy `shelf` have the option `fit`. `SHELF_FITS` lists its values. Without `fit`, the shelf packing does not change.
+
+```ts
+pack(rects, outer, { strategy: "shelf", fit: "best" });
+```
+
+- `fit: "next"`: each rectangle uses only the open shelf. A short rectangle can also stack above a shorter rectangle.
+- `fit: "first"`: each rectangle goes on the first shelf from the top where it fits.
+- `fit: "best"`: each rectangle goes on the shelf with the least height left over above it.
+- With a `fit`, the shelves open only in the free spans of each container shape. `docs/PACKER.md` tells the rules.
+
 Both functions also work alone, in an outer rectangle with a width that you set. They do not change the width.
 
 A `locked` rectangle keeps its position. `packSkyline` and `packShelf` put the other rectangles around it. `packRows` only keeps its position.

package/build/index.d.ts

@@ -142,6 +142,46 @@ interface FreeSpace {
  * frame is the corner of the container, moved in by the inset and out by half the gap. `FreeSpace` tells the methods.
  */
 export declare function freeSpace(input: PackInput): FreeSpace;
+/**
+ * The rule of a shelf packing to choose the shelf of a rectangle. `packShelf` tells each rule.
+ *
+ * - `next`: only the open shelf, the last shelf that the packing opened.
+ * - `first`: the first shelf from the top where the rectangle fits.
+ * - `best`: the shelf with the least height left over above the rectangle.
+ */
+type ShelfFit = "next" | "first" | "best";
+/** This constant lists each shelf fit. */
+export declare const SHELF_FITS: readonly ShelfFit[];
+/** The options of `packShelf` */
+interface ShelfOptions {
+  /** The order of the rectangles before the packing. The default is `height-desc`. */
+  sortOrder?: SortOrder;
+  /**
+   * The free space of the container: `freeSpace` of the input. Without it, or when it is plain, the packer uses only the
+   * outer rectangle and the locked rectangles.
+   */
+  space?: FreeSpace;
+  /**
+   * The rule to choose a shelf. Without it, `packShelf` packs as in 0.2.3. With it, `packShelf` uses its own shelves in
+   * each container shape, and it stacks rectangles in the strips above the shorter rectangles.
+   */
+  fit?: ShelfFit;
+}
+/**
+ * This function packs rectangles into shelves: rows that it fills left to right in the sort order, and does not fill
+ * again. It goes around each `locked` rectangle. It sets the position of each rectangle and gives the outer rectangle.
+ *
+ * - With the sort order `input`, the rows read in the order of the array: left to right, and top to bottom.
+ * - With `height-desc` (the default), it is the classic Next-Fit Decreasing Height packing.
+ * - A rectangle goes to the first x in the row where it crosses no locked rectangle. If no such x is in the width,
+ *   a new row starts under the current row.
+ * - A rectangle wider than the outer rectangle goes on its own row, at the left edge, and overflows.
+ * - 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`.
+ */
+export declare function packShelf<T>(rects: Rect<T>[], outer: Rect<T>, options?: ShelfOptions): Rect<T>;
 /** The options of `pack` and `packRows` */
 interface PackOptions {
   /** The order of the rectangles before the packing. The default is `height-desc`. */
@@ -159,6 +199,8 @@ interface PackLayoutOptions extends PackOptions {
    * Use `shelf` with the sort order `input` to keep the order of the array around locked rectangles.
    */
   strategy?: "rows" | "skyline" | "shelf";
+  /** The rule of `shelf` to choose a shelf. Only `shelf` reads it. `ShelfOptions` tells it. Without it, `shelf` packs as in 0.2.3. */
+  fit?: ShelfFit;
 }
 /**
  * This function packs rectangles into an outer rectangle of a given width with a guillotine row packing. It does
@@ -217,30 +259,6 @@ interface SkylineOptions {
  *   the obstacles and the locked items, thus the locked rectangles only keep their positions.
  */
 export declare function packSkyline<T>(rects: Rect<T>[], outer: Rect<T>, options?: SkylineOptions): Rect<T>;
-/** The options of `packShelf` */
-interface ShelfOptions {
-  /** The order of the rectangles before the packing. The default is `height-desc`. */
-  sortOrder?: SortOrder;
-  /**
-   * The free space of the container: `freeSpace` of the input. Without it, or when it is plain, the packer uses only the
-   * outer rectangle and the locked rectangles.
-   */
-  space?: FreeSpace;
-}
-/**
- * This function packs rectangles into shelves: rows that it fills left to right in the sort order, and does not fill
- * again. It goes around each `locked` rectangle. It sets the position of each rectangle and gives the outer rectangle.
- *
- * - With the sort order `input`, the rows read in the order of the array: left to right, and top to bottom.
- * - With `height-desc` (the default), it is the classic Next-Fit Decreasing Height packing.
- * - A rectangle goes to the first x in the row where it crosses no locked rectangle. If no such x is in the width,
- *   a new row starts under the current row.
- * - A rectangle wider than the outer rectangle goes on its own row, at the left edge, and overflows.
- * - 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.
- */
-export declare function packShelf<T>(rects: Rect<T>[], outer: Rect<T>, options?: ShelfOptions): Rect<T>;
 /** The options of `packFree` */
 interface FreeWidthOptions extends PackLayoutOptions {
   /** The target aspect: the width divided by the height. The default is 1, a square. */
@@ -387,9 +405,16 @@ interface LayoutMeasures {
   "pack.overflow.rate": number;
   "pack.overflow.area": number;
   "pack.overflow.forced": number;
+  /** The tight lower bound of `pack.overflow.area`. `docs/MEASURES.md` defines it. */
   "pack.overflow.forcedArea": number;
   "pack.overflow.excess": number;
+  /**
+   * This measure is an alias of `pack.overflow.forcedArea`, with the same value.
+   *
+   * @deprecated Use `pack.overflow.forcedArea`. The alias stays until the next minor version.
+   */
   "pack.overflow.forcedAreaMin": number;
+  /** The overflow area above its bound: `pack.overflow.area` less `pack.overflow.forcedArea`. */
   "pack.overflow.excessArea": number;
   "pack.search.widths": number;
   "pack.search.ms": number;
@@ -416,6 +441,8 @@ interface MeasureOptions {
  * - 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.
  */
 export declare const MEASURE_SPECS: Readonly<Record<MeasureId, MeasureSpec>>;
 /**
@@ -427,7 +454,8 @@ export declare const MEASURE_SPECS: Readonly<Record<MeasureId, MeasureSpec>>;
  * - 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
@@ -587,6 +615,11 @@ interface LayoutStrategyOptions {
   sortOrder: SortOrder;
   /** The number of widths that the first pass of the size search `log-sweep` tries. */
   samples: number;
+  /**
+   * The rule of `shelf` to choose a shelf: `next`, `first` or `best`. Only `shelf` reads it. Without it, `shelf` packs
+   * as in 0.2.3. With it, the trace also counts `move.firstFit` and `move.bestFit`.
+   */
+  fit?: ShelfFit;
 }
 /** The options of the strategy `push`. */
 interface PushStrategyOptions {
@@ -609,6 +642,7 @@ export declare const skyline: Strategy<LayoutStrategyOptions>;
 /**
  * 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`.
  */
 export declare const shelf: Strategy<LayoutStrategyOptions>;
 /**
@@ -837,5 +871,5 @@ interface Corpus {
  * `RangeError` for an unknown generator, a different version or 2 inputs with the same id.
  */
 export declare function corpus(name: string, specs: readonly CorpusSpec[]): Corpus;
-export { type Cell, type ChangeMeasures, type ContainerTest, type Corpus, type CorpusCell, type CorpusEntry, type CorpusGenerator, type CorpusManifest, type CorpusSpec, type CountScale, DEFAULT_TOLERANCE, type Dimension, type DimensionValue, type Direction, EPS, type EdgeCase, type EdgeCaseParams, type FreeSpace, type FreeSpan, type FreeWidthOptions, type FreeWidthResult, type FreeWidthTry, type GeneratedInput, type GeneratorParams, type GeneratorStamp, type Item, type LayoutContainer, type LayoutEdge, type LayoutInput, type LayoutMeasures, type LayoutStrategyOptions, type Margin, type MeasureFamily, type MeasureId, type MeasureOptions, type MeasureSpec, type MetricsOptions, type Obstacle, type ObstacleLayout, type PackContext, type PackHard, type PackInput, type PackLayoutOptions, type PackOptions, type PackOutput, type PackingMetrics, type Placement, type Port, type PushOptions, type PushStrategyOptions, RECORD_EPS, type RectGridParams, type RectScatteredParams, type Region, type ShelfOptions, type Side, type Sides, type SizeDistribution, type SizeSearch, type SkylineOptions, type SortOrder, type SpaceRect, type StageTrace, type Strategy, type Supports, type Tolerance, type UiParams, checkInput, turnPoint, turnPort, turnRegion };
+export { type Cell, type ChangeMeasures, type ContainerTest, type Corpus, type CorpusCell, type CorpusEntry, type CorpusGenerator, type CorpusManifest, type CorpusSpec, type CountScale, DEFAULT_TOLERANCE, type Dimension, type DimensionValue, type Direction, EPS, type EdgeCase, type EdgeCaseParams, type FreeSpace, type FreeSpan, type FreeWidthOptions, type FreeWidthResult, type FreeWidthTry, type GeneratedInput, type GeneratorParams, type GeneratorStamp, type Item, type LayoutContainer, type LayoutEdge, type LayoutInput, type LayoutMeasures, type LayoutStrategyOptions, type Margin, type MeasureFamily, type MeasureId, type MeasureOptions, type MeasureSpec, type MetricsOptions, type Obstacle, type ObstacleLayout, type PackContext, type PackHard, type PackInput, type PackLayoutOptions, type PackOptions, type PackOutput, type PackingMetrics, type Placement, type Port, type PushOptions, type PushStrategyOptions, RECORD_EPS, type RectGridParams, type RectScatteredParams, type Region, type ShelfFit, type ShelfOptions, type Side, type Sides, type SizeDistribution, type SizeSearch, type SkylineOptions, type SortOrder, type SpaceRect, type StageTrace, type Strategy, type Supports, type Tolerance, type UiParams, checkInput, turnPoint, turnPort, turnRegion };
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["Item","Sides","ContractMeasureSpec","Direction","ContainerTest","PackHard","LayoutContainer","LayoutEdge","LayoutInput"],"sources":["../src/vector.ts","../src/rect.ts","../src/order.ts","../src/contract.ts","../src/space.ts","../src/pack.ts","../src/skyline.ts","../src/shelf.ts","../src/free.ts","../src/push.ts","../src/metrics.ts","../src/measures.ts","../src/strategy.ts","../src/adapters.ts","../src/convert.ts","../src/registry.ts","../src/check.ts","../src/layout-input.ts","../src/generators.ts","../src/corpus.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":["Item","Sides","ContractMeasureSpec","Direction","ContainerTest","PackHard","LayoutContainer","LayoutEdge","LayoutInput"],"sources":["../src/vector.ts","../src/rect.ts","../src/order.ts","../src/contract.ts","../src/space.ts","../src/shelf.ts","../src/pack.ts","../src/skyline.ts","../src/free.ts","../src/push.ts","../src/metrics.ts","../src/measures.ts","../src/strategy.ts","../src/adapters.ts","../src/convert.ts","../src/registry.ts","../src/check.ts","../src/layout-input.ts","../src/generators.ts","../src/corpus.ts"],"mappings":"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"}

package/build/index.js

@@ -138,16 +138,23 @@ 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"
 });
 const counts = /* @__PURE__ */ new Map();
 /** This function adds `n` to the count of a move. */
@@ -775,6 +782,12 @@ function freeSpace(input) {
 	return spaceOf(input, buildFrame(input));
 }
 // 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 +822,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 +988,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
@@ -1993,6 +2183,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 +2317,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 +2363,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 +2377,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 +2389,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,16 +2737,28 @@ 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 move counts of the trace of a strategy: its own move, and the moves of a shelf fit. */
+function movesOf(id, fit) {
+	const out = { [MOVES[id]]: moveCount(MOVES[id]) };
+	if (fit.fit !== void 0) for (const move of [MOVES.firstFit, MOVES.bestFit]) out[move] = moveCount(move);
+	return out;
+}
 /** 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);
+	const fit = fitOf(id, options);
 	clearMoves();
 	if (frame.w > 0) pack(rects, outerOf(frame), {
 		strategy: id,
 		sortOrder: options.sortOrder,
-		space: spaceOf(input, frame)
+		space: spaceOf(input, frame),
+		...fit
 	});
 	const output = readFrame(input, frame, []);
 	return {
@@ -2563,7 +2768,7 @@ function packFixedWidth(id, input, options) {
 			ms: now() - start,
 			measures: {
 				"pack.overflow": output.overflow.length,
-				[MOVES[id]]: moveCount(MOVES[id])
+				...movesOf(id, fit)
 			}
 		}]
 	};
@@ -2622,6 +2827,7 @@ const skyline = layoutStrategy("skyline", "skyline", ["skyline-bl"], {
 /**
 * 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"],
@@ -2647,13 +2853,15 @@ const logSweep = {
 		};
 		const start = now();
 		const frame = buildFrame(input);
+		const fit = fitOf(id, o);
 		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,
+			...fit
 		});
 		const ms = now() - start;
 		const runs = result.tried.length + 1;
@@ -2672,7 +2880,7 @@ const logSweep = {
 				ms: ms / runs,
 				measures: {
 					"pack.overflow": output.overflow.length,
-					[MOVES[id]]: moveCount(MOVES[id])
+					...movesOf(id, fit)
 				}
 			}]
 		};
@@ -3923,6 +4131,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, 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 };
 
 //# sourceMappingURL=index.js.map