@embedpdf/core-stage 3.0.0-next.13 → 3.0.0-next.15

package/dist/index.cjs

@@ -9,21 +9,20 @@ let _embedpdf_core_geometry = require("@embedpdf/core-geometry");
 * (a focal point relative to a page — what survives layout/zoom changes & reloads).
 *
 * Navigation is pure camera math. Bounds/home/margin are three separate functions.
-* No DOM, no framework; plain-data model plus derived spatial queries (the DATA
-* is serializable — `Scene` also carries query methods derived from it). This
-* is the v4 Rust core, verbatim.
+* No DOM, no framework; plain-data model plus derived spatial queries (the data
+* is serializable — `Scene` also carries query methods derived from it).
 */
 /** The page's on-screen footprint: w↔h swapped for quarter-turns (via the shared
-*  geometry primitive), scaled by its `/UserUnit` (the page's PHYSICAL size — a
+*  geometry primitive), scaled by its `/UserUnit` (the page's physical size — a
 *  userUnit-5 page measures 5× its point size). Everything the layout packs uses
 *  these display dims; the content scale (isotropic) and the renderer's
 *  transform recover the content. */
 function displayDims(pg) {
-	const u = pg.userUnit ?? 1;
-	const d = (0, _embedpdf_core_geometry.displaySize)(pg.size, pg.rotation ?? 0);
-	return u === 1 ? d : {
-		width: d.width * u,
-		height: d.height * u
+	const userUnit = pg.userUnit ?? 1;
+	const size = (0, _embedpdf_core_geometry.displaySize)(pg.size, pg.rotation ?? 0);
+	return userUnit === 1 ? size : {
+		width: size.width * userUnit,
+		height: size.height * userUnit
 	};
 }
 const ZOOM_MIN = .05;
@@ -32,37 +31,37 @@ const ZoomMode = {
 	Automatic: "automatic",
 	FitPage: "fit-page",
 	FitWidth: "fit-width",
-	/** Fit the WHOLE scene (every page) in view — the construction overview. */
+	/** Fit the whole scene (every page) in view — the construction overview. */
 	FitAll: "fit-all"
 };
-const clamp = (v, lo, hi) => Math.min(Math.max(v, lo), hi);
-const toScreen = (c, w) => ({
-	x: (w.x - c.x) * c.zoom,
-	y: (w.y - c.y) * c.zoom
+const clamp = (value, lo, hi) => Math.min(Math.max(value, lo), hi);
+const toScreen = (camera, point) => ({
+	x: (point.x - camera.x) * camera.zoom,
+	y: (point.y - camera.y) * camera.zoom
 });
-const toWorld = (c, s) => ({
-	x: c.x + s.x / c.zoom,
-	y: c.y + s.y / c.zoom
+const toWorld = (camera, point) => ({
+	x: camera.x + point.x / camera.zoom,
+	y: camera.y + point.y / camera.zoom
 });
-const cameraWorldRect = (c, vp) => ({
-	x: c.x,
-	y: c.y,
-	width: vp.width / c.zoom,
-	height: vp.height / c.zoom
+const cameraWorldRect = (camera, vp) => ({
+	x: camera.x,
+	y: camera.y,
+	width: vp.width / camera.zoom,
+	height: vp.height / camera.zoom
 });
 /** Focal zoom: keep the world point under `screenPt` fixed (no bounce). */
-const zoomAround = (c, screenPt, factor) => {
-	const zoom = clamp(c.zoom * factor, ZOOM_MIN, 64);
+const zoomAround = (camera, screenPt, factor) => {
+	const zoom = clamp(camera.zoom * factor, ZOOM_MIN, 64);
 	return {
-		x: c.x + screenPt.x / c.zoom - screenPt.x / zoom,
-		y: c.y + screenPt.y / c.zoom - screenPt.y / zoom,
+		x: camera.x + screenPt.x / camera.zoom - screenPt.x / zoom,
+		y: camera.y + screenPt.y / camera.zoom - screenPt.y / zoom,
 		zoom
 	};
 };
-const panByScreen = (c, dxScreen, dyScreen) => ({
-	x: c.x - dxScreen / c.zoom,
-	y: c.y - dyScreen / c.zoom,
-	zoom: c.zoom
+const panByScreen = (camera, dxScreen, dyScreen) => ({
+	x: camera.x - dxScreen / camera.zoom,
+	y: camera.y - dyScreen / camera.zoom,
+	zoom: camera.zoom
 });
 const centerOnWorld = (worldPt, vp, zoom) => ({
 	zoom,
@@ -80,82 +79,82 @@ const travelRange = (origin, content, view, zoom, padding) => ({
 * with a `padding` gutter the camera may reveal beyond each content edge.
 *
 * Per axis the travel interval is `travelRange`'s [near, far]. If the padded
-* content OVERFLOWS the viewport, the camera travels freely in it. If it FITS,
-* the camera is LOCKED to the `fitAlign` rest point — start = near, end = far,
+* content overflows the viewport, the camera travels freely in it. If it fits,
+* the camera is locked to the `fitAlign` rest point — start = near, end = far,
 * center = midpoint (x resolved logically against `direction`).
 */
-const clampCamera = (c, bounds, vp, k) => {
-	if (!k.bounded) return c;
-	const p = k.padding;
-	const fit = k.fitAlign ?? {
+const clampCamera = (camera, bounds, vp, constraint) => {
+	if (!constraint.bounded) return camera;
+	const padding = constraint.padding;
+	const fit = constraint.fitAlign ?? {
 		x: "center",
 		y: "center"
 	};
-	const axis = (pos, origin, content, view, a) => {
-		const t = travelRange(origin, content, view, c.zoom, p);
-		if (t.fits) return a === "start" ? t.near : a === "end" ? t.far : (t.near + t.far) / 2;
-		return clamp(pos, t.near, t.far);
+	const axis = (pos, origin, content, view, align) => {
+		const travel = travelRange(origin, content, view, camera.zoom, padding);
+		if (travel.fits) return align === "start" ? travel.near : align === "end" ? travel.far : (travel.near + travel.far) / 2;
+		return clamp(pos, travel.near, travel.far);
 	};
-	const ax = k.direction === "rtl" && fit.x !== "center" ? fit.x === "start" ? "end" : "start" : fit.x;
+	const ax = constraint.direction === "rtl" && fit.x !== "center" ? fit.x === "start" ? "end" : "start" : fit.x;
 	return {
-		zoom: c.zoom,
-		x: axis(c.x, bounds.x, bounds.width, vp.width, ax),
-		y: axis(c.y, bounds.y, bounds.height, vp.height, fit.y)
+		zoom: camera.zoom,
+		x: axis(camera.x, bounds.x, bounds.width, vp.width, ax),
+		y: axis(camera.y, bounds.y, bounds.height, vp.height, fit.y)
 	};
 };
-const scrollMetrics = (c, bounds, vp, padding) => {
+const scrollMetrics = (camera, bounds, vp, padding) => {
 	const axis = (pos, origin, content, view) => {
-		const lo = Math.min(origin - padding / c.zoom, pos);
-		const total = (Math.max(origin + content + padding / c.zoom, pos + view / c.zoom) - lo) * c.zoom;
+		const lo = Math.min(origin - padding / camera.zoom, pos);
+		const total = (Math.max(origin + content + padding / camera.zoom, pos + view / camera.zoom) - lo) * camera.zoom;
 		return {
-			offset: (pos - lo) * c.zoom,
+			offset: (pos - lo) * camera.zoom,
 			total,
 			scrollable: total > view + .5
 		};
 	};
-	const x = axis(c.x, bounds.x, bounds.width, vp.width);
-	const y = axis(c.y, bounds.y, bounds.height, vp.height);
+	const horizontal = axis(camera.x, bounds.x, bounds.width, vp.width);
+	const vertical = axis(camera.y, bounds.y, bounds.height, vp.height);
 	return {
-		scrollLeft: x.offset,
-		scrollTop: y.offset,
-		scrollWidth: x.total,
-		scrollHeight: y.total,
+		scrollLeft: horizontal.offset,
+		scrollTop: vertical.offset,
+		scrollWidth: horizontal.total,
+		scrollHeight: vertical.total,
 		clientWidth: vp.width,
 		clientHeight: vp.height,
-		scrollableX: x.scrollable,
-		scrollableY: y.scrollable
+		scrollableX: horizontal.scrollable,
+		scrollableY: vertical.scrollable
 	};
 };
 /**
 * The inverse write — `Element.scrollTo` semantics: absolute offsets into the
-* CURRENT range (the same union `scrollMetrics` reports), clamped into
+* current range (the same union `scrollMetrics` reports), clamped into
 * [0, total − view]; an omitted axis does not move. Zoom is untouched: scrolling
 * is a pan in scroller clothing.
 */
-const cameraFromScroll = (c, bounds, vp, padding, target) => {
+const cameraFromScroll = (camera, bounds, vp, padding, target) => {
 	const axis = (want, pos, origin, content, view) => {
 		if (want === void 0) return pos;
-		const lo = Math.min(origin - padding / c.zoom, pos);
-		const hi = Math.max(origin + content + padding / c.zoom, pos + view / c.zoom);
-		const max = Math.max(0, (hi - lo) * c.zoom - view);
-		return lo + clamp(want, 0, max) / c.zoom;
+		const lo = Math.min(origin - padding / camera.zoom, pos);
+		const hi = Math.max(origin + content + padding / camera.zoom, pos + view / camera.zoom);
+		const max = Math.max(0, (hi - lo) * camera.zoom - view);
+		return lo + clamp(want, 0, max) / camera.zoom;
 	};
 	return {
-		zoom: c.zoom,
-		x: axis(target.left, c.x, bounds.x, bounds.width, vp.width),
-		y: axis(target.top, c.y, bounds.y, bounds.height, vp.height)
+		zoom: camera.zoom,
+		x: axis(target.left, camera.x, bounds.x, bounds.width, vp.width),
+		y: axis(target.top, camera.y, bounds.y, bounds.height, vp.height)
 	};
 };
 /**
-* THE placement algorithm — every arrival (goToPage, next/prev, reset) lands
+* The placement algorithm — every arrival (goToPage, next/prev, reset) lands
 * through it. Pure alignment: put the subject at `align` in the viewport —
 * per axis 'start' (reading edge at the padded viewport edge), 'end' (far
 * edge), 'center', or a fraction — with x resolved logically against the
-* reading direction. The SAME rule at every zoom: whether the subject fits or
+* reading direction. The same rule at every zoom: whether the subject fits or
 * overflows never changes where it lands. Landing is policy, not a side
 * effect of magnification.
 *
-* Deliberately clamp-free: the caller clamps the result against the TRUE
+* Deliberately clamp-free: the caller clamps the result against the true
 * travel bounds (the scene in continuous flow, the item slice in paged). On
 * an axis with no real freedom that clamp collapses the landing to the
 * `fitAlign` rest point — "rests where it must" comes out of the clamp's
@@ -165,11 +164,11 @@ function placeCamera(subject, vp, zoom, padding = 0, align = {
 	x: "start",
 	y: "start"
 }, direction = "ltr") {
-	const axis = (a, pos, extent, view) => {
-		if (a === "start") return pos - padding / zoom;
-		if (a === "end") return pos + extent - (view - padding) / zoom;
-		const f = a === "center" ? .5 : clamp(a, 0, 1);
-		return pos + extent / 2 - view * f / zoom;
+	const axis = (alignValue, pos, extent, view) => {
+		if (alignValue === "start") return pos - padding / zoom;
+		if (alignValue === "end") return pos + extent - (view - padding) / zoom;
+		const fraction = alignValue === "center" ? .5 : clamp(alignValue, 0, 1);
+		return pos + extent / 2 - view * fraction / zoom;
 	};
 	return {
 		zoom,
@@ -178,13 +177,13 @@ function placeCamera(subject, vp, zoom, padding = 0, align = {
 	};
 }
 /**
-* The MINIMAL camera move that makes `rect` fully visible (with a `padding` gutter)
+* The minimal camera move that makes `rect` fully visible (with a `padding` gutter)
 * — DOM scrollIntoView({ block: 'nearest' }) as camera math. Per axis, the cameras
-* that show the rect form an interval; the answer is the current camera CLAMPED
+* that show the rect form an interval; the answer is the current camera clamped
 * into it: already inside → unchanged (the no-op case, by construction, not by
 * condition). An oversized rect (interval inverted) aligns to its start.
 *
-* This is deliberately NOT placement: `placeCamera` answers "I am navigating here"
+* This is deliberately not placement: `placeCamera` answers "I am navigating here"
 * (canonical); `revealCamera` answers "make sure this is seeable" (minimal).
 */
 function revealCamera(cam, rect, vp, padding = 0) {
@@ -219,11 +218,11 @@ function anchorAtPoint(scene, worldPt) {
 	const item = scene.nearestItem(worldPt);
 	let page = item.pages[0];
 	let best = Infinity;
-	for (const p of item.pages) {
-		const d = Math.abs(p.x + p.width / 2 - worldPt.x);
-		if (d < best) {
-			best = d;
-			page = p;
+	for (const candidate of item.pages) {
+		const distance = Math.abs(candidate.x + candidate.width / 2 - worldPt.x);
+		if (distance < best) {
+			best = distance;
+			page = candidate;
 		}
 	}
 	return {
@@ -232,11 +231,11 @@ function anchorAtPoint(scene, worldPt) {
 		fy: (worldPt.y - page.y) / page.height
 	};
 }
-/** The camera that puts the anchor's world point at a given SCREEN point. */
+/** The camera that puts the anchor's world point at a given screen point. */
 function cameraForAnchorAtScreen(anchor, scene, screenPt, zoom) {
 	const item = scene.items[scene.itemOfPage(anchor.pageIndex)];
 	let page = item.pages[0];
-	for (const p of item.pages) if (p.pageIndex === anchor.pageIndex) page = p;
+	for (const candidate of item.pages) if (candidate.pageIndex === anchor.pageIndex) page = candidate;
 	const world = {
 		x: page.x + anchor.fx * page.width,
 		y: page.y + anchor.fy * page.height
@@ -256,53 +255,53 @@ function anchorFromCamera(cam, scene, vp, at) {
 	}));
 }
 /** The camera that restores an anchor to the same viewport point it was
-*  captured at — capture and restore MUST agree on `at` for exact round-trips. */
+*  captured at — capture and restore must agree on `at` for exact round-trips. */
 function cameraFromAnchor(anchor, scene, vp, zoom, at) {
 	return cameraForAnchorAtScreen(anchor, scene, at ?? {
 		x: vp.width / 2,
 		y: vp.height / 2
 	}, zoom);
 }
-function lowerBound(arr, t) {
+function lowerBound(arr, value) {
 	let lo = 0;
 	let hi = arr.length;
 	while (lo < hi) {
 		const mid = lo + hi >> 1;
-		if (arr[mid] < t) lo = mid + 1;
+		if (arr[mid] < value) lo = mid + 1;
 		else hi = mid;
 	}
 	return lo;
 }
-function upperBound(arr, t) {
+function upperBound(arr, value) {
 	let lo = 0;
 	let hi = arr.length;
 	while (lo < hi) {
 		const mid = lo + hi >> 1;
-		if (arr[mid] <= t) lo = mid + 1;
+		if (arr[mid] <= value) lo = mid + 1;
 		else hi = mid;
 	}
 	return lo;
 }
 const OVERSCAN = 2;
 /** Intrinsic item dimensions (pages only, no margins) — the `uniform` reference.
-*  Uses DISPLAY dims, so `uniform` equalizes the rotated footprint and a rotated
+*  Uses display dims, so `uniform` equalizes the rotated footprint and a rotated
 *  page sizes to match its neighbours as it actually appears. */
 function measureItem(pages, group, gap) {
-	let w = 0;
-	let h = 0;
+	let width = 0;
+	let height = 0;
 	for (let j = 0; j < group.length; j++) {
-		const d = displayDims(pages[group[j]]);
-		w += d.width + (j > 0 ? gap : 0);
-		if (d.height > h) h = d.height;
+		const size = displayDims(pages[group[j]]);
+		width += size.width + (j > 0 ? gap : 0);
+		if (size.height > height) height = size.height;
 	}
 	return {
-		width: w,
-		height: h
+		width,
+		height
 	};
 }
 /**
-* Pack one item from SCALED pages plus constant per-page margins. The page boxes
-* (and the spread's inner gap) scale with the sizing factor; the margins do NOT —
+* Pack one item from scaled pages plus constant per-page margins. The page boxes
+* (and the spread's inner gap) scale with the sizing factor; the margins do not —
 * they are screen-px-derived chrome bands and stay constant in world space.
 */
 function packScaledItem(pages, group, scale, gap, frame, direction) {
@@ -311,23 +310,23 @@ function packScaledItem(pages, group, scale, gap, frame, direction) {
 	const local = [];
 	let lx = 0;
 	for (let j = 0; j < group.length; j++) {
-		const d = displayDims(pages[group[j]]);
-		const w = d.width * scale;
-		const h = d.height * scale;
+		const size = displayDims(pages[group[j]]);
+		const scaledWidth = size.width * scale;
+		const scaledHeight = size.height * scale;
 		local.push({
 			pageIndex: group[j],
 			lx: lx + frame.left,
-			ly: frame.top + (maxH - h) / 2,
-			w,
-			h,
+			ly: frame.top + (maxH - scaledHeight) / 2,
+			w: scaledWidth,
+			h: scaledHeight,
 			rotation: pages[group[j]].rotation ?? 0,
 			userUnit: pages[group[j]].userUnit ?? 1
 		});
-		lx += frame.left + w + frame.right + gap * scale;
+		lx += frame.left + scaledWidth + frame.right + gap * scale;
 	}
 	const width = Math.max(0, lx - gap * scale);
 	const height = frame.top + maxH + frame.bottom;
-	if (direction === "rtl") for (const b of local) b.lx = width - b.lx - b.w + (frame.left - frame.right);
+	if (direction === "rtl") for (const box of local) box.lx = width - box.lx - box.w + (frame.left - frame.right);
 	return {
 		local,
 		width,
@@ -335,14 +334,14 @@ function packScaledItem(pages, group, scale, gap, frame, direction) {
 	};
 }
 function placePages(item, local, contentScale) {
-	return local.map((b) => ({
-		pageIndex: b.pageIndex,
-		x: item.x + b.lx,
-		y: item.y + b.ly,
-		width: b.w,
-		height: b.h,
-		rotation: b.rotation,
-		contentScale: contentScale * b.userUnit
+	return local.map((box) => ({
+		pageIndex: box.pageIndex,
+		x: item.x + box.lx,
+		y: item.y + box.ly,
+		width: box.w,
+		height: box.h,
+		rotation: box.rotation,
+		contentScale: contentScale * box.userUnit
 	}));
 }
 /** Per-item world scale = sizing factor (1 intrinsic, else cross-equalize for
@@ -350,17 +349,17 @@ function placePages(item, local, contentScale) {
 *  result becomes the page's `contentScale`, so world units are view px and 100%
 *  is physically accurate. `viewUnitsPerPoint` defaults to 1 (neutral). */
 const itemScale = (crossIntrinsic, refCross, sizing, viewUnitsPerPoint = 1) => (sizing === "uniform" && crossIntrinsic > 0 ? refCross / crossIntrinsic : 1) * viewUnitsPerPoint;
-function linearLayout(pages, grouping, opts = {}) {
-	const gap = opts.gap ?? 16;
-	const vertical = (opts.axis ?? "y") === "y";
-	const align = opts.align ?? "center";
-	const sizing = opts.sizing ?? "intrinsic";
-	const direction = opts.direction ?? "ltr";
+function linearLayout(pages, grouping, options = {}) {
+	const gap = options.gap ?? 16;
+	const vertical = (options.axis ?? "y") === "y";
+	const align = options.align ?? "center";
+	const sizing = options.sizing ?? "intrinsic";
+	const direction = options.direction ?? "ltr";
 	const mirrored = !vertical && direction === "rtl";
-	const frame = opts.pageFrame ?? _embedpdf_core_geometry.NO_FRAME;
+	const frame = options.pageFrame ?? _embedpdf_core_geometry.NO_FRAME;
 	const measures = grouping.map((group) => measureItem(pages, group, gap));
-	const crossOf = (p) => vertical ? p.width : p.height;
-	const refCross = measures.reduce((m, p) => Math.max(m, crossOf(p)), 0);
+	const crossOf = (measure) => vertical ? measure.width : measure.height;
+	const refCross = measures.reduce((largest, measure) => Math.max(largest, crossOf(measure)), 0);
 	const items = new Array(grouping.length);
 	const locals = new Array(grouping.length);
 	const scales = new Array(grouping.length);
@@ -369,10 +368,10 @@ function linearLayout(pages, grouping, opts = {}) {
 	let maxW = 0;
 	let maxH = 0;
 	for (let i = 0; i < grouping.length; i++) {
-		const s = itemScale(crossOf(measures[i]), refCross, sizing, opts.viewUnitsPerPoint);
-		const packed = packScaledItem(pages, grouping[i], s, gap, frame, direction);
+		const scale = itemScale(crossOf(measures[i]), refCross, sizing, options.viewUnitsPerPoint);
+		const packed = packScaledItem(pages, grouping[i], scale, gap, frame, direction);
 		const { width, height } = packed;
-		scales[i] = s;
+		scales[i] = scale;
 		locals[i] = packed.local;
 		const it = {
 			index: i,
@@ -410,13 +409,13 @@ function linearLayout(pages, grouping, opts = {}) {
 		else it.y = align === "center" ? (size.height - it.height) / 2 : 0;
 		it.pages = placePages(it, locals[i], scales[i]);
 	}
-	const posIdx = (k) => mirrored ? items.length - 1 - k : k;
-	const starts = items.map((_, k) => {
-		const it = items[posIdx(k)];
+	const posIdx = (position) => mirrored ? items.length - 1 - position : position;
+	const starts = items.map((_, position) => {
+		const it = items[posIdx(position)];
 		return vertical ? it.y : it.x;
 	});
-	const ends = items.map((_, k) => {
-		const it = items[posIdx(k)];
+	const ends = items.map((_, position) => {
+		const it = items[posIdx(position)];
 		return vertical ? it.y + it.height : it.x + it.width;
 	});
 	const firstPage = items.map((it) => it.pageIndexes[0]);
@@ -429,41 +428,41 @@ function linearLayout(pages, grouping, opts = {}) {
 			width: maxW,
 			height: maxH
 		},
-		query(r) {
-			const a0 = vertical ? r.y : r.x;
-			const a1 = vertical ? r.y + r.height : r.x + r.width;
+		query(rect) {
+			const a0 = vertical ? rect.y : rect.x;
+			const a1 = vertical ? rect.y + rect.height : rect.x + rect.width;
 			const lo = Math.max(0, lowerBound(ends, a0) - OVERSCAN);
 			const hi = Math.min(items.length, upperBound(starts, a1) + OVERSCAN);
 			const out = [];
-			for (let k = lo; k < hi; k++) out.push(items[posIdx(k)]);
+			for (let position = lo; position < hi; position++) out.push(items[posIdx(position)]);
 			return out;
 		},
 		nearestItem(pt) {
-			const k = clamp(upperBound(starts, vertical ? pt.y : pt.x) - 1, 0, items.length - 1);
-			return items[posIdx(k)];
+			const position = clamp(upperBound(starts, vertical ? pt.y : pt.x) - 1, 0, items.length - 1);
+			return items[posIdx(position)];
 		},
 		itemOfPage(pi) {
 			return clamp(upperBound(firstPage, pi) - 1, 0, items.length - 1);
 		}
 	};
 }
-function gridLayout(pages, grouping, opts = {}) {
-	const gap = opts.gap ?? 48;
-	const n = grouping.length;
-	const sizing = opts.sizing ?? "intrinsic";
-	const direction = opts.direction ?? "ltr";
-	const frame = opts.pageFrame ?? _embedpdf_core_geometry.NO_FRAME;
+function gridLayout(pages, grouping, options = {}) {
+	const gap = options.gap ?? 48;
+	const itemCount = grouping.length;
+	const sizing = options.sizing ?? "intrinsic";
+	const direction = options.direction ?? "ltr";
+	const frame = options.pageFrame ?? _embedpdf_core_geometry.NO_FRAME;
 	const measures = grouping.map((group) => measureItem(pages, group, gap));
-	const refW = measures.reduce((m, p) => Math.max(m, p.width), 0);
-	const locals = new Array(n);
-	const sizes = new Array(n);
-	const scales = new Array(n);
+	const refW = measures.reduce((widest, measure) => Math.max(widest, measure.width), 0);
+	const locals = new Array(itemCount);
+	const sizes = new Array(itemCount);
+	const scales = new Array(itemCount);
 	let cellW = 1;
 	let cellH = 1;
-	for (let i = 0; i < n; i++) {
-		const s = itemScale(measures[i].width, refW, sizing, opts.viewUnitsPerPoint);
-		const packed = packScaledItem(pages, grouping[i], s, gap, frame, direction);
-		scales[i] = s;
+	for (let i = 0; i < itemCount; i++) {
+		const scale = itemScale(measures[i].width, refW, sizing, options.viewUnitsPerPoint);
+		const packed = packScaledItem(pages, grouping[i], scale, gap, frame, direction);
+		scales[i] = scale;
 		locals[i] = packed.local;
 		sizes[i] = {
 			width: packed.width,
@@ -472,25 +471,25 @@ function gridLayout(pages, grouping, opts = {}) {
 		cellW = Math.max(cellW, sizes[i].width);
 		cellH = Math.max(cellH, sizes[i].height);
 	}
-	const wanted = opts.lineWidth !== void 0 ? Math.floor((opts.lineWidth + gap) / (cellW + gap)) : opts.columns ?? Math.ceil(Math.sqrt(n));
-	const columns = Math.max(1, Math.min(wanted, Math.max(1, n)));
+	const wanted = options.lineWidth !== void 0 ? Math.floor((options.lineWidth + gap) / (cellW + gap)) : options.columns ?? Math.ceil(Math.sqrt(itemCount));
+	const columns = Math.max(1, Math.min(wanted, Math.max(1, itemCount)));
 	const colAt = (col) => direction === "rtl" ? columns - 1 - col : col;
 	const stepX = cellW + gap;
-	const rows = Math.max(1, Math.ceil(n / columns));
+	const rows = Math.max(1, Math.ceil(itemCount / columns));
 	const rowHeight = new Array(rows).fill(1);
-	for (let i = 0; i < n; i++) {
+	for (let i = 0; i < itemCount; i++) {
 		const row = Math.floor(i / columns);
 		rowHeight[row] = Math.max(rowHeight[row], sizes[i].height);
 	}
 	const rowTop = new Array(rows);
 	let yCursor = 0;
-	for (let r = 0; r < rows; r++) {
-		rowTop[r] = yCursor;
-		yCursor += rowHeight[r] + gap;
+	for (let row = 0; row < rows; row++) {
+		rowTop[row] = yCursor;
+		yCursor += rowHeight[row] + gap;
 	}
-	const rowEnd = rowTop.map((top, r) => top + rowHeight[r]);
-	const items = new Array(n);
-	for (let i = 0; i < n; i++) {
+	const rowEnd = rowTop.map((top, row) => top + rowHeight[row]);
+	const items = new Array(itemCount);
+	for (let i = 0; i < itemCount; i++) {
 		const col = colAt(i % columns);
 		const row = Math.floor(i / columns);
 		const it = {
@@ -513,31 +512,31 @@ function gridLayout(pages, grouping, opts = {}) {
 	return {
 		size,
 		items,
-		itemCount: n,
+		itemCount,
 		axis: "grid",
 		maxItemSize: {
 			width: cellW,
 			height: cellH
 		},
-		query(r) {
-			const c0 = Math.max(0, Math.floor(r.x / stepX));
-			const c1 = Math.min(columns - 1, Math.floor((r.x + r.width) / stepX));
-			const r0 = Math.max(0, lowerBound(rowEnd, r.y));
-			const r1 = Math.min(rows - 1, upperBound(rowTop, r.y + r.height) - 1);
+		query(rect) {
+			const c0 = Math.max(0, Math.floor(rect.x / stepX));
+			const c1 = Math.min(columns - 1, Math.floor((rect.x + rect.width) / stepX));
+			const r0 = Math.max(0, lowerBound(rowEnd, rect.y));
+			const r1 = Math.min(rows - 1, upperBound(rowTop, rect.y + rect.height) - 1);
 			const out = [];
 			for (let row = r0; row <= r1; row++) for (let col = c0; col <= c1; col++) {
-				const idx = row * columns + colAt(col);
-				if (idx < n) out.push(items[idx]);
+				const index = row * columns + colAt(col);
+				if (index < itemCount) out.push(items[index]);
 			}
 			return out;
 		},
 		nearestItem(pt) {
 			const col = clamp(Math.floor(pt.x / stepX), 0, columns - 1);
 			const row = clamp(upperBound(rowTop, pt.y) - 1, 0, rows - 1);
-			return items[clamp(row * columns + colAt(col), 0, n - 1)];
+			return items[clamp(row * columns + colAt(col), 0, itemCount - 1)];
 		},
 		itemOfPage(pi) {
-			return clamp(upperBound(firstPage, pi) - 1, 0, n - 1);
+			return clamp(upperBound(firstPage, pi) - 1, 0, itemCount - 1);
 		}
 	};
 }