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

package/dist/resolveAnnotationDraft-7Ke4nV7F.cjs

@@ -0,0 +1,3646 @@
+const require_format = require("./format-Bp3QFSH1.cjs");
+//#region src/geometry/convert.ts
+/**
+* Whether `value` is a rect: `left`, `bottom`, `right` and `top`, each a finite number. A rect
+* with `Infinity` or `NaN` in it places nothing, so every write refuses one: here on the page,
+* and by `PdfRectSchema` and `PageBoxSchema` in the engine and on the wire.
+*/
+function isFinitePdfRect(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const { left, bottom, right, top } = value;
+	return [
+		left,
+		bottom,
+		right,
+		top
+	].every((edge) => typeof edge === "number" && Number.isFinite(edge));
+}
+/**
+* Normalize a `PdfRect` to the y-up invariant (`left <= right`, `bottom <= top`),
+* regardless of how the PDF ordered the corners (a `/Rect` array or `FS_RECTF`
+* may carry them in any order). The enforcement point for the "PdfRect is always
+* normalized" rule: every producer that reads a raw box from PDFium passes it
+* through here, so the invariant holds once, centrally — downstream `width =
+* right - left` is never negative.
+*/
+function normalizePdfRect(r) {
+	return {
+		left: Math.min(r.left, r.right),
+		right: Math.max(r.left, r.right),
+		bottom: Math.min(r.top, r.bottom),
+		top: Math.max(r.top, r.bottom)
+	};
+}
+function pdfRectWidth(r) {
+	return r.right - r.left;
+}
+function pdfRectHeight(r) {
+	return r.top - r.bottom;
+}
+function pdfRectSize(r) {
+	return {
+		width: r.right - r.left,
+		height: r.top - r.bottom
+	};
+}
+/** Convert edges -> origin+size, staying y-up (origin at bottom-left). */
+function pdfRectToOriginSize(r) {
+	return {
+		x: r.left,
+		y: r.bottom,
+		width: r.right - r.left,
+		height: r.top - r.bottom
+	};
+}
+/** Convert y-up origin+size back to edges. */
+function pdfRectFromOriginSize(o) {
+	return {
+		left: o.x,
+		bottom: o.y,
+		right: o.x + o.width,
+		top: o.y + o.height
+	};
+}
+/**
+* Enclosing axis-aligned box of a quad, in PDF user space. Orientation
+* agnostic (correct for rotated/skewed quads) — this is what highlight
+* rendering and hit-testing want.
+*/
+function pdfQuadBounds(q) {
+	const xs = [
+		q.upperLeft.x,
+		q.upperRight.x,
+		q.lowerLeft.x,
+		q.lowerRight.x
+	];
+	const ys = [
+		q.upperLeft.y,
+		q.upperRight.y,
+		q.lowerLeft.y,
+		q.lowerRight.y
+	];
+	return {
+		left: Math.min(...xs),
+		right: Math.max(...xs),
+		bottom: Math.min(...ys),
+		top: Math.max(...ys)
+	};
+}
+const QUAD_EPSILON = 1e-6;
+const isFinitePoint = (point) => Number.isFinite(point.x) && Number.isFinite(point.y);
+/** Whether the four points, read as upper-left, upper-right, lower-left, lower-right, make a quad. */
+function isZigzagQuad([ul, ur, ll, lr]) {
+	if (![
+		ul,
+		ur,
+		ll,
+		lr
+	].every(isFinitePoint)) return false;
+	const upper = {
+		x: ur.x - ul.x,
+		y: ur.y - ul.y
+	};
+	const lower = {
+		x: lr.x - ll.x,
+		y: lr.y - ll.y
+	};
+	const left = {
+		x: ll.x - ul.x,
+		y: ll.y - ul.y
+	};
+	const right = {
+		x: lr.x - ur.x,
+		y: lr.y - ur.y
+	};
+	const lengths = [
+		upper,
+		lower,
+		left,
+		right
+	].map((edge) => Math.hypot(edge.x, edge.y));
+	if (lengths.some((length) => length <= QUAD_EPSILON)) return false;
+	if (upper.x * lower.x + upper.y * lower.y <= 0) return false;
+	if (left.x * right.x + left.y * right.y <= 0) return false;
+	const leftArea = upper.x * left.y - upper.y * left.x;
+	const rightArea = lower.x * right.y - lower.y * right.x;
+	if (Math.abs(leftArea) <= QUAD_EPSILON * lengths[0] * lengths[2]) return false;
+	if (Math.abs(rightArea) <= QUAD_EPSILON * lengths[1] * lengths[3]) return false;
+	return Math.sign(leftArea) === Math.sign(rightArea);
+}
+/**
+* Name the corners of a `/QuadPoints` entry. Writers disagree on the order,
+* so every quad read from a file passes through here, and the corner names
+* hold once, centrally:
+*
+*   1. the order Acrobat writes and reads (upper-left, upper-right,
+*      lower-left, lower-right) is kept, turned quads included;
+*   2. the ring order some writers use (upper-left, upper-right, lower-right,
+*      lower-left) is repaired;
+*   3. anything else is named from its shape: the corners go round their
+*      middle, the edge highest on the page (largest y) is the upper one, and
+*      its end with the smaller x is the left. Which side of a quad is up
+*      cannot be told from four points alone; this rule decides it.
+*
+* A misnamed quad can move an underline to the wrong edge, never cross it.
+*/
+function normalizePdfQuad(points) {
+	const [first, second, third, fourth] = points;
+	if (isZigzagQuad(points)) return {
+		upperLeft: first,
+		upperRight: second,
+		lowerLeft: third,
+		lowerRight: fourth
+	};
+	if (isZigzagQuad([
+		first,
+		second,
+		fourth,
+		third
+	])) return {
+		upperLeft: first,
+		upperRight: second,
+		lowerLeft: fourth,
+		lowerRight: third
+	};
+	const finite = points.map((point) => isFinitePoint(point) ? point : {
+		x: 0,
+		y: 0
+	});
+	const cx = finite.reduce((sum, point) => sum + point.x, 0) / 4;
+	const cy = finite.reduce((sum, point) => sum + point.y, 0) / 4;
+	const ring = [...finite].sort((a, b) => Math.atan2(a.y - cy, a.x - cx) - Math.atan2(b.y - cy, b.x - cx));
+	let upper = 0;
+	for (let i = 1; i < 4; i++) if (ring[i].y + ring[(i + 1) % 4].y > ring[upper].y + ring[(upper + 1) % 4].y) upper = i;
+	const upperEnds = [ring[upper], ring[(upper + 1) % 4]];
+	const lowerEnds = [ring[(upper + 3) % 4], ring[(upper + 2) % 4]];
+	return upperEnds[0].x <= upperEnds[1].x ? {
+		upperLeft: upperEnds[0],
+		upperRight: upperEnds[1],
+		lowerLeft: lowerEnds[0],
+		lowerRight: lowerEnds[1]
+	} : {
+		upperLeft: upperEnds[1],
+		upperRight: upperEnds[0],
+		lowerLeft: lowerEnds[1],
+		lowerRight: lowerEnds[0]
+	};
+}
+/**
+* The upright box around `rect` turned by `degrees` about its middle, either
+* way: the `/Rect` of a turned box. A quarter turn is exact: the sides swap.
+*/
+function pdfRectTurnedBounds(rect, degrees) {
+	const quarterTurn = quarterTurnOf(degrees);
+	if (quarterTurn !== null) return pdfQuarterTurnBox(rect, quarterTurn);
+	const radians = degrees * Math.PI / 180;
+	const cos = Math.abs(Math.cos(radians));
+	const sin = Math.abs(Math.sin(radians));
+	const width = rect.right - rect.left;
+	const height = rect.top - rect.bottom;
+	const halfAcross = (width * cos + height * sin) / 2;
+	const halfUp = (width * sin + height * cos) / 2;
+	const x = (rect.left + rect.right) / 2;
+	const y = (rect.bottom + rect.top) / 2;
+	return {
+		left: x - halfAcross,
+		bottom: y - halfUp,
+		right: x + halfAcross,
+		top: y + halfUp
+	};
+}
+/**
+* `degrees` as a quarter turn (clockwise, 0 to 270), or `null` when it isn't
+* one. A negative turn, or one past a whole turn, is the same turn.
+*/
+function quarterTurnOf(degrees) {
+	const turn = (degrees % 360 + 360) % 360;
+	return turn % 90 === 0 ? turn : null;
+}
+/**
+* The box that, turned `rotation` about its middle, stands upright in
+* `rect`: `rect` itself, its sides swapped under 90 and 270. The inverse of
+* {@link pdfRectTurnedBounds} for a quarter turn, which is the one turn a
+* rect pins a box down for.
+*/
+function pdfQuarterTurnBox(rect, rotation) {
+	if (rotation === 0 || rotation === 180) return rect;
+	const x = (rect.left + rect.right) / 2;
+	const y = (rect.bottom + rect.top) / 2;
+	const halfWidth = (rect.top - rect.bottom) / 2;
+	const halfHeight = (rect.right - rect.left) / 2;
+	return {
+		left: x - halfWidth,
+		bottom: y - halfHeight,
+		right: x + halfWidth,
+		top: y + halfHeight
+	};
+}
+/**
+* The area two normalized rects share, or `null` when they share none. Keys
+* in `normalizePdfRect`'s order, so a rect reads the same whichever made it.
+*/
+function pdfRectIntersection(rect, other) {
+	const left = Math.max(rect.left, other.left);
+	const right = Math.min(rect.right, other.right);
+	const bottom = Math.max(rect.bottom, other.bottom);
+	const top = Math.min(rect.top, other.top);
+	return left < right && bottom < top ? {
+		left,
+		right,
+		bottom,
+		top
+	} : null;
+}
+/**
+* Whether two rects are the same within what a file's numbers hold: Acrobat
+* writes three decimals, and a rect the engine writes is floats.
+*/
+function isSamePdfRect(rect, other) {
+	const tolerance = .01 + 1e-4 * Math.max(rect.right - rect.left, rect.top - rect.bottom, other.right - other.left, other.top - other.bottom);
+	return Math.abs(rect.left - other.left) <= tolerance && Math.abs(rect.bottom - other.bottom) <= tolerance && Math.abs(rect.right - other.right) <= tolerance && Math.abs(rect.top - other.top) <= tolerance;
+}
+//#endregion
+//#region src/geometry/pointTurn.ts
+/** The box around `points`; a zero box at the origin when there are none. */
+function pdfPointsBounds(points) {
+	if (points.length === 0) return {
+		left: 0,
+		bottom: 0,
+		right: 0,
+		top: 0
+	};
+	let left = Infinity;
+	let bottom = Infinity;
+	let right = -Infinity;
+	let top = -Infinity;
+	for (const { x, y } of points) {
+		left = Math.min(left, x);
+		bottom = Math.min(bottom, y);
+		right = Math.max(right, x);
+		top = Math.max(top, y);
+	}
+	return {
+		left,
+		bottom,
+		right,
+		top
+	};
+}
+/** `point` turned by `turn`; a negative angle turns it back. */
+function pdfPointTurned(point, turn) {
+	const radians = turn.degrees * Math.PI / 180;
+	const cos = Math.cos(radians);
+	const sin = Math.sin(radians);
+	const dx = point.x - turn.center.x;
+	const dy = point.y - turn.center.y;
+	return {
+		x: turn.center.x + dx * cos + dy * sin,
+		y: turn.center.y - dx * sin + dy * cos
+	};
+}
+/** `point` turned back by `turn`. */
+function pdfPointUnturned(point, turn) {
+	return pdfPointTurned(point, {
+		degrees: -turn.degrees,
+		center: turn.center
+	});
+}
+const middleOf = (rect) => ({
+	x: (rect.left + rect.right) / 2,
+	y: (rect.bottom + rect.top) / 2
+});
+/** The turn that draws upright `points`: `degrees` about the middle of their box. */
+function pdfTurnOfUpright(points, degrees) {
+	return {
+		degrees,
+		center: middleOf(pdfPointsBounds(points))
+	};
+}
+/**
+* The turn drawn `points` were made with: `degrees` about the middle of the
+* box around the upright points they came from. That middle is where the turn
+* leaves it, so it follows from the drawing: turned back about the origin, the
+* points are the upright ones moved, and turning their middle forward again
+* about the origin gives it.
+*/
+function pdfTurnOfDrawn(points, degrees) {
+	const origin = {
+		x: 0,
+		y: 0
+	};
+	const back = points.map((point) => pdfPointTurned(point, {
+		degrees: -degrees,
+		center: origin
+	}));
+	return {
+		degrees,
+		center: pdfPointTurned(middleOf(pdfPointsBounds(back)), {
+			degrees,
+			center: origin
+		})
+	};
+}
+//#endregion
+//#region src/dto/RichText.ts
+/**
+* The body a partial input body completes itself from: Helvetica 12 pt
+* black, left-aligned, ltr, nothing else set.
+*/
+const DEFAULT_RICH_TEXT_BODY = {
+	family: "Helvetica",
+	weight: 400,
+	italic: false,
+	size: 12,
+	color: "#000000",
+	decoration: [],
+	script: "normal",
+	letterSpacing: 0,
+	horizontalScale: 1,
+	align: "left",
+	dir: "ltr"
+};
+/** The plain-text projection of a rich document: paragraphs joined by `\r`,
+*  runs concatenated — what the engine writes to `/Contents`. */
+function richTextPlainText(doc) {
+	return doc.paragraphs.map((p) => p.runs.map((r) => r.text).join("")).join("\r");
+}
+/** Plain text as rich paragraphs: one per line break, one run each, no
+*  overrides (the engine's own `/Contents` fallback shape). */
+function richTextParagraphsFromPlainText(text) {
+	return text.split(/\r\n|\r|\n/).map((line) => ({ runs: [{ text: line }] }));
+}
+//#endregion
+//#region src/annotation/color.ts
+/** One 0..255 component as two lowercase hex digits. */
+const hex2 = (component) => Math.max(0, Math.min(255, Math.round(component))).toString(16).padStart(2, "0");
+/** A color from its 0..255 sRGB components, as the engine gives colors. */
+function colorOf(r, g, b) {
+	return `#${hex2(r)}${hex2(g)}${hex2(b)}`;
+}
+/** The 0..255 sRGB components of a `'#rrggbb'` color, in either case. */
+function rgbOf(color) {
+	const value = Number.parseInt(color.slice(1), 16);
+	return {
+		r: value >> 16 & 255,
+		g: value >> 8 & 255,
+		b: value & 255
+	};
+}
+/** Whether two colors are the same, whatever the case of their digits. */
+function sameColor(a, b) {
+	return a.toLowerCase() === b.toLowerCase();
+}
+//#endregion
+//#region src/annotation/kind-facts.generated.ts
+/** Each annotation kind's {@link KindFacts}, in the engine's catalog order. */
+const ANNOTATION_KIND_FACTS = {
+	highlight: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "engine",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			color: "data",
+			opacity: "data",
+			quadPoints: "data"
+		},
+		readBack: ["rect"],
+		colors: ["color"],
+		spaces: {
+			rect: "box",
+			actions: "actions",
+			quadPoints: "quads"
+		},
+		resources: {}
+	},
+	underline: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "engine",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			color: "data",
+			opacity: "data",
+			quadPoints: "data"
+		},
+		readBack: ["rect"],
+		colors: ["color"],
+		spaces: {
+			rect: "box",
+			actions: "actions",
+			quadPoints: "quads"
+		},
+		resources: {}
+	},
+	squiggly: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "engine",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			color: "data",
+			opacity: "data",
+			quadPoints: "data"
+		},
+		readBack: ["rect"],
+		colors: ["color"],
+		spaces: {
+			rect: "box",
+			actions: "actions",
+			quadPoints: "quads"
+		},
+		resources: {}
+	},
+	strikeout: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "engine",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			color: "data",
+			opacity: "data",
+			quadPoints: "data",
+			intent: "data"
+		},
+		readBack: ["rect"],
+		colors: ["color"],
+		spaces: {
+			rect: "box",
+			actions: "actions",
+			quadPoints: "quads"
+		},
+		resources: {}
+	},
+	circle: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "engine",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			color: "data",
+			opacity: "data",
+			strokeWidth: "data",
+			borderStyle: "data",
+			dashArray: "data",
+			interiorColor: "data",
+			box: "data",
+			rotation: "data",
+			cloudyIntensity: "data"
+		},
+		readBack: ["rect", "borderStyle"],
+		colors: ["color", "interiorColor"],
+		spaces: {
+			rect: "box",
+			actions: "actions",
+			box: "box"
+		},
+		resources: {}
+	},
+	square: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "engine",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			color: "data",
+			opacity: "data",
+			strokeWidth: "data",
+			borderStyle: "data",
+			dashArray: "data",
+			interiorColor: "data",
+			box: "data",
+			rotation: "data",
+			cloudyIntensity: "data"
+		},
+		readBack: ["rect", "borderStyle"],
+		colors: ["color", "interiorColor"],
+		spaces: {
+			rect: "box",
+			actions: "actions",
+			box: "box"
+		},
+		resources: {}
+	},
+	polygon: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "engine",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			color: "data",
+			opacity: "data",
+			strokeWidth: "data",
+			borderStyle: "data",
+			dashArray: "data",
+			interiorColor: "data",
+			vertices: "data",
+			rotation: "data",
+			captionEnabled: "data",
+			captionCenter: "data",
+			intent: "data",
+			measure: "data",
+			cloudyIntensity: "data"
+		},
+		readBack: [
+			"rect",
+			"borderStyle",
+			"vertices"
+		],
+		colors: ["color", "interiorColor"],
+		spaces: {
+			rect: "box",
+			actions: "actions",
+			vertices: "points",
+			captionCenter: "point",
+			measure: "measure"
+		},
+		resources: {}
+	},
+	polyline: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "engine",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			color: "data",
+			opacity: "data",
+			strokeWidth: "data",
+			borderStyle: "data",
+			dashArray: "data",
+			interiorColor: "data",
+			vertices: "data",
+			rotation: "data",
+			captionEnabled: "data",
+			captionCenter: "data",
+			intent: "data",
+			measure: "data",
+			lineEndings: "data"
+		},
+		readBack: [
+			"rect",
+			"borderStyle",
+			"vertices"
+		],
+		colors: ["color", "interiorColor"],
+		spaces: {
+			rect: "box",
+			actions: "actions",
+			vertices: "points",
+			captionCenter: "point",
+			measure: "measure"
+		},
+		resources: {}
+	},
+	line: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "engine",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			color: "data",
+			opacity: "data",
+			strokeWidth: "data",
+			borderStyle: "data",
+			dashArray: "data",
+			interiorColor: "data",
+			linePoints: "data",
+			lineEndings: "data",
+			rotation: "data",
+			intent: "data",
+			measure: "data",
+			captionEnabled: "data",
+			captionPosition: "data",
+			captionOffset: "data",
+			leader: "data"
+		},
+		readBack: ["rect", "borderStyle"],
+		colors: ["color", "interiorColor"],
+		spaces: {
+			rect: "box",
+			actions: "actions",
+			linePoints: "linePoints",
+			measure: "measure"
+		},
+		resources: {}
+	},
+	link: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "data",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			target: "data"
+		},
+		readBack: ["target"],
+		colors: [],
+		spaces: {
+			rect: "box",
+			actions: "actions",
+			target: "linkTarget"
+		},
+		resources: {}
+	},
+	ink: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "engine",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			color: "data",
+			opacity: "data",
+			strokeWidth: "data",
+			borderStyle: "data",
+			dashArray: "data",
+			inkList: "data",
+			intent: "data",
+			rotation: "data"
+		},
+		readBack: [
+			"rect",
+			"strokeWidth",
+			"borderStyle",
+			"inkList"
+		],
+		colors: ["color"],
+		spaces: {
+			rect: "box",
+			actions: "actions",
+			inkList: "strokes"
+		},
+		resources: {}
+	},
+	"free-text": {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "engine",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			box: "data",
+			rotation: "data",
+			intent: "data",
+			fontFamily: "data",
+			fontSize: "data",
+			textAlign: "data",
+			verticalAlign: "data",
+			richText: "data",
+			color: "data",
+			fontColor: "data",
+			interiorColor: "data",
+			opacity: "data",
+			strokeWidth: "data",
+			borderStyle: "data",
+			dashArray: "data",
+			cloudyIntensity: "data",
+			calloutLine: "data",
+			lineEnding: "data"
+		},
+		readBack: [
+			"rect",
+			"intent",
+			"borderStyle"
+		],
+		colors: [
+			"color",
+			"fontColor",
+			"interiorColor"
+		],
+		spaces: {
+			rect: "box",
+			actions: "actions",
+			box: "box",
+			richText: "length",
+			calloutLine: "calloutLine"
+		},
+		resources: {}
+	},
+	caret: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "engine",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			color: "data",
+			opacity: "data",
+			box: "data",
+			rotation: "data",
+			intent: "data"
+		},
+		readBack: ["rect"],
+		colors: ["color"],
+		spaces: {
+			rect: "box",
+			actions: "actions",
+			box: "box"
+		},
+		resources: {}
+	},
+	text: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "data",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			color: "data",
+			opacity: "data",
+			icon: "data",
+			open: "data",
+			state: "data",
+			stateModel: "data"
+		},
+		readBack: [],
+		colors: ["color"],
+		spaces: {
+			rect: "box",
+			actions: "actions"
+		},
+		resources: {}
+	},
+	stamp: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "engine",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			box: "data",
+			rotation: "data",
+			name: "data",
+			fit: "data",
+			opacity: "data"
+		},
+		readBack: ["rect"],
+		colors: [],
+		spaces: {
+			rect: "box",
+			actions: "actions",
+			box: "box"
+		},
+		resources: { appearance: "required" }
+	},
+	"file-attachment": {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "data",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			color: "data",
+			opacity: "data",
+			icon: "data",
+			file: "data"
+		},
+		readBack: [],
+		colors: ["color"],
+		spaces: {
+			rect: "box",
+			actions: "actions"
+		},
+		resources: { file: "required" }
+	},
+	widget: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "engine",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "data",
+			box: "data",
+			rotation: "data",
+			color: "data",
+			interiorColor: "data",
+			strokeWidth: "data",
+			borderStyle: "data",
+			dashArray: "data",
+			fontFamily: "data",
+			fontSize: "data",
+			fontColor: "data",
+			textAlign: "data",
+			caption: "data",
+			checkStyle: "data",
+			field: "engine",
+			fieldFamily: "engine"
+		},
+		readBack: ["rect", "actions"],
+		colors: [
+			"color",
+			"interiorColor",
+			"fontColor"
+		],
+		spaces: {
+			rect: "box",
+			actions: "actions",
+			box: "box"
+		},
+		resources: {}
+	},
+	redact: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "data",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			color: "data",
+			opacity: "data",
+			quadPoints: "data",
+			interiorColor: "data",
+			overlayText: "data",
+			repeat: "data",
+			fontFamily: "data",
+			fontSize: "data",
+			fontColor: "data",
+			textAlign: "data"
+		},
+		readBack: [],
+		colors: [
+			"color",
+			"interiorColor",
+			"fontColor"
+		],
+		spaces: {
+			rect: "box",
+			actions: "actions",
+			quadPoints: "quads"
+		},
+		resources: {}
+	},
+	popup: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "data",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			parent: "data",
+			open: "data"
+		},
+		readBack: ["parent"],
+		colors: [],
+		spaces: {
+			rect: "box",
+			actions: "actions"
+		},
+		resources: {}
+	},
+	unsupported: {
+		owners: {
+			ref: "engine",
+			page: "engine",
+			hasAppearance: "engine",
+			appearanceState: "engine",
+			nm: "data",
+			rect: "data",
+			contents: "data",
+			subject: "data",
+			blendMode: "data",
+			invisible: "data",
+			hidden: "data",
+			print: "data",
+			noZoom: "data",
+			noRotate: "data",
+			noView: "data",
+			readOnly: "data",
+			locked: "data",
+			toggleNoView: "data",
+			lockedContents: "data",
+			reply: "data",
+			popup: "engine",
+			groupId: "data",
+			author: "attribution",
+			createdAt: "attribution",
+			modifiedAt: "attribution",
+			userId: "attribution",
+			createdBy: "attribution",
+			modifiedBy: "attribution",
+			importedBy: "engine",
+			actions: "preserved",
+			rawSubtypeCode: "engine",
+			rawSubtypeName: "engine"
+		},
+		readBack: [],
+		colors: [],
+		spaces: {
+			rect: "box",
+			actions: "actions"
+		},
+		resources: {}
+	}
+};
+//#endregion
+//#region src/annotation/kind-facts.ts
+/** A table with an entry for every kind, worked out from the kind's facts. */
+function mapKindFacts(of) {
+	const table = {};
+	for (const subtype of Object.keys(ANNOTATION_KIND_FACTS)) table[subtype] = of(ANNOTATION_KIND_FACTS[subtype]);
+	return table;
+}
+/** The facts of the kind `subtype` names, or `null` when no kind has that subtype. */
+function kindFactsOf(subtype) {
+	return Object.prototype.hasOwnProperty.call(ANNOTATION_KIND_FACTS, subtype) ? ANNOTATION_KIND_FACTS[subtype] : null;
+}
+//#endregion
+//#region src/annotation/field-names.ts
+/**
+* Every field each annotation kind declares, in declaration order, without zod, for code that
+* checks the keys of a write but can't load the schemas (the engines, their workers, the
+* viewer). From `kind-facts.generated.ts`.
+*/
+const ANNOTATION_FIELD_NAMES = mapKindFacts((facts) => Object.keys(facts.owners));
+/** The resources each kind takes (`create(data, resources)`), without zod. */
+const ANNOTATION_RESOURCE_ROLES = mapKindFacts((facts) => facts.resources);
+//#endregion
+//#region src/annotation/field-spaces.ts
+/**
+* The fields of each annotation kind that hold something measured on the page, and what they
+* hold (`FieldSpace`), without zod, for the code that converts values between the file's
+* coordinates and page space in the engines and their workers. From
+* `kind-facts.generated.ts`; `test/annotation/field-spaces.test.ts` checks that no declared
+* field holds a place on the page without saying so.
+*/
+const ANNOTATION_FIELD_SPACES = mapKindFacts((facts) => facts.spaces);
+/**
+* Every measured field by its name, whatever its kind: a name holds the same
+* thing in every kind (`test/annotation/field-spaces.test.ts` keeps it so).
+* An update that leaves out its kind converts by this.
+*/
+const ANNOTATION_FIELD_SPACES_BY_NAME = Object.assign({}, ...Object.values(ANNOTATION_FIELD_SPACES));
+//#endregion
+//#region src/dto/IsoDateTime.ts
+/**
+* Order two moments by the instant they name. Their text doesn't order them:
+* `2017-07-12T21:44:38-07:00` is later than `2017-07-13T01:00:00Z`.
+*/
+function compareIsoDateTime(a, b) {
+	const difference = Date.parse(a) - Date.parse(b);
+	return Number.isNaN(difference) ? 0 : difference;
+}
+//#endregion
+//#region src/transfer/bundle.ts
+/**
+* What every bundle shares, whichever family it carries: resources named by
+* the SHA-256 of their bytes, the table of pages its rows are on, the checks
+* of that shape, and where an import puts each page.
+*/
+const RESOURCE_ID_PATTERN = /^sha256-[0-9a-f]{64}$/;
+const PAGE_FIELDS = [
+	"page",
+	"position",
+	"size"
+];
+/** The id of a resource: the SHA-256 of its bytes. */
+async function resourceIdOf(bytes) {
+	const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+	let hex = "";
+	for (const byte of digest) hex += byte.toString(16).padStart(2, "0");
+	return `sha256-${hex}`;
+}
+/** Every resource's bytes hash to its id. */
+async function assertResourceIds(kind, resources) {
+	for (const [id, bytes] of Object.entries(resources)) if (await resourceIdOf(bytes) !== id) invalidBundle(kind, `resource ${id} doesn't match its id`);
+}
+/**
+* Check a bundle's page table: each entry a page ref, a position and a
+* size, no page or position listed twice. Returns the listed pages' keys,
+* for the rows to be checked against.
+*/
+function assertBundlePages(kind, pages) {
+	const pageKeys = /* @__PURE__ */ new Set();
+	const positions = /* @__PURE__ */ new Set();
+	for (const entry of pages) {
+		if (!isRecord(entry) || !isBundlePageRef(entry.page) || !isSize(entry.size)) invalidBundle(kind, "a page needs a page ref, a position and a size");
+		assertKnownFields(kind, "a page", entry, PAGE_FIELDS);
+		const { position } = entry;
+		if (!Number.isInteger(position) || position < 0) invalidBundle(kind, `page position ${JSON.stringify(position)} is not a position`);
+		const key = require_format.encodePageKey(entry.page);
+		if (pageKeys.has(key)) invalidBundle(kind, `page ${key} is listed twice`);
+		if (positions.has(position)) invalidBundle(kind, `position ${position} is listed twice`);
+		pageKeys.add(key);
+		positions.add(position);
+	}
+	return pageKeys;
+}
+/**
+* Check the resources a row names, by role: each role one of `roles`, each
+* id a resource id the bundle holds. Each id is added to `named`.
+*/
+function assertRowResources(kind, row, resources, roles, resourceSizes, named) {
+	if (!isRecord(resources)) invalidBundle(kind, `${row} has no resources`);
+	for (const [role, id] of Object.entries(resources)) {
+		if (!roles.includes(role)) invalidBundle(kind, `${row} names an unknown resource role '${role}'`);
+		if (typeof id !== "string" || !RESOURCE_ID_PATTERN.test(id)) invalidBundle(kind, `${row} names ${JSON.stringify(id)}, which is not a resource id`);
+		if (!resourceSizes.has(id)) invalidBundle(kind, `${row} names ${id}, which the bundle doesn't hold`);
+		named.add(id);
+	}
+}
+/**
+* Every resource the bundle holds has a resource id and is named by one of
+* its `rows` (`'item'`, `'widget'`).
+*/
+function assertResourcesNamed(kind, rows, resourceSizes, named) {
+	for (const id of resourceSizes.keys()) {
+		if (!RESOURCE_ID_PATTERN.test(id)) invalidBundle(kind, `${JSON.stringify(id)} is not a resource id`);
+		if (!named.has(id)) invalidBundle(kind, `resource ${id} is named by no ${rows}`);
+	}
+}
+/** `value` has no field outside `fields`. */
+function assertKnownFields(kind, what, value, fields) {
+	for (const field of Object.keys(value)) if (!fields.includes(field)) invalidBundle(kind, `${what} has an unknown field '${field}'`);
+}
+/** Refuse a bundle that isn't one: `InvalidArg`, naming its kind. */
+function invalidBundle(kind, message) {
+	throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `${kind} bundle: ${message}`);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** A page ref as a bundle holds one: by object number. */
+function isBundlePageRef(value) {
+	return isRecord(value) && value.kind === "objectNumber" && Number.isInteger(value.objectNumber) && value.objectNumber > 0;
+}
+function isSize(value) {
+	return isRecord(value) && [value.width, value.height].every((length) => typeof length === "number" && Number.isFinite(length) && length >= 0);
+}
+/**
+* Where an import puts each page of a bundle, as `pages` says, among the
+* `target` document's pages. Every page in `named` (the pages the rows are
+* on or point at) must map somewhere: `InvalidArg` names those that don't,
+* and a list that maps to a page the target doesn't have is `NotFound`.
+* Nothing here touches a document, so an import refuses before its first
+* write.
+*/
+function bundlePageMapping(input) {
+	const table = pageTable(input.bundlePages, input.pages, input.target);
+	const unmapped = /* @__PURE__ */ new Set();
+	for (const page of input.named) if (!table.has(require_format.encodePageKey(page))) unmapped.add(require_format.encodePageKey(page));
+	if (unmapped.size > 0) {
+		const pages = [...unmapped];
+		throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `import: ${pages.length === 1 ? "page" : "pages"} ${pages.join(", ")} map to no page of this document`, { details: { pages } });
+	}
+	return (page) => table.get(require_format.encodePageKey(page));
+}
+/** Bundle page key → target page. */
+function pageTable(bundlePages, pages, target) {
+	const targetByKey = new Map(target.map((entry) => [require_format.encodePageKey(entry.page), entry.page]));
+	const table = /* @__PURE__ */ new Map();
+	if (pages === "same") for (const entry of bundlePages) {
+		const to = targetByKey.get(require_format.encodePageKey(entry.page));
+		if (to) table.set(require_format.encodePageKey(entry.page), to);
+	}
+	else if (pages === "by-position") {
+		const byPosition = new Map(target.map((entry) => [entry.position, entry.page]));
+		for (const entry of bundlePages) {
+			const to = byPosition.get(entry.position);
+			if (to) table.set(require_format.encodePageKey(entry.page), to);
+		}
+	} else for (const { from, to } of pages) {
+		const key = require_format.encodePageKey(from);
+		if (table.has(key)) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `import: page ${key} is mapped twice`);
+		const found = targetByKey.get(require_format.encodePageKey(to));
+		if (!found) throw new require_format.EngineError(require_format.EngineErrorCode.NotFound, `import: the document has no page ${require_format.encodePageKey(to)}`);
+		table.set(key, found);
+	}
+	return table;
+}
+//#endregion
+//#region src/annotation/relationships.ts
+/**
+* Classify one annotation by its relationship edge alone. Mirrors the
+* spec's "practical parser rule": no `/IRT` is top-level; `/RT /Group` is
+* a grouped subordinate; anything else with an `/IRT` is a reply (the
+* engine has already normalized a missing `/RT` to `'reply'`).
+*/
+function classifyRelation(a) {
+	if (!a.reply) return "top-level";
+	return a.reply.type === "group" ? "grouped-subordinate" : "reply";
+}
+/**
+* Compose a flat annotation list (one page, or a whole document from
+* `annotations.list()`) into {@link AnnotationThread}s in primary
+* order.
+*
+* Rules (ISO 32000 §12.5.6.2 + the spec's UI rule):
+*   - Annotations with no `/IRT` become thread primaries, in input order.
+*   - A `/RT /Group` child is attached to its primary's `groupedParts`.
+*   - A `/RT /R` (or default) child is attached to its primary's `replies`.
+*   - A child whose parent is not in the input set is treated as an
+*     orphan primary (defensive — e.g. a partial/filtered page slice).
+*
+* Limitations (v1, matches the legacy stack): threading is one level deep
+* — a reply-to-a-reply is keyed to its direct parent, so it only appears
+* nested if that direct parent is itself a primary. Callers that want a
+* sidebar of "most annotations, not widgets/popups" should pre-filter the
+* input; this helper is intentionally unopinionated about eligibility.
+*/
+function buildThreads(annotations) {
+	const byKey = new Map(annotations.map((a) => [require_format.annotationKey(a.ref), a]));
+	const threads = [];
+	const threadByPrimaryKey = /* @__PURE__ */ new Map();
+	const primaryThread = (primary) => {
+		const key = require_format.annotationKey(primary.ref);
+		let thread = threadByPrimaryKey.get(key);
+		if (!thread) {
+			thread = {
+				primary,
+				groupedParts: [],
+				replies: []
+			};
+			threadByPrimaryKey.set(key, thread);
+			threads.push(thread);
+		}
+		return thread;
+	};
+	for (const a of annotations) if (!a.reply) primaryThread(a);
+	for (const a of annotations) {
+		if (!a.reply) continue;
+		const parent = byKey.get(require_format.annotationKey(a.reply.to));
+		if (!parent || parent.reply) {
+			primaryThread(a);
+			continue;
+		}
+		const thread = primaryThread(parent);
+		if (a.reply.type === "group") thread.groupedParts.push(a);
+		else thread.replies.push(a);
+	}
+	return threads;
+}
+/**
+* An annotation and everything deleted with it: every annotation whose
+* `reply.to` leads to it (replies, their replies, grouped parts, review
+* states) and every popup of these. A reply left behind would point at
+* nothing and show as a note of its own in other viewers; a popup left
+* behind would show nobody's text. Children come before their parent and a
+* popup before the annotation it shows, so the annotation itself is last.
+* Empty when `ref` names nothing in `annotations`.
+*/
+function deletedWith(annotations, ref) {
+	const byKey = new Map(annotations.map((annotation) => [require_format.annotationKey(annotation.ref), annotation]));
+	const target = byKey.get(require_format.annotationKey(ref));
+	if (!target) return [];
+	const children = /* @__PURE__ */ new Map();
+	const popups = /* @__PURE__ */ new Map();
+	const add = (map, key, value) => map.set(key, [...map.get(key) ?? [], value]);
+	for (const annotation of annotations) {
+		const parent = annotation.reply ? byKey.get(require_format.annotationKey(annotation.reply.to)) : void 0;
+		if (parent && parent !== annotation) add(children, parent, annotation);
+		const shows = annotation.subtype === "popup" && annotation.parent ? byKey.get(require_format.annotationKey(annotation.parent)) : void 0;
+		if (shows && shows !== annotation) add(popups, shows, annotation);
+		const own = annotation.popup ? byKey.get(require_format.annotationKey(annotation.popup)) : void 0;
+		if (own && own !== annotation && own.subtype === "popup") add(popups, annotation, own);
+	}
+	const members = [];
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (annotation) => {
+		if (seen.has(annotation)) return;
+		seen.add(annotation);
+		for (const child of children.get(annotation) ?? []) visit(child);
+		for (const popup of popups.get(annotation) ?? []) {
+			if (seen.has(popup)) continue;
+			seen.add(popup);
+			members.push(popup);
+		}
+		members.push(annotation);
+	};
+	visit(target);
+	return members;
+}
+//#endregion
+//#region src/annotation/comments.ts
+/** Subtypes that never participate in comment threads: a popup is its
+*  parent's window and an unsupported blob is unreadable, so neither makes
+*  a comment card. */
+const EXCLUDED_SUBTYPES = /* @__PURE__ */ new Set([
+	"widget",
+	"link",
+	"popup",
+	"unsupported"
+]);
+const REVIEW_STATES = /* @__PURE__ */ new Set([
+	"accepted",
+	"rejected",
+	"cancelled",
+	"completed",
+	"none"
+]);
+const MARKED_STATES = /* @__PURE__ */ new Set(["marked", "unmarked"]);
+/**
+* The model a standard state belongs to (ISO 32000 §12.5.6.3, Table 174):
+* `'review'` for accepted, rejected, cancelled, completed and none,
+* `'marked'` for marked and unmarked; `null` for a custom state.
+*/
+function standardStateModelOf(state) {
+	if (REVIEW_STATES.has(state)) return "review";
+	if (MARKED_STATES.has(state)) return "marked";
+	return null;
+}
+const nonEmpty = (v) => typeof v === "string" && v !== "";
+/**
+* An ISO 32000 §12.5.6.3 state annotation: a text annotation carrying a
+* non-empty `/State` or `/StateModel`. Classification never relies on
+* flags — producers disagree on how state annotations are flagged.
+*/
+function isStateAnnotation(a) {
+	return a.subtype === "text" && (nonEmpty(a.state) || nonEmpty(a.stateModel));
+}
+function buildCommentThreads(annotations, opts = {}) {
+	const eligible = annotations.filter((a) => !EXCLUDED_SUBTYPES.has(a.subtype));
+	const byKey = new Map(eligible.map((a) => [require_format.annotationKey(a.ref), a]));
+	const chronological = chronologicalIn(new Map(eligible.map((a, at) => [require_format.annotationKey(a.ref), at])));
+	const children = /* @__PURE__ */ new Map();
+	for (const a of eligible) {
+		if (!a.reply) continue;
+		const parent = byKey.get(require_format.annotationKey(a.reply.to));
+		if (!parent) continue;
+		const parentKey = require_format.annotationKey(parent.ref);
+		const list = children.get(parentKey);
+		if (list) list.push(a);
+		else children.set(parentKey, [a]);
+	}
+	const visited = /* @__PURE__ */ new Set();
+	const threads = [];
+	const walk = (root) => {
+		const replies = [];
+		const groupedParts = [];
+		const states = [];
+		visited.add(require_format.annotationKey(root.ref));
+		const stack = [...children.get(require_format.annotationKey(root.ref)) ?? []];
+		while (stack.length > 0) {
+			const a = stack.pop();
+			const key = require_format.annotationKey(a.ref);
+			if (visited.has(key)) continue;
+			visited.add(key);
+			if (isStateAnnotation(a)) states.push(a);
+			else if (classifyRelation(a) === "grouped-subordinate") groupedParts.push(a);
+			else replies.push(a);
+			stack.push(...children.get(key) ?? []);
+		}
+		replies.sort(chronological);
+		states.sort(chronological);
+		threads.push({
+			root,
+			page: root.page,
+			replies,
+			groupedParts,
+			review: computeReview(states, opts)
+		});
+	};
+	for (const a of eligible) if (!a.reply && !isStateAnnotation(a)) walk(a);
+	for (const a of eligible) {
+		if (visited.has(require_format.annotationKey(a.ref))) continue;
+		if (isStateAnnotation(a)) continue;
+		walk(a);
+	}
+	return threads;
+}
+/** `createdAt ?? modifiedAt` ascending; undated last; z-order tiebreak. */
+function chronologicalIn(zOrder) {
+	return (a, b) => {
+		const at = a.createdAt ?? a.modifiedAt;
+		const bt = b.createdAt ?? b.modifiedAt;
+		const order = at !== null && bt !== null ? compareIsoDateTime(at, bt) : 0;
+		if (order !== 0) return order;
+		if (at !== null && bt === null) return -1;
+		if (at === null && bt !== null) return 1;
+		return zOrder.get(require_format.annotationKey(a.ref)) - zOrder.get(require_format.annotationKey(b.ref));
+	};
+}
+function computeReview(states, opts) {
+	const byReviewer = {};
+	const markedLatest = {};
+	let lastChange = null;
+	for (const a of states) {
+		const status = toReviewStatus(a);
+		if (!status) continue;
+		if (status.stateModel === "marked") {
+			if (status.by !== null && isNewer(status, markedLatest[status.by])) markedLatest[status.by] = status;
+			continue;
+		}
+		if (status.by !== null && isNewer(status, byReviewer[status.by])) byReviewer[status.by] = status;
+		if (isNewer(status, lastChange)) lastChange = status;
+	}
+	const markedBy = Object.keys(markedLatest).filter((key) => markedLatest[key].state === "marked").sort();
+	const review = {
+		byReviewer,
+		lastChange,
+		markedBy,
+		statusRefs: states.map((a) => a.ref)
+	};
+	if (opts.currentUserId !== void 0) review.mine = byReviewer[opts.currentUserId] ?? null;
+	return review;
+}
+/**
+* Derive a `ReviewStatus` from one state annotation, or null when nothing
+* classifiable can be derived. ISO defaulting happens here, not in the
+* engine reader: a known model with an absent state means `none` /
+* `unmarked`; an absent model infers from a known state; a custom model
+* with no state has no derivable status.
+*/
+function toReviewStatus(a) {
+	if (a.subtype !== "text") return null;
+	const rawState = nonEmpty(a.state) ? a.state : null;
+	let stateModel = nonEmpty(a.stateModel) ? a.stateModel : null;
+	if (stateModel === null && rawState !== null) {
+		stateModel = standardStateModelOf(rawState);
+		if (stateModel === null) return null;
+	}
+	let state = rawState;
+	if (state === null) if (stateModel === "review") state = "none";
+	else if (stateModel === "marked") state = "unmarked";
+	else return null;
+	if (stateModel === null) return null;
+	return {
+		state,
+		stateModel,
+		by: a.userId ?? (nonEmpty(a.author) ? a.author : null),
+		at: a.modifiedAt ?? a.createdAt ?? null,
+		ref: a.ref
+	};
+}
+/** `a` newer than (or supersedes) `b`. `at` decides; dated beats undated.
+*  States arrive pre-sorted by `chronological` (date, then z-order), so on
+*  equal or missing dates the later entry wins via `>=` / `true`. */
+function isNewer(a, b) {
+	if (!b) return true;
+	if (a.at !== null && b.at !== null) return compareIsoDateTime(a.at, b.at) >= 0;
+	if (a.at !== null) return true;
+	if (b.at !== null) return false;
+	return true;
+}
+//#endregion
+//#region src/annotation/appearance.ts
+/**
+* The kinds a write gives no appearance of the engine's: a link, which the
+* engine writes with no border to draw, and a form widget, which its form
+* field draws (one on its own has nothing to draw). A write leaves whether
+* the file holds one as it was, and a new one has none. Every other kind's
+* create bakes one, and so does every change to it that is visible and not a
+* pure move.
+*/
+const UNBAKED_KINDS = /* @__PURE__ */ new Set(["link", "widget"]);
+/**
+* Coordinate tolerance in PDF user-space points. PDF numbers round-trip
+* through f32 (~7 significant digits) and client-side space conversions, so
+* exact float equality would misclassify no-op writes; 1e-3 pt is far below
+* anything visible while far above accumulated f32 drift at page magnitudes.
+*/
+const EPSILON = .001;
+/**
+* Keys that never affect `/AP` on any kind: the discriminator, the `/F`
+* flags, the name, relationships and grouping, the conversation-plane
+* entries (`/Subj` subject line, `/State` + `/StateModel` review status —
+* dictionary-only per ISO 32000 §12.5.6.3, never painted), and the fields a
+* write accepts but never applies (addresses, attribution, `/A` and `/AA`).
+*/
+const INERT_KEYS = /* @__PURE__ */ new Set([
+	"subtype",
+	"invisible",
+	"hidden",
+	"print",
+	"noZoom",
+	"noRotate",
+	"noView",
+	"readOnly",
+	"locked",
+	"toggleNoView",
+	"lockedContents",
+	"nm",
+	"reply",
+	"popup",
+	"parent",
+	"open",
+	"groupId",
+	"subject",
+	"state",
+	"stateModel",
+	"ref",
+	"page",
+	"hasAppearance",
+	"appearanceState",
+	"author",
+	"createdAt",
+	"modifiedAt",
+	"userId",
+	"createdBy",
+	"modifiedBy",
+	"importedBy",
+	"actions",
+	"file",
+	"field",
+	"fieldFamily"
+]);
+/**
+* Kinds whose `/AP` paints `/Contents`. Everywhere else `contents` is popup
+* note text — editing a comment must never re-bake (or destroy) the shape's
+* appearance.
+*/
+const CONTENTS_PAINTED = /* @__PURE__ */ new Set(["free-text", "redact"]);
+/**
+* The kinds that turn by `rotation`: a box kind about the middle of its
+* `box`, a point kind about the middle of its points' box. Tri-state on
+* writes: an omitted rotation is kept, `null` (or `0`) clears it. Translation
+* verification therefore compares the after-state —
+* `patch.rotation ?? current.rotation` — not the patch keys.
+*/
+const TURNING_KINDS = /* @__PURE__ */ new Set([
+	"square",
+	"circle",
+	"free-text",
+	"stamp",
+	"caret",
+	"widget",
+	"line",
+	"polyline",
+	"polygon",
+	"ink"
+]);
+/**
+* Per-kind absolute-geometry fields (PDF user space) that a rigid translation
+* shifts together. A kind absent from this table never takes the translation
+* route. The first is where a move shows: the field the caller gives the
+* shape in (a `box`, the points, the quads), or `rect` where that is the
+* shape. A `rect` the engine works out moves with it.
+*/
+const TRANSLATABLE_GEOMETRY = {
+	square: ["box"],
+	circle: ["box"],
+	"free-text": ["box", "calloutLine"],
+	line: ["linePoints"],
+	polygon: ["vertices"],
+	polyline: ["vertices"],
+	ink: ["inkList"],
+	highlight: ["quadPoints"],
+	underline: ["quadPoints"],
+	squiggly: ["quadPoints"],
+	strikeout: ["quadPoints"],
+	redact: ["rect", "quadPoints"],
+	caret: ["box"],
+	text: ["rect"],
+	stamp: ["box"],
+	"file-attachment": ["rect"],
+	link: ["rect"],
+	widget: ["box"]
+};
+const numEq = (a, b) => Math.abs(a - b) <= EPSILON;
+/** Degrees normalized to [0,360); absent reads as 0 (no rotation). */
+const normDeg = (v) => {
+	return typeof v === "number" ? (v % 360 + 360) % 360 : 0;
+};
+/**
+* Semantic equality between a patch value and the current DTO value.
+* Numbers compare within {@link epsilon}; `null` and `undefined` both mean
+* "entry absent" (the tri-state clear of an absent entry is a no-op); arrays
+* and objects compare structurally.
+*/
+function semanticEqual(a, b) {
+	if (a == null || b == null) return a == null && b == null;
+	if (typeof a === "number" && typeof b === "number") return numEq(a, b);
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		return a.every((v, i) => semanticEqual(v, b[i]));
+	}
+	if (typeof a === "object" && typeof b === "object") {
+		const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+		for (const k of keys) if (!semanticEqual(a[k], b[k])) return false;
+		return true;
+	}
+	return a === b;
+}
+/**
+* Is `next` exactly `cur` shifted by `(dx, dy)`? Walks the value structurally:
+* numeric leaves under x-axis keys (`left`/`right`/`x`) must shift by `dx`,
+* y-axis keys (`bottom`/`top`/`y`) by `dy`, and any other numeric leaf must be
+* unchanged. Arrays walk elementwise (same length required).
+*/
+function shiftedBy(cur, next, dx, dy) {
+	if (cur == null || next == null) return cur == null && next == null;
+	if (Array.isArray(cur) || Array.isArray(next)) {
+		if (!Array.isArray(cur) || !Array.isArray(next) || cur.length !== next.length) return false;
+		return cur.every((v, i) => shiftedBy(v, next[i], dx, dy));
+	}
+	if (typeof cur === "object" && typeof next === "object") {
+		const keys = /* @__PURE__ */ new Set([...Object.keys(cur), ...Object.keys(next)]);
+		for (const k of keys) {
+			const c = cur[k];
+			const n = next[k];
+			if (typeof c === "number" && typeof n === "number") {
+				if (!numEq(c + (k === "left" || k === "right" || k === "x" ? dx : k === "bottom" || k === "top" || k === "y" ? dy : 0), n)) return false;
+			} else if (!shiftedBy(c, n, dx, dy)) return false;
+		}
+		return true;
+	}
+	return cur === next;
+}
+/**
+* The first point a geometry value holds: a rect's bottom-left, a point, a
+* line's start, a quad's first corner, the first of a list.
+*/
+function firstPoint(value) {
+	if (value == null || typeof value !== "object") return void 0;
+	if (Array.isArray(value)) return value.length > 0 ? firstPoint(value[0]) : void 0;
+	const record = value;
+	if (typeof record.x === "number" && typeof record.y === "number") return {
+		x: record.x,
+		y: record.y
+	};
+	if (typeof record.left === "number" && typeof record.bottom === "number") return {
+		x: record.left,
+		y: record.bottom
+	};
+	return firstPoint(record.start ?? record.upperLeft);
+}
+/**
+* The distance the touched geometry moves by, when it is one rigid
+* translation of the current state; `null` when it isn't. Requires the kind's
+* first geometry field in the patch; it and every other geometry field
+* present on the annotation must ride along shifted by the same delta — a box
+* resized, or a leader left behind by a moved text box, is not a translation
+* (the dictionary would desync from the pixels). For the kinds that turn, the
+* turn is checked as an after-state: an omitted rotation keeps the current
+* one.
+*/
+function rigidTranslationOf(cur, pat, subtype, geometryKeys) {
+	const [anchor] = geometryKeys;
+	const from = firstPoint(cur[anchor]);
+	const to = firstPoint(pat[anchor]);
+	if (!from || !to) return null;
+	const dx = to.x - from.x;
+	const dy = to.y - from.y;
+	if (TURNING_KINDS.has(subtype)) {
+		const rotAfter = pat.rotation === void 0 ? cur.rotation : pat.rotation;
+		if (!numEq(normDeg(cur.rotation), normDeg(rotAfter))) return null;
+	}
+	for (const key of geometryKeys) {
+		const c = cur[key];
+		const p = pat[key];
+		if (c == null && p == null) continue;
+		if (c == null || p == null) return null;
+		if (!shiftedBy(c, p, dx, dy)) return null;
+	}
+	return {
+		x: dx,
+		y: dy
+	};
+}
+const INERT = { impact: "inert" };
+const REGENERATE = { impact: "regenerate" };
+/**
+* Classify an update patch against the annotation's current read, in either
+* space, with the distance a translation moves the drawing by.
+*
+* 1. Value-diff: drop keys whose value semantically equals the current one,
+*    plus the always-inert metadata keys (and per-kind inert keys: `contents`
+*    where it isn't painted).
+*    Nothing left → `'inert'`.
+* 2. If every remaining key is translatable geometry for this kind and the
+*    values are one rigid translation → `'translation'`, by how far.
+* 3. Anything else — style, text, unknown keys, unknown kinds → `'regenerate'`.
+*/
+function appearanceChangeOf(current, patch) {
+	if (patch.subtype !== void 0 && patch.subtype !== current.subtype) return REGENERATE;
+	const cur = current;
+	const pat = patch;
+	const subtype = current.subtype;
+	const captionEnabled = pat.captionEnabled === void 0 ? cur.captionEnabled : pat.captionEnabled;
+	const contentsPainted = CONTENTS_PAINTED.has(subtype) || [
+		"line",
+		"polygon",
+		"polyline"
+	].includes(subtype) && captionEnabled === true;
+	const touched = [];
+	for (const [key, value] of Object.entries(pat)) {
+		if (value === void 0 || INERT_KEYS.has(key)) continue;
+		if (key === "contents" && !contentsPainted) continue;
+		if (!semanticEqual(value, cur[key])) touched.push(key);
+	}
+	if (touched.length === 0) return INERT;
+	const baseGeometryKeys = TRANSLATABLE_GEOMETRY[subtype];
+	const geometryKeys = baseGeometryKeys && (subtype === "polygon" || subtype === "polyline") && cur.captionCenter ? [...baseGeometryKeys, "captionCenter"] : baseGeometryKeys;
+	if (!geometryKeys) return REGENERATE;
+	if (!touched.every((k) => geometryKeys.includes(k))) return REGENERATE;
+	const by = rigidTranslationOf(cur, pat, subtype, geometryKeys);
+	return by ? {
+		impact: "translation",
+		by
+	} : REGENERATE;
+}
+/** {@link appearanceChangeOf}'s verdict alone, on the file's values: what the engine's update decides. */
+function appearanceImpactOf(current, patch) {
+	return appearanceChangeOf(current, patch).impact;
+}
+//#endregion
+//#region src/annotation/shapeForRect.ts
+/**
+* The kinds whose `rect` the engine works out from their shape: a box, points
+* or quads (`drawnRectFields`). `test/annotation/shapeForRect.test.ts` keeps
+* it equal to the declarations.
+*/
+const DRAWN_RECT_KINDS = /* @__PURE__ */ new Set([
+	"highlight",
+	"underline",
+	"squiggly",
+	"strikeout",
+	"square",
+	"circle",
+	"free-text",
+	"stamp",
+	"caret",
+	"widget",
+	"line",
+	"polyline",
+	"polygon",
+	"ink"
+]);
+/**
+* The places that make up a drawing. A measurement's origin isn't one: it's
+* where the scale's coordinates start, so it stays when the drawing moves.
+*/
+const DRAWING_SPACES = /* @__PURE__ */ new Set([
+	"box",
+	"point",
+	"points",
+	"strokes",
+	"quads",
+	"linePoints",
+	"calloutLine"
+]);
+/** The fields that hold a drawn kind's shape: its places, and its turn. */
+function shapeFieldsOf(subtype) {
+	return [...Object.entries(ANNOTATION_FIELD_SPACES[subtype]).filter(([name, space]) => name !== "rect" && DRAWING_SPACES.has(space)).map(([name]) => name), "rotation"];
+}
+/**
+* The shape fields that put `annotation` at `rect`, in the file's
+* coordinates: the rule an update's `rect` follows. The public
+* `shapeForRect` runs it on page-space values.
+*
+* - A kind whose shape is its rect (note, file attachment, link, popup,
+*   redaction) takes `rect` as it is.
+* - A drawn kind has every place it holds mapped from its current `rect` onto
+*   `rect`, each axis on its own, as Acrobat does when a script sets
+*   `annot.rect`: a rect of the same size moves the shape, a bigger one
+*   stretches it. The engine then works out the rect from the shape, so it
+*   can differ a little from `rect` (a stroke keeps its width). A box at a
+*   quarter turn stretches along its own sides, as it stands on the page.
+*
+* A drawn kind refuses a rect that would squash it to no width or height, a
+* rect of another size when it's turned (it can only move) unless it is a
+* box at a quarter turn, and one when its own rect has no width or height to
+* stretch. Each refusal is `InvalidArg` on `rect`.
+*/
+function pdfShapeForRect(annotation, rect) {
+	const subtype = annotation.subtype;
+	if (!DRAWN_RECT_KINDS.has(subtype)) return { rect };
+	const to = normalizePdfRect(rect);
+	const from = normalizePdfRect(annotation.rect);
+	const toWidth = to.right - to.left;
+	const toHeight = to.top - to.bottom;
+	const fromWidth = from.right - from.left;
+	const fromHeight = from.top - from.bottom;
+	const sameWidth = semanticEqual(toWidth, fromWidth);
+	const sameHeight = semanticEqual(toHeight, fromHeight);
+	if (!sameWidth && toWidth <= 0 || !sameHeight && toHeight <= 0) throw refused(subtype, "a rect needs a width and a height");
+	const rotation = annotation.rotation ?? 0;
+	const spaces = ANNOTATION_FIELD_SPACES[subtype];
+	const quarterTurn = spaces.box === "box" ? quarterTurnOf(rotation) : null;
+	if (!semanticEqual((rotation % 360 + 360) % 360, 0) && quarterTurn === null) {
+		if (!sameWidth || !sameHeight) throw refused(subtype, "a turned drawing's rect can only move; resize its shape instead");
+	}
+	if (!sameWidth && fromWidth <= 0 || !sameHeight && fromHeight <= 0) throw refused(subtype, "its rect has no width or height to stretch; it can only move");
+	const scaleX = sameWidth ? 1 : toWidth / fromWidth;
+	const scaleY = sameHeight ? 1 : toHeight / fromHeight;
+	const point = (p) => ({
+		x: to.left + (p.x - from.left) * scaleX,
+		y: to.bottom + (p.y - from.bottom) * scaleY
+	});
+	const placeRect = (rect) => {
+		const corner = point({
+			x: rect.left,
+			y: rect.bottom
+		});
+		const opposite = point({
+			x: rect.right,
+			y: rect.top
+		});
+		return normalizePdfRect({
+			left: corner.x,
+			bottom: corner.y,
+			right: opposite.x,
+			top: opposite.y
+		});
+	};
+	const place = {
+		box: (box) => quarterTurn === null || quarterTurn === 0 || quarterTurn === 180 ? placeRect(box) : pdfQuarterTurnBox(placeRect(pdfRectTurnedBounds(box, quarterTurn)), quarterTurn),
+		point,
+		points: (points) => points.map(point),
+		strokes: (strokes) => strokes.map((stroke) => stroke.map(point)),
+		quads: (quads) => quads.map((quad) => ({
+			upperLeft: point(quad.upperLeft),
+			upperRight: point(quad.upperRight),
+			lowerLeft: point(quad.lowerLeft),
+			lowerRight: point(quad.lowerRight)
+		})),
+		linePoints: (line) => ({
+			start: point(line.start),
+			end: point(line.end)
+		}),
+		calloutLine: (points) => points.map(point)
+	};
+	const shape = {};
+	for (const name of shapeFieldsOf(subtype)) {
+		const value = annotation[name];
+		const space = spaces[name];
+		if (value != null && space) shape[name] = place[space](value);
+	}
+	return shape;
+}
+function refused(subtype, reason) {
+	return new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `${subtype} field 'rect': ${reason}`, { details: { field: "rect" } });
+}
+//#endregion
+//#region src/measure/compute.ts
+const positive = (n) => Number.isFinite(n) && n > 0;
+function scaleOf(measure) {
+	const sx = Math.fround(measure.x[0]?.conversion ?? NaN);
+	if (!positive(sx)) return null;
+	if (!measure.y) return {
+		sx,
+		sy: sx
+	};
+	const cy = Math.fround(measure.y[0]?.conversion ?? NaN);
+	const cyx = Math.fround(measure.cyx ?? NaN);
+	const sy = cy * cyx;
+	return positive(cy) && positive(cyx) && positive(sy) ? {
+		sx,
+		sy
+	} : null;
+}
+const measurementPoint = (p) => ({
+	x: Math.fround(p.x),
+	y: Math.fround(p.y)
+});
+function pathLength(points, closed, scale) {
+	let total = 0;
+	const normalized = points.map(measurementPoint);
+	for (let i = 0; i < (closed ? normalized.length : normalized.length - 1); i++) {
+		const a = normalized[i], b = normalized[(i + 1) % normalized.length];
+		total += Math.hypot((b.x - a.x) * scale.sx, (b.y - a.y) * scale.sy);
+	}
+	return total;
+}
+function polygonArea(points, scale) {
+	if (points.length < 3) return 0;
+	const normalized = points.map(measurementPoint);
+	const origin = normalized[0];
+	let twice = 0;
+	for (let i = 1; i < normalized.length - 1; i++) {
+		const a = normalized[i], b = normalized[i + 1];
+		twice += (a.x - origin.x) * (b.y - origin.y) - (b.x - origin.x) * (a.y - origin.y);
+	}
+	return Math.abs(twice * scale.sx * scale.sy) / 2;
+}
+/** A measured area must have one simple, nonzero boundary. Repeated closing
+*  vertices are allowed in imported PDFs; crossings and overlapping edges are not. */
+function validAreaBoundary(points) {
+	const boundary = points.map(measurementPoint);
+	const same = (a, b) => a.x === b.x && a.y === b.y;
+	if (boundary.length > 1 && same(boundary[0], boundary[boundary.length - 1])) boundary.pop();
+	if (boundary.length < 3 || polygonArea(boundary, {
+		sx: 1,
+		sy: 1
+	}) === 0) return false;
+	const cross = (a, b, c) => (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+	const onSegment = (a, b, p) => cross(a, b, p) === 0 && p.x >= Math.min(a.x, b.x) && p.x <= Math.max(a.x, b.x) && p.y >= Math.min(a.y, b.y) && p.y <= Math.max(a.y, b.y);
+	for (let i = 0; i < boundary.length; i++) {
+		const a = boundary[i];
+		const b = boundary[(i + 1) % boundary.length];
+		if (same(a, b)) return false;
+		const next = boundary[(i + 2) % boundary.length];
+		const doublesBack = (b.x - a.x) * (next.x - b.x) + (b.y - a.y) * (next.y - b.y) < 0;
+		if (cross(a, b, next) === 0 && doublesBack) return false;
+		for (let j = i + 1; j < boundary.length; j++) {
+			if (j === i + 1 || i === 0 && j === boundary.length - 1) continue;
+			const c = boundary[j];
+			const d = boundary[(j + 1) % boundary.length];
+			if (onSegment(a, b, c) || onSegment(a, b, d) || onSegment(c, d, a) || onSegment(c, d, b)) return false;
+			if (Math.sign(cross(a, b, c)) !== Math.sign(cross(a, b, d)) && Math.sign(cross(c, d, a)) !== Math.sign(cross(c, d, b))) return false;
+		}
+	}
+	return true;
+}
+//#endregion
+//#region src/measure/derive.ts
+function isDimension(dto) {
+	return dto.subtype === "line" && dto.intent === "line-dimension" || dto.subtype === "polyline" && dto.intent === "polyline-dimension" || dto.subtype === "polygon" && dto.intent === "polygon-dimension";
+}
+const isReadout = (r) => !("unavailable" in r);
+function measurementReadout(dto) {
+	if (!isDimension(dto)) return { unavailable: "not-dimension" };
+	if (!dto.measure) return { unavailable: "no-measure" };
+	if (dto.measure.subtype !== "rectilinear") return { unavailable: "foreign-measure" };
+	const m = dto.measure, scale = scaleOf(m);
+	if (!scale) return { unavailable: "no-scale" };
+	const points = dto.subtype === "line" ? dto.linePoints ? [dto.linePoints.start, dto.linePoints.end] : [] : dto.vertices ?? [];
+	if (points.length < (dto.subtype === "polygon" ? 3 : 2) || points.some((p) => !Number.isFinite(Math.fround(p.x)) || !Number.isFinite(Math.fround(p.y)))) return { unavailable: "invalid-geometry" };
+	const area = dto.subtype === "polygon";
+	if (area && !validAreaBoundary(points)) return { unavailable: "invalid-geometry" };
+	const formats = area ? m.area : m.distance;
+	if (!formats.length) return { unavailable: area ? "no-area-format" : "no-distance-format" };
+	if (!formats.every(require_format.validNumberFormat)) return { unavailable: "invalid-format" };
+	const value = area ? polygonArea(points, scale) : pathLength(points, false, scale);
+	try {
+		return {
+			kind: area ? "area" : dto.subtype === "line" ? "distance" : "perimeter",
+			value: value * Math.fround(formats[0].conversion),
+			label: require_format.formatMeasurement(value, formats),
+			...area && m.distance.length && m.distance.every(require_format.validNumberFormat) ? { perimeter: require_format.formatMeasurement(pathLength(points, true, scale), m.distance) } : {}
+		};
+	} catch {
+		return { unavailable: "invalid-format" };
+	}
+}
+function deriveMeasurementLabel(dto) {
+	const readout = measurementReadout(dto);
+	return isReadout(readout) && dto.contents !== readout.label ? {
+		...dto,
+		contents: readout.label
+	} : dto;
+}
+//#endregion
+//#region src/measure/validate.ts
+/** Shared preflight for HTTP, workers and calibration helpers. Does not write. */
+function assertWritableMeasure(value) {
+	if (value.subtype !== "rectilinear") throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "Only rectilinear measures can be authored");
+	if (value.ratio !== void 0 && (typeof value.ratio !== "string" || value.ratio.includes("\0"))) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "Invalid scale ratio");
+	for (const key of [
+		"x",
+		"y",
+		"distance",
+		"area",
+		"angle",
+		"slope"
+	]) {
+		const list = value[key];
+		if (list === void 0 && (key === "y" || key === "angle" || key === "slope")) continue;
+		if (!Array.isArray(list)) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `Missing ${key} formats`);
+		for (const nf of list) {
+			if (!nf || typeof nf.unit !== "string" || !require_format.validNumberFormat(nf)) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "Invalid number format");
+			if (nf.fraction !== void 0 && ![
+				"decimal",
+				"fraction",
+				"round",
+				"truncate"
+			].includes(nf.fraction)) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "Invalid fraction mode");
+			if (nf.labelPosition !== void 0 && !["prefix", "suffix"].includes(nf.labelPosition)) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "Invalid label position");
+			if (nf.fixed !== void 0 && typeof nf.fixed !== "boolean") throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "Invalid fixed precision");
+			for (const key of [
+				"unit",
+				"thousands",
+				"decimal",
+				"prefixSpacing",
+				"suffixSpacing"
+			]) {
+				const text = nf[key];
+				if (text !== void 0 && (typeof text !== "string" || text.includes("\0"))) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "Invalid measurement text");
+			}
+		}
+	}
+	if (value.origin !== void 0) for (const n of [value.origin.x, value.origin.y]) assertPdfFloat(n);
+	if (value.cyx !== void 0) {
+		assertPdfFloat(value.cyx);
+		if (Math.fround(value.cyx) <= 0) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "Invalid CYX");
+	}
+}
+function assertPdfFloat(n) {
+	if (typeof n !== "number" || !Number.isFinite(Math.fround(n))) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "Value is outside PDF float range");
+}
+//#endregion
+//#region src/annotation/resolve/measurement.ts
+/** The fields a measurement's label is worked out from. */
+const LABEL_INPUTS = [
+	"linePoints",
+	"vertices",
+	"measure",
+	"intent",
+	"contents"
+];
+const CAPTION_FIELDS = [
+	"captionEnabled",
+	"captionPosition",
+	"captionOffset",
+	"captionCenter"
+];
+const isDimensionKind = (subtype) => subtype === "line" || subtype === "polygon" || subtype === "polyline";
+/** Whether a write names any of the caption's fields. */
+const touchesCaption = (value) => CAPTION_FIELDS.some((name) => value[name] !== void 0);
+function validate(subtype, write) {
+	try {
+		if (write.measure != null && write.measure.subtype === "rectilinear") assertWritableMeasure(write.measure);
+		if (subtype === "line" && "leader" in write && write.leader != null && (typeof write.leader !== "object" || Array.isArray(write.leader))) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "Invalid line leader");
+		const intents = subtype === "line" ? ["line-dimension", "line-arrow"] : subtype === "polygon" ? ["polygon-dimension", "polygon-cloud"] : ["polyline-dimension"];
+		if (write.intent != null && !intents.includes(write.intent)) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "Invalid measurement intent");
+		if (write.captionEnabled != null && typeof write.captionEnabled !== "boolean") throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "Invalid caption visibility");
+		if ("captionPosition" in write && write.captionPosition != null) {
+			if (!["inline", "top"].includes(write.captionPosition)) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "Invalid caption position");
+		}
+		if ("captionOffset" in write && write.captionOffset) {
+			assertPdfFloat(write.captionOffset.along);
+			assertPdfFloat(write.captionOffset.perpendicular);
+		}
+		if ("captionCenter" in write && write.captionCenter) {
+			assertPdfFloat(write.captionCenter.x);
+			assertPdfFloat(write.captionCenter.y);
+		}
+		if ("leader" in write && write.leader) {
+			for (const length of [
+				write.leader.length,
+				write.leader.extension ?? 0,
+				write.leader.offset ?? 0
+			]) assertPdfFloat(length);
+			if ((write.leader.extension ?? 0) < 0 || (write.leader.offset ?? 0) < 0) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "Leader extension and offset must be nonnegative");
+		}
+		const points = "linePoints" in write ? write.linePoints ? [write.linePoints.start, write.linePoints.end] : [] : "vertices" in write ? write.vertices ?? [] : [];
+		for (const point of points) {
+			assertPdfFloat(point.x);
+			assertPdfFloat(point.y);
+		}
+	} catch (error) {
+		throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, error.message);
+	}
+}
+/** Infer a rigid transform only when all corresponding vertices agree. Vertex edits leave a manual center fixed. */
+function moveCenter(before, after, center) {
+	if (before.length !== after.length || before.length < 2) return void 0;
+	const origin = before[0];
+	const moved = after[0];
+	const index = before.findIndex((point) => Math.hypot(point.x - origin.x, point.y - origin.y) > 1e-6);
+	if (index < 0) return void 0;
+	const from = {
+		x: before[index].x - origin.x,
+		y: before[index].y - origin.y
+	};
+	const to = {
+		x: after[index].x - moved.x,
+		y: after[index].y - moved.y
+	};
+	const length = from.x * from.x + from.y * from.y;
+	const cos = (from.x * to.x + from.y * to.y) / length;
+	const sin = (from.x * to.y - from.y * to.x) / length;
+	if (Math.abs(cos * cos + sin * sin - 1) > 1e-5) return void 0;
+	const transform = (point) => ({
+		x: moved.x + cos * (point.x - origin.x) - sin * (point.y - origin.y),
+		y: moved.y + sin * (point.x - origin.x) + cos * (point.y - origin.y)
+	});
+	if (!before.every((point, i) => {
+		const placed = transform(point);
+		return Math.hypot(placed.x - after[i].x, placed.y - after[i].y) <= .001;
+	})) return void 0;
+	return transform(center);
+}
+/**
+* A dimension draft ready for the writer: validated, its label worked out,
+* and its caption fields complete, since the native caption setters write
+* the whole caption at once.
+*/
+function resolveMeasurementDraft(draft) {
+	if (!isDimensionKind(draft.subtype)) return draft;
+	const dimension = draft;
+	validate(draft.subtype, dimension);
+	if (dimension.measure != null && dimension.measure.subtype !== "rectilinear") throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `A ${dimension.measure.subtype === "geospatial" ? "geospatial" : "foreign"} measure can't be written; leave measure out`);
+	let resolved = draft;
+	if (touchesCaption(draft)) {
+		if (draft.subtype === "line") resolved = {
+			...draft,
+			captionEnabled: draft.captionEnabled === void 0 ? false : draft.captionEnabled,
+			captionPosition: draft.captionPosition ?? "inline",
+			captionOffset: draft.captionOffset ?? null
+		};
+		else if (draft.subtype === "polygon" || draft.subtype === "polyline") resolved = {
+			...draft,
+			captionEnabled: draft.captionEnabled ?? (draft.captionCenter != null ? false : null),
+			captionCenter: draft.captionCenter ?? null
+		};
+	}
+	return deriveMeasurementLabel(resolved);
+}
+/**
+* A dimension patch with what follows from it. The patch's subtype is the
+* target's. Caption fields merge with the current caption into a complete
+* caption; a whole-shape move carries a manual caption center along; a
+* foreign measure marker sent back keeps the measure as it is; and the label
+* is worked out from the resulting geometry and scale.
+*/
+function measurementFollows(current, patch) {
+	if (current.subtype !== "line" && current.subtype !== "polygon" && current.subtype !== "polyline") return patch;
+	const subtype = current.subtype;
+	let next = {
+		...patch,
+		subtype
+	};
+	validate(subtype, next);
+	if (next.measure != null && next.measure.subtype !== "rectilinear") {
+		if (current.measure?.subtype !== next.measure.subtype) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `A ${next.measure.subtype === "geospatial" ? "geospatial" : "foreign"} measure can't be written; leave measure out`);
+		next = {
+			...next,
+			measure: void 0
+		};
+	}
+	if (current.subtype === "line" && next.subtype === "line") {
+		if (touchesCaption(next)) next = {
+			...next,
+			captionEnabled: next.captionEnabled === void 0 ? current.captionEnabled : next.captionEnabled,
+			captionPosition: next.captionPosition ?? current.captionPosition,
+			captionOffset: next.captionOffset === void 0 ? current.captionOffset : next.captionOffset
+		};
+	} else if (current.subtype !== "line" && next.subtype !== "line") {
+		if (next.vertices && next.captionEnabled !== null && next.captionCenter === void 0 && current.captionCenter) {
+			const center = moveCenter(current.vertices, next.vertices, current.captionCenter);
+			if (center) next = {
+				...next,
+				captionCenter: center
+			};
+		}
+		if (touchesCaption(next)) next = next.captionEnabled === null ? {
+			...next,
+			captionEnabled: null,
+			captionCenter: null
+		} : {
+			...next,
+			captionEnabled: next.captionEnabled ?? current.captionEnabled ?? false,
+			captionCenter: next.captionCenter === void 0 ? current.captionCenter : next.captionCenter
+		};
+	}
+	if (LABEL_INPUTS.some((key) => next[key] !== void 0)) {
+		const readout = measurementReadout({
+			...current,
+			...next
+		});
+		if (isReadout(readout)) next = {
+			...next,
+			contents: readout.label
+		};
+	}
+	validate(subtype, next);
+	return next;
+}
+//#endregion
+//#region src/annotation/calloutEnd.ts
+/**
+* Where a callout's line meets its text box: the middle of the side `toward`
+* (the knee, else the tip) lies beyond, chosen by which way it is farther
+* from the box's middle, across or up and down. A turned box decides in its
+* own frame, and the point lands on the turned side, the one the page shows.
+* In the file's coordinates.
+*/
+function pdfCalloutEnd(box, toward, rotation) {
+	const center = {
+		x: (box.left + box.right) / 2,
+		y: (box.bottom + box.top) / 2
+	};
+	const turn = {
+		degrees: rotation,
+		center
+	};
+	const local = rotation ? pdfPointUnturned(toward, turn) : toward;
+	const dx = local.x - center.x;
+	const dy = local.y - center.y;
+	const end = Math.abs(dx) >= Math.abs(dy) ? {
+		x: dx >= 0 ? box.right : box.left,
+		y: center.y
+	} : {
+		x: center.x,
+		y: dy > 0 ? box.top : box.bottom
+	};
+	return rotation ? pdfPointTurned(end, turn) : end;
+}
+//#endregion
+//#region src/annotation/fontFaces.ts
+const STANDARD_FACES = {
+	courier: {
+		family: "Courier",
+		weight: 400,
+		italic: false
+	},
+	"courier-bold": {
+		family: "Courier",
+		weight: 700,
+		italic: false
+	},
+	"courier-bold-oblique": {
+		family: "Courier",
+		weight: 700,
+		italic: true
+	},
+	"courier-oblique": {
+		family: "Courier",
+		weight: 400,
+		italic: true
+	},
+	helvetica: {
+		family: "Helvetica",
+		weight: 400,
+		italic: false
+	},
+	"helvetica-bold": {
+		family: "Helvetica",
+		weight: 700,
+		italic: false
+	},
+	"helvetica-bold-oblique": {
+		family: "Helvetica",
+		weight: 700,
+		italic: true
+	},
+	"helvetica-oblique": {
+		family: "Helvetica",
+		weight: 400,
+		italic: true
+	},
+	"times-roman": {
+		family: "Times",
+		weight: 400,
+		italic: false
+	},
+	"times-bold": {
+		family: "Times",
+		weight: 700,
+		italic: false
+	},
+	"times-bold-italic": {
+		family: "Times",
+		weight: 700,
+		italic: true
+	},
+	"times-italic": {
+		family: "Times",
+		weight: 400,
+		italic: true
+	},
+	symbol: {
+		family: "Symbol",
+		weight: 400,
+		italic: false
+	},
+	"zapf-dingbats": {
+		family: "ZapfDingbats",
+		weight: 400,
+		italic: false
+	}
+};
+/** One of the 14 standard names. The names are reserved: a registered font keyed `'helvetica'` resolves as the standard one. */
+const isStandardFontName = (font) => require_format.STANDARD_FONTS.includes(font);
+/**
+* The face a free text's `fontFamily` (or a rich run's `family`) asks for: a
+* standard font's family, weight and italic; a registered key's identity; or,
+* for anything else, the string itself as a family name (a face the document
+* embeds, or one the engine will substitute).
+*/
+function faceForFreeTextFont(font, describe) {
+	if (isStandardFontName(font)) {
+		const face = STANDARD_FACES[font];
+		return {
+			family: face.family,
+			weight: face.weight,
+			italic: face.italic
+		};
+	}
+	const registered = describe?.(font);
+	if (registered) return {
+		family: registered.familyName,
+		weight: registered.weight,
+		italic: registered.italic
+	};
+	return { family: font };
+}
+/** Family names compare without case, spaces, hyphens and underscores
+*  (the engine's own rule): "Noto Sans" == "NotoSans" == "noto-sans". */
+function familyKey(family) {
+	return family.toLowerCase().replace(/[\s\-_'"]/g, "");
+}
+/** Families that are a standard font's, by `familyKey`. */
+const STANDARD_FAMILY_KEYS = {
+	helvetica: "Helvetica",
+	arial: "Helvetica",
+	arialmt: "Helvetica",
+	sansserif: "Helvetica",
+	times: "Times",
+	timesroman: "Times",
+	timesnewroman: "Times",
+	timesnewromanpsmt: "Times",
+	serif: "Times",
+	courier: "Courier",
+	couriernew: "Courier",
+	couriernewpsmt: "Courier",
+	monospace: "Courier",
+	symbol: "Symbol",
+	zapfdingbats: "ZapfDingbats",
+	dingbats: "ZapfDingbats"
+};
+/**
+* The `fontFamily` that names a face (the other direction of
+* {@link faceForFreeTextFont}): the registered `key` whose identity matches,
+* else the standard font's kebab name, else the family itself.
+*/
+function freeTextFontForFace(face, keyForFace) {
+	const key = keyForFace?.(face.family, face.weight, face.italic);
+	if (key !== void 0) return key;
+	const standard = STANDARD_FAMILY_KEYS[familyKey(face.family)];
+	if (standard) {
+		const faces = Object.entries(STANDARD_FACES);
+		const bold = face.weight >= 600;
+		const any = faces.find(([, spec]) => spec.family === standard && spec.weight >= 600 === bold && spec.italic === face.italic) ?? faces.find(([, spec]) => spec.family === standard);
+		if (any) return any[0];
+	}
+	return face.family;
+}
+//#endregion
+//#region src/annotation/resolve/freeText.ts
+/**
+* `base` with a free text's text style over it. The font, size, text color
+* and alignment are the rich body's (runs are deltas over it, so every run
+* that didn't set one follows), and a style given by itself wins over the
+* body's.
+*/
+function bodyWithStyle(base, style, describe) {
+	const body = { ...base };
+	if (style.fontFamily !== void 0) {
+		const face = faceForFreeTextFont(style.fontFamily, describe);
+		body.family = face.family;
+		if (face.weight !== void 0) body.weight = face.weight;
+		if (face.italic !== void 0) body.italic = face.italic;
+	}
+	if (style.fontSize !== void 0) body.size = style.fontSize;
+	if (style.fontColor != null) body.color = style.fontColor;
+	if (style.textAlign !== void 0) body.align = style.textAlign;
+	return body;
+}
+/** A callout line goes only with the callout intent: another box would draw without it. */
+function assertCalloutIntent(intent, calloutLine) {
+	if (calloutLine != null && intent !== "free-text-callout") throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `free-text: a callout line needs intent 'free-text-callout', not '${intent}'`, { details: { field: "intent" } });
+}
+/**
+* The text style fields a new body brings, beside it: a free text reads its
+* size, text color and alignment off its body, so they change with it. Only
+* the ones that differ from `current`, and never over one the patch states.
+*/
+function styleOfBody(body, current, text) {
+	const style = {};
+	if (text.fontSize === void 0 && body.size !== void 0 && body.size !== current.fontSize) style.fontSize = body.size;
+	if (text.fontColor === void 0 && body.color !== void 0 && body.color.toLowerCase() !== current.fontColor?.toLowerCase()) style.fontColor = body.color.toLowerCase();
+	if (text.textAlign === void 0 && body.align !== void 0 && body.align !== current.textAlign) style.textAlign = body.align;
+	return style;
+}
+/**
+* A free text's text lives in its rich text: `contents` is its plain
+* projection, and the font, size, text color and alignment are its body.
+*
+* - New `richText` brings its `contents`; a partial body merges over the
+*   current one.
+* - New `contents` becomes body-style paragraphs, one per line break (run
+*   formatting goes: a plain-text writer can't keep what it can't see).
+* - A new font, size, text color or alignment moves the body.
+* - Whatever moves the body states the complete rich text to write, and the
+*   size, text color and alignment it reads back with.
+* - A callout line needs the callout intent.
+*/
+function freeTextFollows(current, patch, describe) {
+	if (current.subtype !== "free-text" || patch.subtype !== "free-text") return patch;
+	const text = patch;
+	if (text.intent !== void 0 || text.calloutLine !== void 0) assertCalloutIntent(text.intent ?? current.intent, text.calloutLine !== void 0 ? text.calloutLine : current.calloutLine);
+	const changes = bodyWithStyle({}, text, describe);
+	const textChanged = text.richText !== void 0 || text.contents !== void 0;
+	if (!textChanged && Object.keys(changes).length === 0) return text;
+	const body = {
+		...current.richText.body,
+		...text.richText?.body,
+		...changes
+	};
+	const richText = {
+		body,
+		paragraphs: text.richText?.paragraphs ?? (text.contents !== void 0 ? richTextParagraphsFromPlainText(text.contents ?? "") : current.richText.paragraphs)
+	};
+	return {
+		...text,
+		...styleOfBody(body, current, text),
+		richText,
+		...textChanged ? { contents: richTextPlainText(richText) } : {}
+	};
+}
+/**
+* A callout's line stays attached: when its box moves or turns and the
+* patch doesn't state its own `calloutLine`, the line's end moves to where
+* the line now meets the box (the side its knee, else its tip, lies beyond).
+* A stated `calloutLine` is kept as given; a patch that moves neither the box
+* nor its turn keeps the stored end.
+*/
+function calloutEndFollows(current, patch) {
+	if (current.subtype !== "free-text" || patch.subtype !== "free-text") return patch;
+	const text = patch;
+	const line = current.calloutLine;
+	if (!line || text.calloutLine !== void 0) return text;
+	if (text.box === void 0 && text.rotation === void 0) return text;
+	const box = text.box ?? current.box;
+	const rotation = (text.rotation === void 0 ? current.rotation : text.rotation) ?? 0;
+	const knee = line.length === 3 ? line[1] : void 0;
+	const end = pdfCalloutEnd(box, knee ?? line[0], rotation);
+	return {
+		...text,
+		calloutLine: knee ? [
+			line[0],
+			knee,
+			end
+		] : [line[0], end]
+	};
+}
+/**
+* A free text draft, stated whole:
+*
+* - its intent: the callout intent when it has a callout line, else a plain
+*   box (a callout line needs the callout intent);
+* - its text as rich text: the draft's rich text, else body-style paragraphs
+*   from its `contents` (one per line break, an empty box without any), with
+*   the text style over the body (a style given by itself wins over the
+*   body's; what neither gives is the engine's default);
+* - `contents` as the rich text's plain projection.
+*/
+function freeTextDraftFollows(draft, describe) {
+	if (draft.subtype !== "free-text") return draft;
+	const intent = draft.intent ?? (draft.calloutLine != null ? "free-text-callout" : "free-text");
+	assertCalloutIntent(intent, draft.calloutLine);
+	const richText = {
+		body: bodyWithStyle(draft.richText?.body ?? {}, draft, describe),
+		paragraphs: draft.richText?.paragraphs ?? richTextParagraphsFromPlainText(draft.contents ?? "")
+	};
+	return {
+		...draft,
+		intent,
+		richText,
+		contents: richTextPlainText(richText)
+	};
+}
+//#endregion
+//#region src/annotation/resolve/rectCommand.ts
+/**
+* An update's `rect` on a drawn kind, resolved as a command: the rect it
+* read, sent back, is dropped (nothing moves); another rect becomes the shape
+* fields that put the drawing there. It can't come with a change to the shape
+* itself: which of the two to follow would be a guess, so it is refused
+* (`InvalidArg` on `rect`), as is a rect that isn't four finite numbers. A
+* kind whose shape is its rect keeps it as a plain field. The page-space
+* `resolveRectCommand` runs it on page-space values.
+*/
+function pdfResolveRectCommand(current, patch) {
+	const { rect, ...rest } = patch;
+	if (rect === void 0 || !DRAWN_RECT_KINDS.has(current.subtype)) return patch;
+	if (!isFinitePdfRect(rect)) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `${current.subtype} update field 'rect': not a rect of finite numbers`, { details: { field: "rect" } });
+	if (semanticEqual(normalizePdfRect(rect), current.rect)) return rest;
+	const read = current;
+	const changed = shapeFieldsOf(current.subtype).find((name) => {
+		const value = patch[name];
+		return value !== void 0 && !semanticEqual(value, read[name]);
+	});
+	if (changed) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `${current.subtype} update field 'rect': a new rect moves the shape, so it can't come with a new '${changed}'`, { details: { field: "rect" } });
+	const { left, bottom, right, top } = rect;
+	return {
+		...rest,
+		...pdfShapeForRect(current, {
+			left,
+			bottom,
+			right,
+			top
+		})
+	};
+}
+//#endregion
+//#region src/annotation/resolve/sentBack.ts
+/** `patch` without the fields `drop` names. `subtype` always stays. */
+function without(patch, drop) {
+	const kept = Object.entries(patch).filter(([name, value]) => name === "subtype" || !drop(name, value));
+	return Object.fromEntries(kept);
+}
+/**
+* The patch without the colors it sends back as they read. A gray or CMYK
+* color in the file reads as its sRGB equivalent; writing that back would
+* store it as sRGB, so leaving it out keeps the file as it is.
+*/
+function withoutUnchangedColors(current, patch) {
+	const colors = kindFactsOf(current.subtype)?.colors ?? [];
+	const read = current;
+	return without(patch, (name, value) => {
+		const was = read[name];
+		return colors.includes(name) && typeof value === "string" && typeof was === "string" && sameColor(value, was);
+	});
+}
+/**
+* The patch without the fields it sends back as they read: a field equal to
+* the read is not a change, so the annotation keeps it and nothing follows
+* from it. Equal as `semanticEqual` judges it: `null` and a field left out
+* are the same, and numbers within the precision a round trip through page
+* space keeps, so a read sent back from page space is the read. A changed
+* value stays, whatever it is; the engine's check refuses one its kind can't
+* write.
+*/
+function withoutUnchangedFields(current, patch) {
+	const read = current;
+	return without(patch, (name, value) => value !== void 0 && semanticEqual(value, read[name]));
+}
+//#endregion
+//#region src/annotation/resolve/text.ts
+/**
+* A review state needs its model (ISO 32000 §12.5.6.3): a standard state
+* brings its own, so only a custom state with none is refused.
+*/
+function stateNeedsModel(state) {
+	return new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `text: the custom state '${state}' needs a stateModel`, { details: { field: "stateModel" } });
+}
+/**
+* A note draft's state with its model filled in: a standard state brings its
+* own; a custom state without one is refused, before the first write.
+*/
+function noteDraftStateFollows(draft) {
+	if (draft.subtype !== "text" || draft.state == null || draft.stateModel != null) return draft;
+	const model = standardStateModelOf(draft.state);
+	if (!model) throw stateNeedsModel(draft.state);
+	return {
+		...draft,
+		stateModel: model
+	};
+}
+/**
+* A note's new state with its model filled in: a standard state sets its
+* own; a custom one keeps the annotation's, and needs one.
+*/
+function noteStateFollows(current, patch) {
+	if (current.subtype !== "text" || patch.subtype !== "text") return patch;
+	if (patch.state == null || patch.stateModel !== void 0) return patch;
+	const model = standardStateModelOf(patch.state);
+	if (model) return {
+		...patch,
+		stateModel: model
+	};
+	if (!current.stateModel) throw stateNeedsModel(patch.state);
+	return patch;
+}
+/**
+* A draft or patch that carries both `contents` and `richText` must agree:
+* `contents` is the plain projection of the rich text. A stale read sent back
+* fails loud here instead of quietly restoring old text.
+*/
+function assertRichTextAgreement(input) {
+	if (input.subtype !== "free-text" || input.richText === void 0) return;
+	if (input.contents === void 0 || input.contents === null) return;
+	if (input.contents !== richTextPlainText(input.richText)) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "free-text: `contents` must equal the plain projection of `richText` when both are given");
+}
+//#endregion
+//#region src/annotation/resolve/resolveAnnotationPatch.ts
+/**
+* What a patch means: the one place the engine decides which fields an
+* update changes. An update is prepared (`pdfPrepareAnnotationPatch`), then
+* what follows from it is derived (`pdfDeriveAnnotationPatch`). The engine
+* checks the prepared patch against its kind's schema between the two
+* (`pdfResolveAnnotationPatch`, from `@embedpdf/engine-core/validation`), a
+* check that only accepts or refuses; a viewer shows a pending change by
+* running the same two steps without schema validation (`applyAnnotationPatch`),
+* so the two can't disagree. The writers write what this resolves and nothing
+* more.
+*/
+/** A write names only fields its kind declares: a misspelled or foreign field is refused, never ignored. */
+function assertDeclaredFields(subtype, write) {
+	const known = ANNOTATION_FIELD_NAMES[subtype];
+	const unknown = Object.keys(write).filter((name) => name !== "subtype" && !known.includes(name));
+	if (unknown.length > 0) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `${subtype} has no field ${unknown.map((name) => `'${name}'`).join(", ")}`);
+}
+/**
+* The patch as the target's kind: its subtype filled in from the target, which
+* a caller may leave out. A different subtype, a changed name, a field the
+* kind doesn't declare, or any change to an annotation of a type the engine
+* doesn't model is refused.
+*/
+function annotationPatchForTarget(current, patch) {
+	if (patch.subtype !== void 0 && patch.subtype !== current.subtype) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "Annotation subtype cannot change");
+	if (current.subtype === "unsupported") throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "an annotation of a type the engine doesn't model can't be updated");
+	if (patch.nm !== void 0 && patch.nm !== current.nm) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "an annotation's nm can't change after create");
+	assertDeclaredFields(current.subtype, patch);
+	return {
+		...patch,
+		subtype: current.subtype
+	};
+}
+/**
+* The patch an update writes before anything follows from it, in the file's
+* coordinates, the same on the page and in the engine:
+*
+* - its subtype filled in from `current` (a different one is refused, as is
+*   a field the kind doesn't declare and a changed `nm`);
+* - a drawn kind's `rect`: the rect it reads, sent back, dropped; another one
+*   the shape fields that put the drawing there (`pdfResolveRectCommand`);
+* - a color sent back as it reads dropped, so the file keeps it as it has it;
+* - every other field sent back as it reads dropped: it is not a change
+*   (`withoutUnchangedFields`).
+*
+* A changed value stays whatever it is: whether the kind can write it is the
+* engine's check, which never adds, drops or changes a field.
+*/
+function pdfPrepareAnnotationPatch(current, patch) {
+	return withoutUnchangedFields(current, withoutUnchangedColors(current, pdfResolveRectCommand(current, annotationPatchForTarget(current, patch))));
+}
+/**
+* A prepared patch with every field that follows from it stated, in the
+* file's coordinates:
+*
+* - a note's standard review state brings its state model;
+* - a free text's `contents` and rich text follow each other, and its font,
+*   size, text color and alignment move its rich body;
+* - a callout's line stays attached to its box when the box moves or turns;
+* - a measurement's label follows its points and scale, and a polygon's
+*   caption follows its vertices.
+*
+* Throws `InvalidArg` where nothing can follow. Pure: it reads nothing but its
+* arguments.
+*/
+function pdfDeriveAnnotationPatch(current, prepared, options = {}) {
+	const resolved = noteStateFollows(current, prepared);
+	assertRichTextAgreement(resolved);
+	return measurementFollows(current, calloutEndFollows(current, freeTextFollows(current, resolved, options.describeFont)));
+}
+/**
+* The patch the engine writes for `patch` on `current`, as a viewer predicts
+* it, in the file's coordinates: prepared and derived as the engine does
+* (`pdfPrepareAnnotationPatch`, `pdfDeriveAnnotationPatch`), without schema
+* validation. A patch the engine's schema check refuses
+* (`pdfResolveAnnotationPatch`, from `@embedpdf/engine-core/validation`) is
+* refused when the update reaches it.
+*
+* Throws `InvalidArg` for what preparation and derivation refuse: a field the
+* kind doesn't declare, a changed subtype or name, a rect with a new shape or
+* that isn't finite, and where nothing can follow.
+*/
+function pdfPredictAnnotationPatch(current, patch, options = {}) {
+	return pdfDeriveAnnotationPatch(current, pdfPrepareAnnotationPatch(current, patch), options);
+}
+//#endregion
+//#region src/annotation/resolve/box.ts
+/**
+* A box kind's create placed by where it stands: a `rect` with a quarter
+* turn pins the box down, `rect` itself or its sides swapped under 90 and
+* 270 (`pdfQuarterTurnBox`). A create that gives `box` keeps it, and its
+* `rect` is worked out from it as ever, so a read sent back as a create
+* places the copy by its box.
+*
+* Refused with `InvalidArg`: a create with neither, a `rect` that isn't four
+* finite numbers, and a `rect` at another angle, where many boxes stand in
+* the same rect.
+*/
+function boxDraftFollows(draft) {
+	if (ANNOTATION_FIELD_SPACES[draft.subtype]?.box !== "box") return draft;
+	const given = draft;
+	if (given.box !== void 0) return draft;
+	if (given.rect === void 0) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `${draft.subtype} create: give its \`box\`, or its \`rect\` with a quarter turn`, { details: { field: "box" } });
+	if (!isFinitePdfRect(given.rect)) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `${draft.subtype} create field 'rect': not a rect of finite numbers`, { details: { field: "rect" } });
+	const rotation = given.rotation ?? 0;
+	const turn = quarterTurnOf(rotation);
+	if (turn === null) throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `${draft.subtype} create field 'rect': a rect places a box at a quarter turn; at ${rotation}° give its \`box\``, { details: { field: "rect" } });
+	const { rect: _placed, ...rest } = draft;
+	return {
+		...rest,
+		box: pdfQuarterTurnBox(normalizePdfRect(given.rect), turn)
+	};
+}
+//#endregion
+//#region src/annotation/resolve/redact.ts
+/**
+* A redaction over text that names no `rect` covers its quads: the box
+* around them is its region.
+*/
+function redactDraftFollows(draft) {
+	if (draft.subtype !== "redact" || draft.rect != null) return draft;
+	const quads = draft.quadPoints ?? [];
+	if (quads.length === 0) return draft;
+	const rect = pdfPointsBounds(quads.flatMap((quad) => [
+		quad.upperLeft,
+		quad.upperRight,
+		quad.lowerLeft,
+		quad.lowerRight
+	]));
+	return {
+		...draft,
+		rect
+	};
+}
+//#endregion
+//#region src/annotation/resolve/resolveAnnotationDraft.ts
+/**
+* The draft a create writes before anything follows from it, in the file's
+* coordinates, the same on the page and in the engine: its fields named by
+* its kind, and a box kind placed by its `rect` at a quarter turn stating its
+* `box` (`boxDraftFollows`). The engine checks the prepared draft against its
+* kind's schema before deriving the rest (`pdfResolveAnnotationDraft`), a
+* check that only accepts or refuses.
+*
+* Throws `InvalidArg` for a field the kind doesn't declare, and for a box
+* kind it can't place.
+*/
+function pdfPrepareAnnotationDraft(draft) {
+	assertDeclaredFields(draft.subtype, draft);
+	return boxDraftFollows(draft);
+}
+/**
+* A prepared draft with every field that follows from it stated, in the
+* file's coordinates:
+*
+* - a note's standard review state brings its state model;
+* - a free text states its intent, and its text as rich text carrying its
+*   text style, with `contents` its plain projection;
+* - a redaction over text without a `rect` covers its quads;
+* - a measurement's label follows its points and scale, and its caption is
+*   stated whole.
+*
+* Throws `InvalidArg` where nothing can follow: a custom review state with no
+* model, contents that disagree with the rich text, a callout line without
+* the callout intent, a measurement it can't label. Pure: it reads nothing
+* but its arguments. Defaults stay out of the draft: a field left out reads
+* back as `annotation/defaults.ts` says.
+*/
+function pdfDeriveAnnotationDraft(prepared, options = {}) {
+	assertRichTextAgreement(prepared);
+	return resolveMeasurementDraft(redactDraftFollows(freeTextDraftFollows(noteDraftStateFollows(prepared), options.describeFont)));
+}
+/**
+* The draft the engine writes for `draft`, as a viewer predicts it: prepared
+* and derived as the engine does (`pdfPrepareAnnotationDraft`,
+* `pdfDeriveAnnotationDraft`), without schema validation. A draft the
+* engine's schema check refuses (`pdfResolveAnnotationDraft`, from
+* `@embedpdf/engine-core/validation`) is refused when the create reaches it.
+*/
+function pdfPredictAnnotationDraft(draft, options = {}) {
+	return pdfDeriveAnnotationDraft(pdfPrepareAnnotationDraft(draft), options);
+}
+//#endregion
+Object.defineProperty(exports, "ANNOTATION_FIELD_NAMES", {
+	enumerable: true,
+	get: function() {
+		return ANNOTATION_FIELD_NAMES;
+	}
+});
+Object.defineProperty(exports, "ANNOTATION_FIELD_SPACES", {
+	enumerable: true,
+	get: function() {
+		return ANNOTATION_FIELD_SPACES;
+	}
+});
+Object.defineProperty(exports, "ANNOTATION_FIELD_SPACES_BY_NAME", {
+	enumerable: true,
+	get: function() {
+		return ANNOTATION_FIELD_SPACES_BY_NAME;
+	}
+});
+Object.defineProperty(exports, "ANNOTATION_RESOURCE_ROLES", {
+	enumerable: true,
+	get: function() {
+		return ANNOTATION_RESOURCE_ROLES;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_RICH_TEXT_BODY", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_RICH_TEXT_BODY;
+	}
+});
+Object.defineProperty(exports, "DRAWN_RECT_KINDS", {
+	enumerable: true,
+	get: function() {
+		return DRAWN_RECT_KINDS;
+	}
+});
+Object.defineProperty(exports, "STANDARD_FACES", {
+	enumerable: true,
+	get: function() {
+		return STANDARD_FACES;
+	}
+});
+Object.defineProperty(exports, "UNBAKED_KINDS", {
+	enumerable: true,
+	get: function() {
+		return UNBAKED_KINDS;
+	}
+});
+Object.defineProperty(exports, "appearanceChangeOf", {
+	enumerable: true,
+	get: function() {
+		return appearanceChangeOf;
+	}
+});
+Object.defineProperty(exports, "appearanceImpactOf", {
+	enumerable: true,
+	get: function() {
+		return appearanceImpactOf;
+	}
+});
+Object.defineProperty(exports, "assertBundlePages", {
+	enumerable: true,
+	get: function() {
+		return assertBundlePages;
+	}
+});
+Object.defineProperty(exports, "assertDeclaredFields", {
+	enumerable: true,
+	get: function() {
+		return assertDeclaredFields;
+	}
+});
+Object.defineProperty(exports, "assertKnownFields", {
+	enumerable: true,
+	get: function() {
+		return assertKnownFields;
+	}
+});
+Object.defineProperty(exports, "assertPdfFloat", {
+	enumerable: true,
+	get: function() {
+		return assertPdfFloat;
+	}
+});
+Object.defineProperty(exports, "assertResourceIds", {
+	enumerable: true,
+	get: function() {
+		return assertResourceIds;
+	}
+});
+Object.defineProperty(exports, "assertResourcesNamed", {
+	enumerable: true,
+	get: function() {
+		return assertResourcesNamed;
+	}
+});
+Object.defineProperty(exports, "assertRichTextAgreement", {
+	enumerable: true,
+	get: function() {
+		return assertRichTextAgreement;
+	}
+});
+Object.defineProperty(exports, "assertRowResources", {
+	enumerable: true,
+	get: function() {
+		return assertRowResources;
+	}
+});
+Object.defineProperty(exports, "assertWritableMeasure", {
+	enumerable: true,
+	get: function() {
+		return assertWritableMeasure;
+	}
+});
+Object.defineProperty(exports, "buildCommentThreads", {
+	enumerable: true,
+	get: function() {
+		return buildCommentThreads;
+	}
+});
+Object.defineProperty(exports, "buildThreads", {
+	enumerable: true,
+	get: function() {
+		return buildThreads;
+	}
+});
+Object.defineProperty(exports, "bundlePageMapping", {
+	enumerable: true,
+	get: function() {
+		return bundlePageMapping;
+	}
+});
+Object.defineProperty(exports, "classifyRelation", {
+	enumerable: true,
+	get: function() {
+		return classifyRelation;
+	}
+});
+Object.defineProperty(exports, "colorOf", {
+	enumerable: true,
+	get: function() {
+		return colorOf;
+	}
+});
+Object.defineProperty(exports, "compareIsoDateTime", {
+	enumerable: true,
+	get: function() {
+		return compareIsoDateTime;
+	}
+});
+Object.defineProperty(exports, "deletedWith", {
+	enumerable: true,
+	get: function() {
+		return deletedWith;
+	}
+});
+Object.defineProperty(exports, "deriveMeasurementLabel", {
+	enumerable: true,
+	get: function() {
+		return deriveMeasurementLabel;
+	}
+});
+Object.defineProperty(exports, "faceForFreeTextFont", {
+	enumerable: true,
+	get: function() {
+		return faceForFreeTextFont;
+	}
+});
+Object.defineProperty(exports, "familyKey", {
+	enumerable: true,
+	get: function() {
+		return familyKey;
+	}
+});
+Object.defineProperty(exports, "freeTextFontForFace", {
+	enumerable: true,
+	get: function() {
+		return freeTextFontForFace;
+	}
+});
+Object.defineProperty(exports, "invalidBundle", {
+	enumerable: true,
+	get: function() {
+		return invalidBundle;
+	}
+});
+Object.defineProperty(exports, "isBundlePageRef", {
+	enumerable: true,
+	get: function() {
+		return isBundlePageRef;
+	}
+});
+Object.defineProperty(exports, "isDimension", {
+	enumerable: true,
+	get: function() {
+		return isDimension;
+	}
+});
+Object.defineProperty(exports, "isReadout", {
+	enumerable: true,
+	get: function() {
+		return isReadout;
+	}
+});
+Object.defineProperty(exports, "isRecord", {
+	enumerable: true,
+	get: function() {
+		return isRecord;
+	}
+});
+Object.defineProperty(exports, "isSamePdfRect", {
+	enumerable: true,
+	get: function() {
+		return isSamePdfRect;
+	}
+});
+Object.defineProperty(exports, "isStandardFontName", {
+	enumerable: true,
+	get: function() {
+		return isStandardFontName;
+	}
+});
+Object.defineProperty(exports, "isStateAnnotation", {
+	enumerable: true,
+	get: function() {
+		return isStateAnnotation;
+	}
+});
+Object.defineProperty(exports, "kindFactsOf", {
+	enumerable: true,
+	get: function() {
+		return kindFactsOf;
+	}
+});
+Object.defineProperty(exports, "measurementPoint", {
+	enumerable: true,
+	get: function() {
+		return measurementPoint;
+	}
+});
+Object.defineProperty(exports, "measurementReadout", {
+	enumerable: true,
+	get: function() {
+		return measurementReadout;
+	}
+});
+Object.defineProperty(exports, "normalizePdfQuad", {
+	enumerable: true,
+	get: function() {
+		return normalizePdfQuad;
+	}
+});
+Object.defineProperty(exports, "normalizePdfRect", {
+	enumerable: true,
+	get: function() {
+		return normalizePdfRect;
+	}
+});
+Object.defineProperty(exports, "pathLength", {
+	enumerable: true,
+	get: function() {
+		return pathLength;
+	}
+});
+Object.defineProperty(exports, "pdfDeriveAnnotationDraft", {
+	enumerable: true,
+	get: function() {
+		return pdfDeriveAnnotationDraft;
+	}
+});
+Object.defineProperty(exports, "pdfDeriveAnnotationPatch", {
+	enumerable: true,
+	get: function() {
+		return pdfDeriveAnnotationPatch;
+	}
+});
+Object.defineProperty(exports, "pdfPointTurned", {
+	enumerable: true,
+	get: function() {
+		return pdfPointTurned;
+	}
+});
+Object.defineProperty(exports, "pdfPointUnturned", {
+	enumerable: true,
+	get: function() {
+		return pdfPointUnturned;
+	}
+});
+Object.defineProperty(exports, "pdfPointsBounds", {
+	enumerable: true,
+	get: function() {
+		return pdfPointsBounds;
+	}
+});
+Object.defineProperty(exports, "pdfPredictAnnotationDraft", {
+	enumerable: true,
+	get: function() {
+		return pdfPredictAnnotationDraft;
+	}
+});
+Object.defineProperty(exports, "pdfPredictAnnotationPatch", {
+	enumerable: true,
+	get: function() {
+		return pdfPredictAnnotationPatch;
+	}
+});
+Object.defineProperty(exports, "pdfPrepareAnnotationDraft", {
+	enumerable: true,
+	get: function() {
+		return pdfPrepareAnnotationDraft;
+	}
+});
+Object.defineProperty(exports, "pdfPrepareAnnotationPatch", {
+	enumerable: true,
+	get: function() {
+		return pdfPrepareAnnotationPatch;
+	}
+});
+Object.defineProperty(exports, "pdfQuadBounds", {
+	enumerable: true,
+	get: function() {
+		return pdfQuadBounds;
+	}
+});
+Object.defineProperty(exports, "pdfQuarterTurnBox", {
+	enumerable: true,
+	get: function() {
+		return pdfQuarterTurnBox;
+	}
+});
+Object.defineProperty(exports, "pdfRectFromOriginSize", {
+	enumerable: true,
+	get: function() {
+		return pdfRectFromOriginSize;
+	}
+});
+Object.defineProperty(exports, "pdfRectHeight", {
+	enumerable: true,
+	get: function() {
+		return pdfRectHeight;
+	}
+});
+Object.defineProperty(exports, "pdfRectIntersection", {
+	enumerable: true,
+	get: function() {
+		return pdfRectIntersection;
+	}
+});
+Object.defineProperty(exports, "pdfRectSize", {
+	enumerable: true,
+	get: function() {
+		return pdfRectSize;
+	}
+});
+Object.defineProperty(exports, "pdfRectToOriginSize", {
+	enumerable: true,
+	get: function() {
+		return pdfRectToOriginSize;
+	}
+});
+Object.defineProperty(exports, "pdfRectTurnedBounds", {
+	enumerable: true,
+	get: function() {
+		return pdfRectTurnedBounds;
+	}
+});
+Object.defineProperty(exports, "pdfRectWidth", {
+	enumerable: true,
+	get: function() {
+		return pdfRectWidth;
+	}
+});
+Object.defineProperty(exports, "pdfResolveRectCommand", {
+	enumerable: true,
+	get: function() {
+		return pdfResolveRectCommand;
+	}
+});
+Object.defineProperty(exports, "pdfShapeForRect", {
+	enumerable: true,
+	get: function() {
+		return pdfShapeForRect;
+	}
+});
+Object.defineProperty(exports, "pdfTurnOfDrawn", {
+	enumerable: true,
+	get: function() {
+		return pdfTurnOfDrawn;
+	}
+});
+Object.defineProperty(exports, "pdfTurnOfUpright", {
+	enumerable: true,
+	get: function() {
+		return pdfTurnOfUpright;
+	}
+});
+Object.defineProperty(exports, "polygonArea", {
+	enumerable: true,
+	get: function() {
+		return polygonArea;
+	}
+});
+Object.defineProperty(exports, "quarterTurnOf", {
+	enumerable: true,
+	get: function() {
+		return quarterTurnOf;
+	}
+});
+Object.defineProperty(exports, "resolveMeasurementDraft", {
+	enumerable: true,
+	get: function() {
+		return resolveMeasurementDraft;
+	}
+});
+Object.defineProperty(exports, "resourceIdOf", {
+	enumerable: true,
+	get: function() {
+		return resourceIdOf;
+	}
+});
+Object.defineProperty(exports, "rgbOf", {
+	enumerable: true,
+	get: function() {
+		return rgbOf;
+	}
+});
+Object.defineProperty(exports, "richTextParagraphsFromPlainText", {
+	enumerable: true,
+	get: function() {
+		return richTextParagraphsFromPlainText;
+	}
+});
+Object.defineProperty(exports, "richTextPlainText", {
+	enumerable: true,
+	get: function() {
+		return richTextPlainText;
+	}
+});
+Object.defineProperty(exports, "sameColor", {
+	enumerable: true,
+	get: function() {
+		return sameColor;
+	}
+});
+Object.defineProperty(exports, "scaleOf", {
+	enumerable: true,
+	get: function() {
+		return scaleOf;
+	}
+});
+Object.defineProperty(exports, "semanticEqual", {
+	enumerable: true,
+	get: function() {
+		return semanticEqual;
+	}
+});
+Object.defineProperty(exports, "shapeFieldsOf", {
+	enumerable: true,
+	get: function() {
+		return shapeFieldsOf;
+	}
+});
+Object.defineProperty(exports, "standardStateModelOf", {
+	enumerable: true,
+	get: function() {
+		return standardStateModelOf;
+	}
+});
+Object.defineProperty(exports, "touchesCaption", {
+	enumerable: true,
+	get: function() {
+		return touchesCaption;
+	}
+});
+Object.defineProperty(exports, "validAreaBoundary", {
+	enumerable: true,
+	get: function() {
+		return validAreaBoundary;
+	}
+});
+
+//# sourceMappingURL=resolveAnnotationDraft-7Ke4nV7F.cjs.map