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

package/dist/calibrate-7T3fnP8-.js

@@ -0,0 +1,2404 @@
+import { $ as ANNOTATION_FIELD_SPACES_BY_NAME, A as shapeFieldsOf, G as assertRowResources, H as assertKnownFields, J as isBundlePageRef, O as DRAWN_RECT_KINDS, P as semanticEqual, Q as ANNOTATION_FIELD_SPACES, U as assertResourceIds, V as assertBundlePages, W as assertResourcesNamed, Y as isRecord, _t as pdfQuadBounds, dt as pdfPointsBounds, ft as pdfTurnOfDrawn, j as UNBAKED_KINDS, k as pdfShapeForRect, l as pdfResolveRectCommand, lt as pdfPointTurned, mt as isSamePdfRect, n as pdfPredictAnnotationDraft, nt as kindFactsOf, o as pdfPredictAnnotationPatch, ot as DEFAULT_RICH_TEXT_BODY, pt as pdfTurnOfUpright, q as invalidBundle, tt as ANNOTATION_RESOURCE_ROLES, ut as pdfPointUnturned, v as assertWritableMeasure, wt as pdfRectTurnedBounds } from "./resolveAnnotationDraft-CUpf0SMh.js";
+import { h as EngineError, u as encodePageKey, v as _defineProperty, y as EngineErrorCode } from "./format-Dgg428Kb.js";
+import { c as toBase64, o as decodedLengthOf, s as fromBase64 } from "./charmap-Cprti1ta.js";
+//#region src/geometry/renderSize.ts
+/**
+* The pixel size of a render: an area of `width` × `height` points, turned
+* by `rotation` (width and height swap on a quarter turn) and sized by
+* `viewport`. The local worker allocates exactly this; the cloud client
+* reports it without rendering. `InvalidArg` for a viewport that isn't
+* positive.
+*/
+function renderSize(area, rotation, viewport) {
+	const swap = rotation === 90 || rotation === 270;
+	const baseWidth = swap ? area.height : area.width;
+	const baseHeight = swap ? area.width : area.height;
+	if (viewport.kind === "width") {
+		if (!Number.isFinite(viewport.width) || viewport.width <= 0) throw new EngineError(EngineErrorCode.InvalidArg, "render viewport width must be positive");
+		const width = Math.max(1, Math.round(viewport.width));
+		return {
+			width,
+			height: Math.max(1, Math.round(width * baseHeight / baseWidth))
+		};
+	}
+	const scale = viewport.scale ?? 1;
+	if (!Number.isFinite(scale) || scale <= 0) throw new EngineError(EngineErrorCode.InvalidArg, "render viewport scale must be positive");
+	return {
+		width: Math.max(1, Math.round(baseWidth * scale)),
+		height: Math.max(1, Math.round(baseHeight * scale))
+	};
+}
+//#endregion
+//#region src/geometry/pageTransform.ts
+/**
+* The transform of the image a render with `options` makes of `page`, without
+* rendering: its size, rounding included, and the conversion between page
+* space and its pixels. Takes the page's layout (`doc.pages.list()`).
+* `InvalidArg` for a viewport that isn't positive or a target without area.
+*/
+function pageTransform(page, options = {}) {
+	const target = options.target;
+	return renderAreaTransform(target?.kind === "rect" ? renderTargetArea(target.rect) : {
+		x: 0,
+		y: 0,
+		width: page.size.width,
+		height: page.size.height
+	}, options);
+}
+/** The transform of a render of `area` with `options`' turn and size. */
+function renderAreaTransform(area, options) {
+	const rotation = options.rotation ?? 0;
+	const { width, height } = renderSize(area, rotation, options.viewport ?? { kind: "scale" });
+	return renderTransform(area, rotation, width, height);
+}
+/**
+* A render target's area with its sides in order, as the renderer takes it.
+* `InvalidArg` for a rect without area, or one that isn't numbers.
+*/
+function renderTargetArea(rect) {
+	const { x, y, width, height } = rect;
+	if (![
+		x,
+		y,
+		width,
+		height
+	].every(Number.isFinite) || width === 0 || height === 0) throw new EngineError(EngineErrorCode.InvalidArg, "render rect must have positive area");
+	return {
+		x: Math.min(x, x + width),
+		y: Math.min(y, y + height),
+		width: Math.abs(width),
+		height: Math.abs(height)
+	};
+}
+/**
+* The matrix that draws `area` of the page, turned clockwise by `rotation`,
+* onto `width` × `height` pixels. The renderer draws with it.
+*/
+function renderMatrix(area, rotation, width, height) {
+	const { x, y } = area;
+	const w = area.width;
+	const h = area.height;
+	switch (rotation) {
+		case 0: return [
+			width / w,
+			0,
+			0,
+			height / h,
+			-width / w * x,
+			-height / h * y
+		];
+		case 90: return [
+			0,
+			height / w,
+			-width / h,
+			0,
+			width / h * (y + h),
+			-height / w * x
+		];
+		case 180: return [
+			-width / w,
+			0,
+			0,
+			-height / h,
+			width / w * (x + w),
+			height / h * (y + h)
+		];
+		case 270: return [
+			0,
+			-height / w,
+			width / h,
+			0,
+			-width / h * y,
+			height / w * (x + w)
+		];
+	}
+}
+/** The transform of a render of `area`, turned by `rotation`, drawn onto `width` × `height` pixels. */
+function renderTransform(area, rotation, width, height) {
+	const matrix = renderMatrix(area, rotation, width, height);
+	const inverse = inverseOf(matrix);
+	return {
+		width,
+		height,
+		matrix,
+		pageToPixels: ((value) => mapped(matrix, value)),
+		pixelsToPage: ((value) => mapped(inverse, value))
+	};
+}
+function inverseOf([a, b, c, d, e, f]) {
+	const det = a * d - b * c;
+	return [
+		d / det,
+		-b / det,
+		-c / det,
+		a / det,
+		(c * f - d * e) / det,
+		(b * e - a * f) / det
+	];
+}
+function mappedPoint(m, { x, y }) {
+	return {
+		x: m[0] * x + m[2] * y + m[4],
+		y: m[1] * x + m[3] * y + m[5]
+	};
+}
+/** A point, a box or a quad through `m`. A box stays a box: every turn is a quarter turn. */
+function mapped(m, value) {
+	if ("upperLeft" in value) return {
+		upperLeft: mappedPoint(m, value.upperLeft),
+		upperRight: mappedPoint(m, value.upperRight),
+		lowerLeft: mappedPoint(m, value.lowerLeft),
+		lowerRight: mappedPoint(m, value.lowerRight)
+	};
+	if ("width" in value) {
+		const from = mappedPoint(m, value);
+		const to = mappedPoint(m, {
+			x: value.x + value.width,
+			y: value.y + value.height
+		});
+		return {
+			x: Math.min(from.x, to.x),
+			y: Math.min(from.y, to.y),
+			width: Math.abs(to.x - from.x),
+			height: Math.abs(to.y - from.y)
+		};
+	}
+	return mappedPoint(m, value);
+}
+//#endregion
+//#region src/geometry/pageSpace.ts
+/** A point in the file's coordinates, in page space. `visible` is the page's visible box. */
+function pagePointOf(point, visible) {
+	return {
+		x: point.x - visible.left,
+		y: visible.top - point.y
+	};
+}
+/** A page-space point in the file's coordinates. */
+function pdfPointOf(point, visible) {
+	return {
+		x: point.x + visible.left,
+		y: visible.top - point.y
+	};
+}
+/** A normalized rect in the file's coordinates, in page space. */
+function pageBoxOf(rect, visible) {
+	return {
+		x: rect.left - visible.left,
+		y: visible.top - rect.top,
+		width: rect.right - rect.left,
+		height: rect.top - rect.bottom
+	};
+}
+/** A page-space box in the file's coordinates, keys in `normalizePdfRect`'s order. */
+function pdfRectOf(box, visible) {
+	const left = box.x + visible.left;
+	const top = visible.top - box.y;
+	return {
+		left,
+		right: left + box.width,
+		bottom: top - box.height,
+		top
+	};
+}
+function pageQuadOf(quad, visible) {
+	return {
+		upperLeft: pagePointOf(quad.upperLeft, visible),
+		upperRight: pagePointOf(quad.upperRight, visible),
+		lowerLeft: pagePointOf(quad.lowerLeft, visible),
+		lowerRight: pagePointOf(quad.lowerRight, visible)
+	};
+}
+function pdfQuadOf(quad, visible) {
+	return {
+		upperLeft: pdfPointOf(quad.upperLeft, visible),
+		upperRight: pdfPointOf(quad.upperRight, visible),
+		lowerLeft: pdfPointOf(quad.lowerLeft, visible),
+		lowerRight: pdfPointOf(quad.lowerRight, visible)
+	};
+}
+/** A page-space point flipped into y-up coordinates. */
+const mirroredPoint = (point) => ({
+	x: point.x,
+	y: -point.y
+});
+/** A y-up point flipped back into page space. */
+const unmirroredPoint = (point) => ({
+	x: point.x,
+	y: -point.y
+});
+/** A page-space box flipped into a y-up rect. */
+const mirroredRect = (box) => ({
+	left: box.x,
+	right: box.x + box.width,
+	bottom: -(box.y + box.height),
+	top: -box.y
+});
+/** A y-up rect flipped back into a page-space box. */
+const unmirroredBox = (rect) => ({
+	x: rect.left,
+	y: -rect.top,
+	width: rect.right - rect.left,
+	height: rect.top - rect.bottom
+});
+const mirroredQuad = (quad) => ({
+	upperLeft: mirroredPoint(quad.upperLeft),
+	upperRight: mirroredPoint(quad.upperRight),
+	lowerLeft: mirroredPoint(quad.lowerLeft),
+	lowerRight: mirroredPoint(quad.lowerRight)
+});
+const unmirroredQuad = (quad) => ({
+	upperLeft: unmirroredPoint(quad.upperLeft),
+	upperRight: unmirroredPoint(quad.upperRight),
+	lowerLeft: unmirroredPoint(quad.lowerLeft),
+	lowerRight: unmirroredPoint(quad.lowerRight)
+});
+//#endregion
+//#region src/dto/PageGeometrySnapshot.ts
+/** Narrowing guard: is this run the rotated (non-upright) variant? */
+function isRotatedGeometryRun(run) {
+	return "rotation" in run;
+}
+/**
+* Uniform oriented-cell view over either run variant, in the file's
+* coordinates: the glyph's loose cell as a quad (synthesized from the box
+* corners when the run is upright).
+*/
+function glyphLooseQuad(run, index) {
+	if (isRotatedGeometryRun(run)) return run.glyphs[index].loose;
+	const b = run.glyphs[index].loose;
+	return {
+		upperLeft: {
+			x: b.left,
+			y: b.top
+		},
+		upperRight: {
+			x: b.right,
+			y: b.top
+		},
+		lowerLeft: {
+			x: b.left,
+			y: b.bottom
+		},
+		lowerRight: {
+			x: b.right,
+			y: b.bottom
+		}
+	};
+}
+/**
+* Uniform AABB view over either run variant, in the file's coordinates: the
+* glyph's loose box, or the
+* enclosing bounds of its oriented cell when the run is rotated. The
+* conservative envelope for consumers that genuinely want a box (culling,
+* scroll targets) — never a substitute for handling orientation in geometry
+* that gets drawn.
+*/
+function glyphLooseBounds(run, index) {
+	if (isRotatedGeometryRun(run)) return pdfQuadBounds(run.glyphs[index].loose);
+	return run.glyphs[index].loose;
+}
+//#endregion
+//#region src/promise/AbortError.ts
+/**
+* What a cancelled call rejects with: an `EngineError` with code `Aborted`,
+* named `AbortError` like the DOM's, so both `EngineError.is(err,
+* EngineErrorCode.Aborted)` and `err.name === 'AbortError'` recognise it.
+*/
+var AbortError = class extends EngineError {
+	constructor(reason) {
+		super(EngineErrorCode.Aborted, reasonMessage(reason));
+		_defineProperty(this, "name", "AbortError");
+		_defineProperty(this, "reason", void 0);
+		this.reason = reason;
+	}
+};
+function isAbortError(value) {
+	return value instanceof AbortError || value?.name === "AbortError";
+}
+function reasonMessage(reason) {
+	if (reason == null) return "aborted";
+	if (typeof reason === "string") return reason;
+	if (reason instanceof Error) return reason.message || "aborted";
+	try {
+		return JSON.stringify(reason);
+	} catch {
+		return "aborted";
+	}
+}
+//#endregion
+//#region src/resource/BinarySource.ts
+function isBlob$1(value) {
+	return typeof Blob !== "undefined" && value instanceof Blob;
+}
+/**
+* Copy a Uint8Array view into a fresh, exactly-sized ArrayBuffer the call
+* owns. Always copies — even when the view spans its whole buffer — because
+* the result may be transferred to a worker (detaching it), and the view is
+* the caller's. Returning `view.buffer` here would let one transfer zero
+* the caller's bytes (a stamp library's Uint8Array became single-use).
+* Callers wanting a zero-copy hand-off need an explicit "give" form, as
+* `pages.insert` has for bare ArrayBuffers; `BinarySource` has none.
+*/
+function toOwnedArrayBuffer(view) {
+	const copy = new ArrayBuffer(view.byteLength);
+	new Uint8Array(copy).set(view);
+	return copy;
+}
+/**
+* Resolve any accepted `BinarySource` form into a `WireResource`.
+* Async because Blob bytes can only be read asynchronously.
+*/
+async function resolveBinarySource(source) {
+	if (source instanceof Uint8Array) return { bytes: toOwnedArrayBuffer(source) };
+	if (isBlob$1(source)) {
+		const blobName = blobFileName(source);
+		return {
+			bytes: await source.arrayBuffer(),
+			mimeType: source.type || void 0,
+			...blobName !== void 0 ? { name: blobName } : {}
+		};
+	}
+	const { data, mimeType, name } = source;
+	const inner = data instanceof Uint8Array ? {
+		bytes: toOwnedArrayBuffer(data),
+		mimeType: void 0,
+		name: void 0
+	} : {
+		bytes: await data.arrayBuffer(),
+		mimeType: data.type || void 0,
+		name: blobFileName(data)
+	};
+	const resolvedName = name ?? inner.name;
+	return {
+		bytes: inner.bytes,
+		...mimeType ?? inner.mimeType ? { mimeType: mimeType ?? inner.mimeType } : {},
+		...resolvedName !== void 0 ? { name: resolvedName } : {}
+	};
+}
+/** A browser `File` is a Blob with a `name` — pick it up so attachment
+*  drafts can pass a `File` directly without repeating the file name. */
+function blobFileName(blob) {
+	const name = blob.name;
+	return typeof name === "string" && name.length > 0 ? name : void 0;
+}
+//#endregion
+//#region src/resource/binaryMetadata.ts
+/**
+* Detect format (and intrinsic dimensions for rasters) of a binary buffer.
+*
+* @returns metadata, or `null` for unsupported/corrupt data
+*/
+function sniffBinaryMetadata(buffer) {
+	if (buffer.byteLength < 4) return null;
+	const bytes = new Uint8Array(buffer);
+	if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) return parsePng(buffer);
+	if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return parseJpeg(buffer);
+	if (bytes[0] === 37 && bytes[1] === 80 && bytes[2] === 68 && bytes[3] === 70) return { mimeType: "application/pdf" };
+	return null;
+}
+function parsePng(buffer) {
+	if (buffer.byteLength < 24) return null;
+	const view = new DataView(buffer);
+	const width = view.getUint32(16);
+	const height = view.getUint32(20);
+	if (width === 0 || height === 0) return null;
+	return {
+		mimeType: "image/png",
+		width,
+		height
+	};
+}
+function parseJpeg(buffer) {
+	const bytes = new Uint8Array(buffer);
+	let offset = 2;
+	while (offset + 4 < bytes.byteLength) {
+		if (bytes[offset] !== 255) return null;
+		const marker = bytes[offset + 1];
+		if (marker >= 192 && marker <= 195) {
+			if (offset + 9 > bytes.byteLength) return null;
+			const view = new DataView(buffer, offset + 5);
+			const height = view.getUint16(0);
+			const width = view.getUint16(2);
+			if (width === 0 || height === 0) return null;
+			return {
+				mimeType: "image/jpeg",
+				width,
+				height
+			};
+		}
+		if (marker === 216 || marker === 217) offset += 2;
+		else if (marker === 255) offset += 1;
+		else {
+			const segLen = bytes[offset + 2] << 8 | bytes[offset + 3];
+			offset += 2 + segLen;
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/annotation/resources.ts
+/**
+* Bytes travel beside an annotation's data, never inside it:
+* `create(data, resources)` and `update(ref, patch, resources)`. A read
+* returns the data only. Each role names what the bytes are for; a kind
+* declares the roles it takes (`kinds/<kind>/declaration.ts`).
+*/
+/**
+* What bytes beside an annotation's data can be for:
+*
+* - `appearance`: what the box shows before the rotation the data describes,
+*   PNG, JPEG or a one-page PDF, scaled into the box as the data's `fit` says.
+*   A stamp requires it; on update it replaces the drawing.
+* - `file`: an attached file's exact bytes; its name, MIME type and
+*   description are the data's `file`. A file attachment requires it; on
+*   update it replaces the bytes.
+*/
+const ANNOTATION_RESOURCE_ROLE_NAMES = ["appearance", "file"];
+/**
+* Copy each resource into bytes the write owns: the local engine transfers
+* them to its worker, which detaches the buffer, and the caller's bytes are
+* only borrowed. An appearance that isn't PNG, JPEG or PDF fails here,
+* before anything is sent; the format comes from the bytes.
+*/
+async function resolveAnnotationResources(resources) {
+	if (!resources) return {};
+	for (const role of Object.keys(resources)) if (!ANNOTATION_RESOURCE_ROLE_NAMES.includes(role)) throw new EngineError(EngineErrorCode.InvalidArg, `unknown annotation resource '${role}'; expected ${ANNOTATION_RESOURCE_ROLE_NAMES.join(" or ")}`);
+	const wire = {};
+	for (const role of ANNOTATION_RESOURCE_ROLE_NAMES) {
+		const data = resources[role];
+		if (data === void 0) continue;
+		const bytes = await ownedBytes(data);
+		if (role === "appearance" && !sniffBinaryMetadata(bytes)) throw new EngineError(EngineErrorCode.InvalidArg, "the appearance resource must be PNG, JPEG or one-page PDF bytes");
+		wire[role] = bytes;
+	}
+	return wire;
+}
+/**
+* A file-attachment create's `file`, completed from its `file` resource when
+* that is a `File` or a `Blob`: the name a `File` brings and the type a
+* `Blob` does, where the data leaves them out. A `Blob` with no type gives
+* none. Other drafts, and bare bytes, pass as they are.
+*/
+function withFileFromResource(draft, resources) {
+	const data = resources?.file;
+	if (draft.subtype !== "file-attachment" || !isBlob(data)) return draft;
+	const name = draft.file?.name ?? blobFileName(data);
+	if (name === void 0) return draft;
+	return {
+		...draft,
+		file: {
+			...draft.file,
+			name,
+			mimeType: draft.file?.mimeType !== void 0 ? draft.file.mimeType : data.type || null
+		}
+	};
+}
+function hasAnnotationResources(resources) {
+	return ANNOTATION_RESOURCE_ROLE_NAMES.some((role) => resources[role] !== void 0);
+}
+/** The buffers of a write's resources: what a worker transfer list hands over. */
+function annotationResourceBuffers(resources) {
+	return Object.values(resources).filter((bytes) => bytes !== void 0);
+}
+/**
+* Check a write's resources against its kind: a role the kind doesn't take
+* is refused, and so is a create without a role the kind requires.
+*/
+function assertAnnotationResources(subtype, resources, write) {
+	const roles = ANNOTATION_RESOURCE_ROLES[subtype] ?? {};
+	for (const role of ANNOTATION_RESOURCE_ROLE_NAMES) {
+		const given = resources?.[role] !== void 0;
+		if (given && roles[role] === void 0) throw new EngineError(EngineErrorCode.InvalidArg, `a ${subtype} annotation takes no '${role}' resource`);
+		if (!given && write === "create" && roles[role] === "required") throw new EngineError(EngineErrorCode.InvalidArg, `creating a ${subtype} annotation needs its '${role}' resource`);
+	}
+}
+function isBlob(value) {
+	return typeof Blob !== "undefined" && value instanceof Blob;
+}
+async function ownedBytes(data) {
+	if (isBlob(data)) return data.arrayBuffer();
+	const copy = new ArrayBuffer(data.byteLength);
+	new Uint8Array(copy).set(data);
+	return copy;
+}
+//#endregion
+//#region src/transfer/bundleLimits.ts
+const DEFAULT_BUNDLE_LIMITS = Object.freeze({
+	bundleBytes: 50 * 1024 * 1024,
+	manifestBytes: 16 * 1024 * 1024,
+	items: 1e4,
+	pages: 2e3,
+	resources: 2e3,
+	resourceBytes: 50 * 1024 * 1024,
+	imagePixels: 4e7
+});
+/** The bytes of a bundle's manifest: its pages and rows (`{ pages, items }`) as UTF-8 JSON. */
+function manifestBytesOf(rows) {
+	return new TextEncoder().encode(JSON.stringify(rows)).length;
+}
+/** Refuse `value` when it is past the limit named `limit`. */
+function assertWithinLimit(kind, limits, limit, value) {
+	const max = limits[limit];
+	if (value <= max) return;
+	throw new EngineError(EngineErrorCode.PayloadTooLarge, `the ${kind} bundle is past its ${limit} limit: ${value} > ${max}`, { details: {
+		limit,
+		max,
+		value
+	} });
+}
+//#endregion
+//#region src/transfer/codec.ts
+/** A resource's entry in the file besides its base64: its id, quotes and separators. */
+const RESOURCE_ENTRY_CHARACTERS = 81;
+/** The file's own keys and punctuation. */
+const ENVELOPE_CHARACTERS = 256;
+const A_BUNDLE = {
+	annotation: "an annotation bundle",
+	form: "a form bundle"
+};
+/**
+* The JSON file of one family's bundles: a bundle whole, to store or
+* download. HTTP carries bundles as multipart instead, without the third
+* base64 adds.
+*/
+function bundleCodec(spec) {
+	const notABundle = (cause) => new EngineError(EngineErrorCode.InvalidArg, `the file is not ${A_BUNDLE[spec.kind]}`, cause === void 0 ? void 0 : { cause });
+	return {
+		stringify(bundle, options) {
+			const limits = options?.limits ?? DEFAULT_BUNDLE_LIMITS;
+			const sizes = /* @__PURE__ */ new Map();
+			for (const [id, bytes] of Object.entries(bundle.resources)) sizes.set(id, bytes.length);
+			spec.assertManifest(bundle, sizes, limits);
+			const file = {};
+			for (const key of spec.keys) file[key] = bundle[key];
+			const resources = {};
+			for (const [id, bytes] of Object.entries(bundle.resources)) resources[id] = toBase64(bytes);
+			file.resources = resources;
+			return JSON.stringify(file);
+		},
+		async parse(text, options) {
+			const limits = options?.limits ?? DEFAULT_BUNDLE_LIMITS;
+			const maxLength = Math.ceil(limits.bundleBytes * 4 / 3) + limits.resources * RESOURCE_ENTRY_CHARACTERS + ENVELOPE_CHARACTERS;
+			if (text.length > maxLength) throw new EngineError(EngineErrorCode.PayloadTooLarge, `the file is ${text.length} characters, more than a bundle within ${limits.bundleBytes} bytes can be`, { details: {
+				limit: "bundleBytes",
+				max: limits.bundleBytes,
+				fileLength: text.length
+			} });
+			let file;
+			try {
+				file = JSON.parse(text);
+			} catch (error) {
+				throw notABundle(error);
+			}
+			const encoded = typeof file === "object" && file !== null ? file.resources : null;
+			if (typeof encoded !== "object" || encoded === null || Array.isArray(encoded)) throw notABundle();
+			const sizes = /* @__PURE__ */ new Map();
+			for (const [id, value] of Object.entries(encoded)) {
+				const size = typeof value === "string" ? decodedLengthOf(value) : null;
+				if (size === null) throw new EngineError(EngineErrorCode.InvalidArg, `resource ${id} is not base64`);
+				sizes.set(id, size);
+			}
+			spec.assertManifest(file, sizes, limits);
+			const resources = {};
+			for (const [id, value] of Object.entries(encoded)) try {
+				resources[id] = fromBase64(value);
+			} catch (error) {
+				throw new EngineError(EngineErrorCode.InvalidArg, `resource ${id} is not base64`, { cause: error });
+			}
+			await assertResourceIds(spec.kind, resources);
+			const bundle = {};
+			for (const key of spec.keys) bundle[key] = file[key];
+			bundle.resources = resources;
+			return bundle;
+		}
+	};
+}
+/** The manifest's keys, in the order a file writes them. */
+const ANNOTATION_BUNDLE_KEYS = [
+	"format",
+	"version",
+	"pages",
+	"items"
+];
+const BUNDLE_FIELDS = [...ANNOTATION_BUNDLE_KEYS, "resources"];
+const ITEM_FIELDS = ["data", "resources"];
+/**
+* Check a bundle before anything uses it, the checks cheapest first: its
+* format, its counts and sizes against `limits` (`PayloadTooLarge`), its
+* shape and references (`InvalidArg`), then every resource against its id.
+*/
+async function assertAnnotationBundle(bundle, limits = DEFAULT_BUNDLE_LIMITS) {
+	const resources = isRecord(bundle?.resources) ? bundle.resources : invalidBundle("annotation", "no resources");
+	const sizes = /* @__PURE__ */ new Map();
+	for (const [id, bytes] of Object.entries(resources)) {
+		if (!(bytes instanceof Uint8Array)) invalidBundle("annotation", `resource ${id} is not bytes`);
+		sizes.set(id, bytes.length);
+	}
+	assertAnnotationBundleManifest(bundle, sizes, limits);
+	await assertResourceIds("annotation", resources);
+}
+/**
+* The checks that need no resource bytes, only their sizes by id: format
+* and version, counts, sizes, the shape of pages and items, and that items
+* and resources name each other exactly.
+*/
+function assertAnnotationBundleManifest(manifest, resourceSizes, limits) {
+	if (!isRecord(manifest)) invalidBundle("annotation", "not an annotation bundle");
+	assertKnownFields("annotation", "the bundle", manifest, BUNDLE_FIELDS);
+	if (manifest.format !== "embedpdf/annotations") invalidBundle("annotation", `unknown format ${JSON.stringify(manifest.format)}`);
+	if (manifest.version !== 1) invalidBundle("annotation", `unknown version ${JSON.stringify(manifest.version)}`);
+	const { pages, items } = manifest;
+	if (!Array.isArray(pages)) invalidBundle("annotation", "pages is not a list");
+	if (!Array.isArray(items)) invalidBundle("annotation", "items is not a list");
+	assertWithinLimit("annotation", limits, "items", items.length);
+	assertWithinLimit("annotation", limits, "pages", pages.length);
+	assertWithinLimit("annotation", limits, "resources", resourceSizes.size);
+	let bundleBytes = manifestBytesOf({
+		pages,
+		items
+	});
+	assertWithinLimit("annotation", limits, "manifestBytes", bundleBytes);
+	for (const size of resourceSizes.values()) {
+		assertWithinLimit("annotation", limits, "resourceBytes", size);
+		bundleBytes += size;
+	}
+	assertWithinLimit("annotation", limits, "bundleBytes", bundleBytes);
+	const pageKeys = assertBundlePages("annotation", pages);
+	const named = /* @__PURE__ */ new Set();
+	items.forEach((item, index) => {
+		if (!isRecord(item) || !isRecord(item.data) || typeof item.data.subtype !== "string") invalidBundle("annotation", `item ${index} has no annotation data`);
+		assertKnownFields("annotation", `item ${index}`, item, ITEM_FIELDS);
+		const ref = item.data.ref;
+		const page = isRecord(ref) ? ref.page : void 0;
+		if (!isBundlePageRef(page) || !pageKeys.has(encodePageKey(page))) invalidBundle("annotation", `item ${index} is on a page the bundle doesn't list`);
+		assertRowResources("annotation", `item ${index}`, item.resources, ANNOTATION_RESOURCE_ROLE_NAMES, resourceSizes, named);
+	});
+	assertResourcesNamed("annotation", "item", resourceSizes, named);
+}
+//#endregion
+//#region src/transfer/AnnotationTransfer.ts
+/**
+* An annotation bundle as one JSON file, each resource in base64: a bundle
+* whole, to store or download. HTTP carries bundles as multipart instead,
+* without the third base64 adds.
+*/
+const AnnotationTransfer = bundleCodec({
+	kind: "annotation",
+	keys: ANNOTATION_BUNDLE_KEYS,
+	assertManifest: assertAnnotationBundleManifest
+});
+//#endregion
+//#region src/dto/Attachment.ts
+/** The ref of an attachment whose name-tree key you already hold. */
+function toAttachmentRef(key) {
+	return {
+		kind: "key",
+		key
+	};
+}
+//#endregion
+//#region src/annotation/appearanceTurn.ts
+/** The kinds drawn about a box that can turn. */
+const BOX_KINDS = /* @__PURE__ */ new Set([
+	"square",
+	"circle",
+	"free-text",
+	"stamp",
+	"caret"
+]);
+/**
+* The turn an annotation's appearance raster is drawn without, degrees
+* clockwise, or `null` when the raster is drawn as the page shows it. A box
+* kind drawn turned whose drawing stays inside the turned box (its `rect` is
+* the upright box around it) renders upright over its `box`, for the
+* consumer to turn about the middle of `box`: a new turn needs no new
+* raster. A callout (its line isn't turned) and a drawing that reaches past
+* its box (a cloudy border's bumps) render as the page shows them, placed by
+* `rect`.
+*/
+function pdfAppearanceTurnOf(annotation) {
+	const { subtype, rect, box, rotation, intent } = annotation;
+	if (!BOX_KINDS.has(subtype) || !box || !rotation) return null;
+	if (subtype === "free-text" && intent === "free-text-callout") return null;
+	return isSamePdfRect(pdfRectTurnedBounds(box, rotation), rect) ? rotation : null;
+}
+//#endregion
+//#region src/annotation/resolve/applyAnnotationPatch.ts
+/**
+* A resolved patch's fields as a read spells them. Most fields read as they
+* are written; these take a different shape on the way in.
+*/
+function readValueOf(name, value, current) {
+	if (value === null) return null;
+	switch (name) {
+		case "reply": {
+			const reply = value;
+			return {
+				to: reply.to,
+				type: reply.type ?? "reply"
+			};
+		}
+		case "richText": {
+			const input = value;
+			const read = current;
+			const body = input.body ? {
+				...DEFAULT_RICH_TEXT_BODY,
+				...input.body
+			} : read?.body ?? DEFAULT_RICH_TEXT_BODY;
+			return {
+				body: {
+					...body,
+					color: body.color.toLowerCase()
+				},
+				paragraphs: input.paragraphs.map((paragraph) => ({
+					...paragraph,
+					runs: paragraph.runs.filter((run) => run.text !== "").map((run) => run.style?.color ? {
+						...run,
+						style: {
+							...run.style,
+							color: run.style.color.toLowerCase()
+						}
+					} : run)
+				}))
+			};
+		}
+		case "file": {
+			const written = value;
+			return {
+				...current ?? {
+					size: null,
+					checksum: null,
+					createdAt: null,
+					modifiedAt: null
+				},
+				name: written.name,
+				mimeType: written.mimeType ?? null,
+				description: written.description ?? null
+			};
+		}
+		default: return value;
+	}
+}
+/**
+* `current` with a resolved patch's data fields in place, each as a read
+* spells it. Fields the engine works out or stamps itself (a drawn kind's
+* `rect`, the modified date and author) keep
+* the value `current` has: the engine's answer brings the new one. Works in
+* either space: it only moves values by field name.
+*/
+function applyResolvedPatch(current, resolved) {
+	const owners = kindFactsOf(current.subtype)?.owners ?? {};
+	const read = current;
+	const next = { ...read };
+	for (const [name, value] of Object.entries(resolved)) {
+		if (name === "subtype" || value === void 0) continue;
+		if (owners[name] !== "data") continue;
+		next[name] = readValueOf(name, value, read[name]);
+	}
+	return {
+		...next,
+		...followingReads(current, resolved)
+	};
+}
+/**
+* Fields the engine keeps as found, but rewrites when a data field they
+* mirror changes: a link's `target` is the root of its `/A`, so a new target
+* is a new `actions.activate` (and no target, none).
+*/
+function followingReads(current, resolved) {
+	if (current.subtype !== "link" || resolved.subtype !== "link") return {};
+	const target = resolved.target;
+	if (target === void 0 || target !== null && target.kind !== "uri" && target.kind !== "goto") return {};
+	const { activate: _replaced, ...others } = current.actions ?? {};
+	const actions = target === null ? others : {
+		...others,
+		activate: actionTreeOf(target)
+	};
+	return { actions: Object.keys(actions).length > 0 ? actions : null };
+}
+/** The action tree the engine writes for a link target: one URI or GoTo action. */
+function actionTreeOf(target) {
+	return {
+		root: target.kind === "uri" ? {
+			type: "uri",
+			subtype: "URI",
+			uri: target.uri,
+			isMap: false,
+			next: []
+		} : {
+			type: "goto",
+			subtype: "GoTo",
+			destination: target.destination,
+			next: []
+		},
+		incomplete: false,
+		warningFlags: 0,
+		warnings: []
+	};
+}
+//#endregion
+//#region src/annotation/defaults.ts
+const RED = "#ff0000";
+const BLACK = "#000000";
+const YELLOW = "#ffff00";
+/** Every kind: printed (as Acrobat creates them), no other flag set, normal blending. A popup doesn't print. */
+const BASE = {
+	invisible: false,
+	hidden: false,
+	print: true,
+	noZoom: false,
+	noRotate: false,
+	noView: false,
+	readOnly: false,
+	locked: false,
+	toggleNoView: false,
+	lockedContents: false,
+	blendMode: "normal"
+};
+/** Shapes and lines: a solid red line, one point wide. */
+const STROKE = {
+	...BASE,
+	color: RED,
+	opacity: 1,
+	strokeWidth: 1,
+	borderStyle: "solid"
+};
+const NO_ENDINGS = {
+	start: "none",
+	end: "none"
+};
+/** Text markup other than a highlight: black. */
+const MARKUP = {
+	...BASE,
+	color: BLACK,
+	opacity: 1
+};
+const ANNOTATION_DEFAULTS = {
+	square: STROKE,
+	circle: STROKE,
+	line: {
+		...STROKE,
+		lineEndings: NO_ENDINGS,
+		captionPosition: "inline"
+	},
+	polygon: STROKE,
+	polyline: {
+		...STROKE,
+		lineEndings: NO_ENDINGS
+	},
+	ink: STROKE,
+	highlight: {
+		...BASE,
+		blendMode: "multiply",
+		color: YELLOW,
+		opacity: 1
+	},
+	underline: MARKUP,
+	squiggly: MARKUP,
+	strikeout: MARKUP,
+	caret: {
+		...BASE,
+		color: RED,
+		opacity: 1
+	},
+	"free-text": {
+		...BASE,
+		contents: "",
+		intent: "free-text",
+		fontFamily: "helvetica",
+		fontSize: 12,
+		textAlign: "left",
+		verticalAlign: "top",
+		color: BLACK,
+		fontColor: BLACK,
+		opacity: 1,
+		strokeWidth: 1,
+		borderStyle: "solid"
+	},
+	text: {
+		...BASE,
+		icon: "note",
+		open: false,
+		color: YELLOW,
+		opacity: 1
+	},
+	"file-attachment": {
+		...BASE,
+		icon: "paperclip",
+		color: YELLOW,
+		opacity: 1
+	},
+	link: BASE,
+	redact: {
+		...BASE,
+		quadPoints: [],
+		color: RED,
+		opacity: 1,
+		repeat: false,
+		fontFamily: "helvetica",
+		fontSize: 12,
+		fontColor: BLACK,
+		textAlign: "left"
+	},
+	stamp: {
+		...BASE,
+		fit: "contain",
+		opacity: 1
+	},
+	widget: {
+		...BASE,
+		strokeWidth: 1,
+		borderStyle: "solid",
+		textAlign: "left"
+	},
+	popup: {
+		...BASE,
+		print: false,
+		open: false
+	}
+};
+/** What a create of `subtype` reads back for each data field it leaves out. */
+function annotationDefaultsOf(subtype) {
+	return subtype === "unsupported" ? {} : ANNOTATION_DEFAULTS[subtype];
+}
+//#endregion
+//#region src/pageSpace/destinations.ts
+const boxFor = (page, box) => typeof box === "function" ? box(page) : box;
+/** An axis value that may keep the current one (`null`) or be left out. */
+const across = (value, convert) => value == null ? value : convert(value);
+/**
+* A destination in the file's coordinates, in page space: for one read by
+* another PDF tool, before handing it to the viewer. `box` is the `pdfCropBox`
+* of the page it goes to.
+*/
+function pageDestinationOf(destination, box) {
+	const { left: boxLeft, top: boxTop } = boxFor(destination.page, box);
+	const x = (left) => across(left, (value) => value - boxLeft);
+	const y = (top) => across(top, (value) => boxTop - value);
+	switch (destination.kind) {
+		case "xyz": {
+			const { left, top, ...rest } = destination;
+			return {
+				...rest,
+				..."left" in destination ? { x: x(left) } : {},
+				..."top" in destination ? { y: y(top) } : {}
+			};
+		}
+		case "fitH":
+		case "fitBH": {
+			const { top, ...rest } = destination;
+			return {
+				...rest,
+				..."top" in destination ? { y: y(top) } : {}
+			};
+		}
+		case "fitV":
+		case "fitBV": {
+			const { left, ...rest } = destination;
+			return {
+				...rest,
+				..."left" in destination ? { x: x(left) } : {}
+			};
+		}
+		case "fitR": {
+			const { left, bottom, right, top, ...rest } = destination;
+			const lower = Math.min(bottom, top);
+			const upper = Math.max(bottom, top);
+			return {
+				...rest,
+				x: Math.min(left, right) - boxLeft,
+				y: boxTop - upper,
+				width: Math.abs(right - left),
+				height: upper - lower
+			};
+		}
+		case "fit":
+		case "fitB": return destination;
+	}
+}
+/**
+* A page-space destination in the file's coordinates: for handing one to
+* another PDF tool. `box` is the `pdfCropBox` of the page it goes to.
+*/
+function pdfDestinationOf(destination, box) {
+	const { left: boxLeft, top: boxTop } = boxFor(destination.page, box);
+	const left = (x) => across(x, (value) => value + boxLeft);
+	const top = (y) => across(y, (value) => boxTop - value);
+	switch (destination.kind) {
+		case "xyz": {
+			const { x, y, ...rest } = destination;
+			return {
+				...rest,
+				..."x" in destination ? { left: left(x) } : {},
+				..."y" in destination ? { top: top(y) } : {}
+			};
+		}
+		case "fitH":
+		case "fitBH": {
+			const { y, ...rest } = destination;
+			return {
+				...rest,
+				..."y" in destination ? { top: top(y) } : {}
+			};
+		}
+		case "fitV":
+		case "fitBV": {
+			const { x, ...rest } = destination;
+			return {
+				...rest,
+				..."x" in destination ? { left: left(x) } : {}
+			};
+		}
+		case "fitR": {
+			const { x, y, width, height, ...rest } = destination;
+			const upper = boxTop - y;
+			return {
+				...rest,
+				left: x + boxLeft,
+				bottom: upper - height,
+				right: x + boxLeft + width,
+				top: upper
+			};
+		}
+		case "fit":
+		case "fitB": return destination;
+	}
+}
+function mapLinkTarget(target, convert) {
+	return target.kind === "goto" ? {
+		...target,
+		destination: convert(target.destination)
+	} : target;
+}
+function mapActionNode(node, convert) {
+	const next = node.next.map((child) => mapActionNode(child, convert));
+	return node.type === "goto" ? {
+		...node,
+		next,
+		destination: convert(node.destination)
+	} : {
+		...node,
+		next
+	};
+}
+function mapActionTree(tree, convert) {
+	return {
+		...tree,
+		root: tree.root ? mapActionNode(tree.root, convert) : null
+	};
+}
+/** An action to write, its destinations converted. */
+function mapActionWrite(action, convert) {
+	const next = action.next?.map((child) => mapActionWrite(child, convert));
+	const converted = action.type === "goto" ? {
+		...action,
+		destination: convert(action.destination)
+	} : action;
+	return next ? {
+		...converted,
+		next
+	} : converted;
+}
+/**
+* A record of triggers as a read has them (trees) or a write takes them
+* (actions to write, `null` to remove one), its destinations converted.
+*/
+function mapTriggerActions(triggers, convert) {
+	return Object.fromEntries(Object.entries(triggers).map(([trigger, value]) => {
+		if (value == null) return [trigger, value];
+		return [trigger, "root" in value ? mapActionTree(value, convert) : mapActionWrite(value, convert)];
+	}));
+}
+/** Every action tree in a record of triggers (an annotation's, a page's or a field's). */
+function mapTriggers(triggers, convert) {
+	return Object.fromEntries(Object.entries(triggers).map(([trigger, tree]) => [trigger, tree ? mapActionTree(tree, convert) : tree]));
+}
+function mapAnnotationActions(actions, convert) {
+	return mapTriggers(actions, convert);
+}
+function mapPageActions(actions, convert) {
+	return mapTriggers(actions, convert);
+}
+function mapFieldActions(actions, convert) {
+	return mapTriggers(actions, convert);
+}
+function mapDocumentActions(snapshot, convert) {
+	const { nameTreeScripts, openAction, openDestination, ...triggers } = snapshot;
+	return {
+		...mapTriggers(triggers, convert),
+		nameTreeScripts: nameTreeScripts.map((script) => ({
+			...script,
+			action: mapActionTree(script.action, convert)
+		})),
+		openAction: openAction ? mapActionTree(openAction, convert) : null,
+		..."openDestination" in snapshot ? { openDestination: openDestination ? convert(openDestination) : openDestination } : {}
+	};
+}
+//#endregion
+//#region src/pageSpace/measure.ts
+const withOrigin = (measure, convert) => measure.subtype === "rectilinear" && measure.origin ? {
+	...measure,
+	origin: convert(measure.origin)
+} : measure;
+/** A scale in page space: its origin (`/O`) is a place on the page. */
+function pageMeasureOf(measure, visible) {
+	return withOrigin(measure, (origin) => pagePointOf(origin, visible));
+}
+/** A page-space scale in the file's coordinates. */
+function pdfMeasureOf(measure, visible) {
+	return withOrigin(measure, (origin) => pdfPointOf(origin, visible));
+}
+/** A page's measurement viewports in page space. */
+function pageViewportsOf(viewports, visible) {
+	return viewports.map((viewport) => ({
+		...viewport,
+		bbox: pageBoxOf(viewport.bbox, visible),
+		measure: viewport.measure ? pageMeasureOf(viewport.measure, visible) : null
+	}));
+}
+//#endregion
+//#region src/pageSpace/annotations.ts
+const TO_PAGE = {
+	length: (value) => value,
+	point: (point, { visible }) => pagePointOf(point, visible),
+	points: (points, { visible }) => points.map((point) => pagePointOf(point, visible)),
+	strokes: (strokes, { visible }) => strokes.map((stroke) => stroke.map((point) => pagePointOf(point, visible))),
+	box: (rect, { visible }) => pageBoxOf(rect, visible),
+	quads: (quads, { visible }) => quads.map((quad) => pageQuadOf(quad, visible)),
+	linePoints: (line, { visible }) => ({
+		start: pagePointOf(line.start, visible),
+		end: pagePointOf(line.end, visible)
+	}),
+	calloutLine: (points, { visible }) => points.map((point) => pagePointOf(point, visible)),
+	measure: (measure, { visible }) => pageMeasureOf(measure, visible),
+	linkTarget: (target, { boxOf }) => mapLinkTarget(target, (destination) => pageDestinationOf(destination, boxOf)),
+	actions: (actions, { boxOf }) => mapTriggerActions(actions, (destination) => pageDestinationOf(destination, boxOf))
+};
+const TO_PDF = {
+	length: (value) => value,
+	point: (point, { visible }) => pdfPointOf(point, visible),
+	points: (points, { visible }) => points.map((point) => pdfPointOf(point, visible)),
+	strokes: (strokes, { visible }) => strokes.map((stroke) => stroke.map((point) => pdfPointOf(point, visible))),
+	box: (box, { visible }) => pdfRectOf(box, visible),
+	quads: (quads, { visible }) => quads.map((quad) => pdfQuadOf(quad, visible)),
+	linePoints: (line, { visible }) => ({
+		start: pdfPointOf(line.start, visible),
+		end: pdfPointOf(line.end, visible)
+	}),
+	calloutLine: (points, { visible }) => points.map((point) => pdfPointOf(point, visible)),
+	measure: (measure, { visible }) => pdfMeasureOf(measure, visible),
+	linkTarget: (target, { boxOf }) => mapLinkTarget(target, (destination) => pdfDestinationOf(destination, boxOf)),
+	actions: (actions, { boxOf }) => mapTriggerActions(actions, (destination) => pdfDestinationOf(destination, boxOf))
+};
+/**
+* The measured fields of a kind; a kind the engine doesn't know has the base
+* fields. An update may leave out its kind: a field's name says what it
+* holds, the same in every kind.
+*/
+const spacesOf = (subtype) => subtype === void 0 ? ANNOTATION_FIELD_SPACES_BY_NAME : ANNOTATION_FIELD_SPACES[subtype] ?? ANNOTATION_FIELD_SPACES.unsupported;
+function convertFields(subtype, value, frame, converters) {
+	const spaces = spacesOf(subtype);
+	return Object.fromEntries(Object.entries(value).map(([name, field]) => {
+		const space = spaces[name];
+		if (!space || field == null) return [name, field];
+		const converted = converters[space](field, frame);
+		if (converters === TO_PDF && hasNaN(converted)) throw notInPageSpace(name, space);
+		return [name, converted];
+	}));
+}
+/** Whether a converted value has a number that isn't one: a place not given in page space. */
+function hasNaN(value) {
+	if (typeof value === "number") return Number.isNaN(value);
+	if (typeof value !== "object" || value === null) return false;
+	return Object.values(value).some(hasNaN);
+}
+function notInPageSpace(name, space) {
+	const shape = space === "box" ? "{ x, y, width, height }" : "points as { x, y }";
+	return new EngineError(EngineErrorCode.InvalidArg, `field '${name}': expected page space, ${shape} from the page's top-left`, { details: { field: name } });
+}
+/** A read in page space. `visible` is its page's visible box, in the file's coordinates. */
+function pageAnnotationOf(annotation, visible, boxOf) {
+	return convertFields(annotation.subtype, annotation, {
+		visible,
+		boxOf
+	}, TO_PAGE);
+}
+/** A page-space read in the file's coordinates. */
+function pdfAnnotationOf(annotation, visible, boxOf) {
+	return convertFields(annotation.subtype, annotation, {
+		visible,
+		boxOf
+	}, TO_PDF);
+}
+/** A page-space create in the file's coordinates. */
+function pdfAnnotationDraftOf(draft, visible, boxOf) {
+	return convertFields(draft.subtype, draft, {
+		visible,
+		boxOf
+	}, TO_PDF);
+}
+/** A create in the file's coordinates, in page space. */
+function pageAnnotationDraftOf(draft, visible, boxOf) {
+	return convertFields(draft.subtype, draft, {
+		visible,
+		boxOf
+	}, TO_PAGE);
+}
+/**
+* A page-space update in the file's coordinates. An update may leave out its
+* `subtype`; its fields' names say what they hold.
+*/
+function pdfAnnotationPatchOf(patch, visible, boxOf) {
+	return convertFields(patch.subtype, patch, {
+		visible,
+		boxOf
+	}, TO_PDF);
+}
+/** An update in the file's coordinates, in page space. */
+function pageAnnotationPatchOf(patch, visible, boxOf) {
+	return convertFields(patch.subtype, patch, {
+		visible,
+		boxOf
+	}, TO_PAGE);
+}
+//#endregion
+//#region src/text/layout.ts
+/**
+* The canonical text-interaction layout — the one place glyph geometry
+* becomes hit targets, word/line ranges, and visual-line segments.
+*
+* Selection owns gestures and state; search owns matching and cursors;
+* neither owns segmentation. Both consume this module, so a text range has
+* exactly one canonical segmentation regardless of how it was produced.
+*
+* Everything here works in the file's coordinates (y up), as the engine reads
+* them. The public layout (`createTextLayout`, `pageSpace/text.ts`) runs this
+* one on page-space geometry flipped top to bottom and flips its answers
+* back. The line-merge is adapted from Chromium's
+* pdf/pdfium/pdfium_range.cc `MergeAdjacentRects` (BSD-licensed, Copyright
+* 2010 The Chromium Authors); hit-testing mirrors PDFium `GetIndexAtPos`
+* (exact tight box first, then a tolerance pass).
+*
+* Orientation model — frames. Every run belongs to a frame: frame 0 is page
+* space itself (all upright runs — the dominant case takes a byte-identical
+* fast path), and each rotated orientation cluster gets an orthonormal frame
+* in which its text reads upright (baseline +x, ascent +y). Frames are
+* derived from the semantic edges of the first classifiable glyph's quad —
+* never from advisory wire fields — and keyed by (baseline direction,
+* ascent handedness):
+*
+*   - Rotated and mirrored text become upright inside their frame.
+*   - Shear (fake italic) is deliberately not part of the frame key or the
+*     basis: a sheared run shares the frame of its unsheared neighbours, so
+*     a mixed roman/italic line merges into one segment (Acrobat parity),
+*     and the shear is absorbed as a small in-frame AABB residue. This is
+*     the deterministic, order-independent contract — an affine
+*     (shear-preserving) basis would either fragment mixed lines or make
+*     the roman body's geometry depend on whether an italic run came first.
+*   - Runs of different frames never merge into one line.
+*
+* All algorithms run on frame-local boxes; every participating run of a
+* cluster is transformed through the same frame, so merged coordinates are
+* always commensurable. Only the output maps back to page space, as
+* oriented quads.
+*/
+/** A space or a character with no box ends a word. */
+const isBoundary = (g) => !!(g.space || g.empty);
+const isEmpty = (g) => !!g.empty;
+const CHAR_DISTANCE_FACTOR = 2.5;
+const FONT_SIZE_RATIO_THRESHOLD = 1.5;
+const VERTICAL_OVERLAP_THRESHOLD = .8;
+const LINE_OVERLAP_THRESHOLD = .5;
+/** Baseline directions within ~0.5° share a frame. */
+const FRAME_DOT_TOLERANCE = Math.cos(.0087);
+const EDGE_EPSILON = 1e-6;
+/**
+* The layout of a page's geometry in the file's coordinates, for the engine's
+* own readers. Everything else uses `createTextLayout`, in page space.
+*/
+function createPdfTextLayout(snapshot) {
+	const layout = buildPageTextLayout(snapshot);
+	const charCount = layout.glyphs.length;
+	const indexOf = (at) => {
+		if (typeof at !== "number") return textGlyphAt(layout, at);
+		return Number.isInteger(at) && at >= 0 && at < charCount ? at : null;
+	};
+	const rangeOf = ([from, to]) => ({
+		start: from,
+		count: to - from + 1
+	});
+	return {
+		charCount,
+		runs: snapshot.runs,
+		charAt: (point) => textGlyphAt(layout, point),
+		wordAt: (at) => {
+			const index = indexOf(at);
+			return index === null ? null : rangeOf(expandTextRangeToWord(layout, index));
+		},
+		lineAt: (at) => {
+			const index = indexOf(at);
+			return index === null ? null : rangeOf(expandTextRangeToLine(layout, index));
+		},
+		segments: (range) => textSegmentsForRange(layout, range.start, range.count),
+		charQuad: (index) => textGlyphQuad(layout, index)
+	};
+}
+const IDENTITY_FRAME = {
+	baseline: {
+		x: 1,
+		y: 0
+	},
+	ascent: {
+		x: 0,
+		y: 1
+	}
+};
+const toFrame = (f, p) => ({
+	x: p.x * f.baseline.x + p.y * f.baseline.y,
+	y: p.x * f.ascent.x + p.y * f.ascent.y
+});
+const fromFrame = (f, p) => ({
+	x: f.baseline.x * p.x + f.ascent.x * p.y,
+	y: f.baseline.y * p.x + f.ascent.y * p.y
+});
+const ZERO_RECT = {
+	left: 0,
+	bottom: 0,
+	right: 0,
+	top: 0
+};
+/** Frame-local AABB of a page-space cell (exact under the frame's rotation;
+*  shear residue is the documented in-frame envelope). */
+function frameBoxOfQuad(f, q) {
+	const pts = [
+		q.upperLeft,
+		q.upperRight,
+		q.lowerLeft,
+		q.lowerRight
+	].map((p) => toFrame(f, p));
+	const xs = pts.map((p) => p.x);
+	const ys = pts.map((p) => p.y);
+	return {
+		left: Math.min(...xs),
+		bottom: Math.min(...ys),
+		right: Math.max(...xs),
+		top: Math.max(...ys)
+	};
+}
+/** Find-or-create the frame for a rotated run, keyed by the baseline
+*  direction + ascent handedness of its first classifiable glyph's edges. */
+function frameForRun(frames, run) {
+	const seed = run.glyphs.find((g) => !isEmpty(g));
+	if (!seed) return 0;
+	const q = seed.loose;
+	const bx = q.upperRight.x - q.upperLeft.x;
+	const by = q.upperRight.y - q.upperLeft.y;
+	const len = Math.hypot(bx, by);
+	if (len <= EDGE_EPSILON) return 0;
+	const baseline = {
+		x: bx / len,
+		y: by / len
+	};
+	const ax = q.upperLeft.x - q.lowerLeft.x;
+	const ay = q.upperLeft.y - q.lowerLeft.y;
+	const sign = baseline.x * ay - baseline.y * ax >= 0 ? 1 : -1;
+	const ascent = {
+		x: -baseline.y * sign,
+		y: baseline.x * sign
+	};
+	for (let i = 0; i < frames.length; i++) {
+		const f = frames[i];
+		const dot = f.baseline.x * baseline.x + f.baseline.y * baseline.y;
+		const sameHandedness = f.ascent.x * ascent.x + f.ascent.y * ascent.y > 0;
+		if (dot >= FRAME_DOT_TOLERANCE && sameHandedness) return i;
+	}
+	frames.push({
+		baseline,
+		ascent
+	});
+	return frames.length - 1;
+}
+/**
+* Flatten a page's geometry snapshot into the canonical layout. Upright runs
+* copy their wire boxes verbatim (frame 0, wire run rects included); rotated
+* runs project their glyph cells into their cluster's frame.
+*/
+function buildPageTextLayout(snapshot) {
+	const glyphs = [];
+	const runs = [];
+	const frames = [IDENTITY_FRAME];
+	for (const run of snapshot.runs) {
+		if (!isRotatedGeometryRun(run)) {
+			for (const g of run.glyphs) glyphs.push({
+				loose: g.loose,
+				tight: g.tight,
+				space: g.space,
+				empty: g.empty
+			});
+			runs.push({
+				start: run.start,
+				count: run.glyphs.length,
+				rect: run.rect,
+				fontSize: run.fontSize,
+				frame: 0
+			});
+			continue;
+		}
+		const frame = frameForRun(frames, run);
+		const f = frames[frame];
+		let runBox = null;
+		for (const g of run.glyphs) {
+			if (isEmpty(g)) {
+				glyphs.push({
+					loose: ZERO_RECT,
+					space: g.space,
+					empty: true
+				});
+				continue;
+			}
+			const loose = frameBoxOfQuad(f, g.loose);
+			const tight = g.tight ? frameBoxOfQuad(f, g.tight) : void 0;
+			glyphs.push({
+				loose,
+				tight,
+				space: g.space
+			});
+			runBox = runBox ? {
+				left: Math.min(runBox.left, loose.left),
+				bottom: Math.min(runBox.bottom, loose.bottom),
+				right: Math.max(runBox.right, loose.right),
+				top: Math.max(runBox.top, loose.top)
+			} : loose;
+		}
+		runs.push({
+			start: run.start,
+			count: run.glyphs.length,
+			rect: runBox ?? ZERO_RECT,
+			fontSize: run.fontSize,
+			frame
+		});
+	}
+	return {
+		glyphs,
+		runs,
+		frames
+	};
+}
+const inRect = (r, p) => p.x >= r.left && p.x <= r.right && p.y >= r.bottom && p.y <= r.top;
+function avgGlyphHeight(layout) {
+	let total = 0;
+	let count = 0;
+	for (const g of layout.glyphs) {
+		if (isEmpty(g)) continue;
+		total += g.loose.top - g.loose.bottom;
+		count++;
+	}
+	return count === 0 ? 0 : total / count;
+}
+/** The point expressed in every frame (index-aligned with `layout.frames`).
+*  Frame 0 returns the point itself — no float round-trip on the fast path. */
+function pointPerFrame(layout, p) {
+	return layout.frames.map((f, i) => i === 0 ? p : toFrame(f, p));
+}
+/**
+* The glyph (char) index at a page-space point, or null when nothing is near
+* (so callers can show the pointer cursor off-text). PDFium `GetIndexAtPos`:
+* exact tight-box containment first, then a tolerance pass (closest by
+* Manhattan distance within `toleranceFactor × average glyph height`). Each
+* run tests the point in its own frame, so rotated text hit-tests exactly.
+*/
+function textGlyphAt(layout, point, toleranceFactor = 1.5) {
+	const pts = pointPerFrame(layout, point);
+	for (const run of layout.runs) {
+		const q = pts[run.frame];
+		if (!inRect(run.rect, q)) continue;
+		for (let i = 0; i < run.count; i++) {
+			const g = layout.glyphs[run.start + i];
+			if (inRect(g.tight ?? g.loose, q)) return run.start + i;
+		}
+	}
+	if (toleranceFactor <= 0) return null;
+	const half = avgGlyphHeight(layout) * toleranceFactor / 2;
+	let best = -1;
+	let bestDist = Infinity;
+	for (const run of layout.runs) {
+		const q = pts[run.frame];
+		const r = run.rect;
+		if (q.x < r.left - half || q.x > r.right + half || q.y < r.bottom - half || q.y > r.top + half) continue;
+		for (let i = 0; i < run.count; i++) {
+			const g = layout.glyphs[run.start + i];
+			if (isEmpty(g)) continue;
+			const b = g.tight ?? g.loose;
+			if (q.x < b.left - half || q.x > b.right + half || q.y < b.bottom - half || q.y > b.top + half) continue;
+			const dx = Math.min(Math.abs(q.x - b.left), Math.abs(q.x - b.right));
+			const dy = Math.min(Math.abs(q.y - b.bottom), Math.abs(q.y - b.top));
+			if (dx + dy < bestDist - EDGE_EPSILON) {
+				bestDist = dx + dy;
+				best = run.start + i;
+			}
+		}
+	}
+	return best >= 0 ? best : null;
+}
+/** Double-click: the word around `glyph` (walk to space/empty glyphs both ways). */
+function expandTextRangeToWord(layout, glyph) {
+	const n = layout.glyphs.length;
+	if (glyph < 0 || glyph >= n) return [glyph, glyph];
+	let from = glyph;
+	while (from > 0 && !isBoundary(layout.glyphs[from - 1])) from--;
+	let to = glyph;
+	while (to < n - 1 && !isBoundary(layout.glyphs[to + 1])) to++;
+	return [from, to];
+}
+/** Triple-click: the full visual line — same-frame runs whose vertical extent
+*  overlaps the anchor run's. A differently-oriented run is a line boundary. */
+function expandTextRangeToLine(layout, glyph) {
+	const ri = layout.runs.findIndex((r) => glyph >= r.start && glyph < r.start + r.count);
+	if (ri < 0) return [glyph, glyph];
+	const anchor = layout.runs[ri];
+	const bottom = anchor.rect.bottom;
+	const top = anchor.rect.top;
+	let from = anchor.start;
+	let to = anchor.start + anchor.count - 1;
+	for (let r = ri - 1; r >= 0; r--) {
+		const run = layout.runs[r];
+		if (isZero(run.rect)) continue;
+		if (run.frame !== anchor.frame) break;
+		if (!overlapV(run.rect.bottom, run.rect.top, bottom, top)) break;
+		from = run.start;
+	}
+	for (let r = ri + 1; r < layout.runs.length; r++) {
+		const run = layout.runs[r];
+		if (isZero(run.rect)) continue;
+		if (run.frame !== anchor.frame) break;
+		if (!overlapV(run.rect.bottom, run.rect.top, bottom, top)) break;
+		to = run.start + run.count - 1;
+	}
+	return [from, to];
+}
+/**
+* A single glyph's oriented cell in page space, or null for degenerate
+* glyphs — the anchor for caret placement at a selection boundary.
+*/
+function textGlyphQuad(layout, glyph) {
+	const g = layout.glyphs[glyph];
+	if (!g || isEmpty(g)) return null;
+	const b = g.loose;
+	if (b.right <= b.left || b.top <= b.bottom) return null;
+	const run = layout.runs.find((r) => glyph >= r.start && glyph < r.start + r.count);
+	const f = layout.frames[run?.frame ?? 0];
+	return quadOfFrameRect(f, run?.frame ?? 0, b);
+}
+/**
+* Merged visual-line segments for the half-open char range
+* `[start, start + count)` — the canonical segmentation. Chars
+* outside the layout are ignored.
+*/
+function textSegmentsForRange(layout, start, count) {
+	if (count <= 0 || layout.glyphs.length === 0) return [];
+	const lo = Math.max(0, start);
+	const hi = Math.min(layout.glyphs.length - 1, start + count - 1);
+	if (hi < lo) return [];
+	const subRuns = [];
+	for (const run of layout.runs) {
+		const runEnd = run.start + run.count - 1;
+		if (runEnd < lo || run.start > hi) continue;
+		const s = Math.max(lo, run.start);
+		const e = Math.min(hi, runEnd);
+		let left = Infinity;
+		let right = -Infinity;
+		let bottom = Infinity;
+		let top = -Infinity;
+		let charCountAcc = 0;
+		let widthSum = 0;
+		let prevRight = -Infinity;
+		let firstX = 0;
+		let lastX = 0;
+		const flush = () => {
+			if (charCountAcc > 0 && left !== Infinity) subRuns.push({
+				rect: {
+					left,
+					bottom,
+					right,
+					top
+				},
+				charCount: charCountAcc,
+				fontSize: run.fontSize,
+				frame: run.frame,
+				firstX,
+				lastX
+			});
+			left = Infinity;
+			right = -Infinity;
+			bottom = Infinity;
+			top = -Infinity;
+			charCountAcc = 0;
+			widthSum = 0;
+			prevRight = -Infinity;
+		};
+		for (let ci = s; ci <= e; ci++) {
+			const g = layout.glyphs[ci];
+			if (isEmpty(g)) continue;
+			const b = g.loose;
+			if (charCountAcc > 0 && prevRight > -Infinity) {
+				const avg = widthSum / charCountAcc;
+				if (avg > 0 && Math.abs(b.left - prevRight) > CHAR_DISTANCE_FACTOR * avg) flush();
+			}
+			const centerX = (b.left + b.right) / 2;
+			if (charCountAcc === 0) firstX = centerX;
+			lastX = centerX;
+			left = Math.min(left, b.left);
+			right = Math.max(right, b.right);
+			bottom = Math.min(bottom, b.bottom);
+			top = Math.max(top, b.top);
+			charCountAcc++;
+			widthSum += b.right - b.left;
+			prevRight = b.right;
+		}
+		flush();
+	}
+	return mergeAdjacentSubRuns(subRuns).map((m) => materializeSegment(layout, m));
+}
+function mergeAdjacentSubRuns(runs) {
+	const out = [];
+	let prev = null;
+	let cur = null;
+	for (const run of runs) {
+		if (prev && cur && prev.frame === run.frame && shouldMerge(prev, run)) cur = {
+			rect: {
+				left: Math.min(cur.rect.left, run.rect.left),
+				bottom: Math.min(cur.rect.bottom, run.rect.bottom),
+				right: Math.max(cur.rect.right, run.rect.right),
+				top: Math.max(cur.rect.top, run.rect.top)
+			},
+			frame: cur.frame,
+			firstX: cur.firstX,
+			lastX: run.lastX
+		};
+		else {
+			if (cur) out.push(cur);
+			cur = {
+				rect: run.rect,
+				frame: run.frame,
+				firstX: run.firstX,
+				lastX: run.lastX
+			};
+		}
+		prev = run;
+	}
+	if (cur && cur.rect.right > cur.rect.left && cur.rect.top > cur.rect.bottom) out.push(cur);
+	return out;
+}
+/** Segment quad for a frame-local rect (frame 0: the rect's own corners,
+*  no float round-trip). The frame is y-up, so the upper corners sit at the
+*  frame top. */
+function quadOfFrameRect(f, frameIndex, r) {
+	if (frameIndex === 0) return {
+		upperLeft: {
+			x: r.left,
+			y: r.top
+		},
+		upperRight: {
+			x: r.right,
+			y: r.top
+		},
+		lowerLeft: {
+			x: r.left,
+			y: r.bottom
+		},
+		lowerRight: {
+			x: r.right,
+			y: r.bottom
+		}
+	};
+	return {
+		upperLeft: fromFrame(f, {
+			x: r.left,
+			y: r.top
+		}),
+		upperRight: fromFrame(f, {
+			x: r.right,
+			y: r.top
+		}),
+		lowerLeft: fromFrame(f, {
+			x: r.left,
+			y: r.bottom
+		}),
+		lowerRight: fromFrame(f, {
+			x: r.right,
+			y: r.bottom
+		})
+	};
+}
+function materializeSegment(layout, m) {
+	const frame = layout.frames[m.frame];
+	const quad = quadOfFrameRect(frame, m.frame, m.rect);
+	return {
+		quad,
+		rect: m.frame === 0 ? m.rect : {
+			left: Math.min(quad.upperLeft.x, quad.upperRight.x, quad.lowerLeft.x, quad.lowerRight.x),
+			bottom: Math.min(quad.upperLeft.y, quad.upperRight.y, quad.lowerLeft.y, quad.lowerRight.y),
+			right: Math.max(quad.upperLeft.x, quad.upperRight.x, quad.lowerLeft.x, quad.lowerRight.x),
+			top: Math.max(quad.upperLeft.y, quad.upperRight.y, quad.lowerLeft.y, quad.lowerRight.y)
+		},
+		advance: m.lastX >= m.firstX ? 1 : -1
+	};
+}
+function shouldMerge(a, b) {
+	if (a.fontSize != null && b.fontSize != null && a.fontSize > 0 && b.fontSize > 0) {
+		if (Math.max(a.fontSize, b.fontSize) / Math.min(a.fontSize, b.fontSize) > FONT_SIZE_RATIO_THRESHOLD) return false;
+	}
+	if (verticalOverlap(a.rect, b.rect) < VERTICAL_OVERLAP_THRESHOLD) return false;
+	const aw = (a.rect.right - a.rect.left) / a.charCount;
+	const bw = (b.rect.right - b.rect.left) / b.charCount;
+	const aL = a.rect.left - aw;
+	const aR = a.rect.right + aw;
+	const bL = b.rect.left - bw;
+	return aL < b.rect.right + bw && aR > bL;
+}
+function verticalOverlap(a, b) {
+	const ah = a.top - a.bottom;
+	const bh = b.top - b.bottom;
+	if (ah <= 0 || bh <= 0) return 0;
+	const u = Math.max(a.top, b.top) - Math.min(a.bottom, b.bottom);
+	if (u === ah || u === bh) return 1;
+	return Math.max(0, Math.min(a.top, b.top) - Math.max(a.bottom, b.bottom)) / u;
+}
+const isZero = (r) => r.right === r.left && r.top === r.bottom;
+function overlapV(bottom1, top1, bottom2, top2) {
+	const u = Math.max(top1, top2) - Math.min(bottom1, bottom2);
+	if (u === 0) return false;
+	return Math.max(0, Math.min(top1, top2) - Math.max(bottom1, bottom2)) / u >= LINE_OVERLAP_THRESHOLD;
+}
+//#endregion
+//#region src/pageSpace/text.ts
+/**
+* A character with no box of its own (`empty`) carries a zeroed box or quad
+* that says so, in either space, and so does a run of nothing but such
+* characters; it is not a place, so it never converts.
+*/
+const NO_BOX$1 = {
+	x: 0,
+	y: 0,
+	width: 0,
+	height: 0
+};
+const NO_RECT = {
+	left: 0,
+	bottom: 0,
+	right: 0,
+	top: 0
+};
+const NO_QUAD = {
+	upperLeft: {
+		x: 0,
+		y: 0
+	},
+	upperRight: {
+		x: 0,
+		y: 0
+	},
+	lowerLeft: {
+		x: 0,
+		y: 0
+	},
+	lowerRight: {
+		x: 0,
+		y: 0
+	}
+};
+/** Whether a run has a character with a box of its own. */
+const hasBox = (run) => run.glyphs.some((glyph) => !glyph.empty);
+/** A page's text geometry in page space. `visible` is the page's visible box. */
+function pageGeometryOf(snapshot, visible) {
+	return {
+		...snapshot,
+		runs: snapshot.runs.map((run) => {
+			const rect = hasBox(run) ? pageBoxOf(run.rect, visible) : NO_BOX$1;
+			if (isRotatedGeometryRun(run)) return {
+				...run,
+				rect,
+				glyphs: run.glyphs.map(({ loose, tight, ...glyph }) => ({
+					...glyph,
+					loose: glyph.empty ? NO_QUAD : pageQuadOf(loose, visible),
+					...tight ? { tight: pageQuadOf(tight, visible) } : {}
+				}))
+			};
+			return {
+				...run,
+				rect,
+				glyphs: run.glyphs.map(({ loose, tight, ...glyph }) => ({
+					...glyph,
+					loose: glyph.empty ? NO_BOX$1 : pageBoxOf(loose, visible),
+					...tight ? { tight: pageBoxOf(tight, visible) } : {}
+				}))
+			};
+		})
+	};
+}
+/** A page-space run flipped top to bottom, for the y-up math of the text layout and its helpers. */
+function mirroredRun(run) {
+	const rect = hasBox(run) ? mirroredRect(run.rect) : NO_RECT;
+	if (isRotatedGeometryRun(run)) return {
+		...run,
+		rect,
+		glyphs: run.glyphs.map(({ loose, tight, ...glyph }) => ({
+			...glyph,
+			loose: glyph.empty ? NO_QUAD : mirroredQuad(loose),
+			...tight ? { tight: mirroredQuad(tight) } : {}
+		}))
+	};
+	return {
+		...run,
+		rect,
+		glyphs: run.glyphs.map(({ loose, tight, ...glyph }) => ({
+			...glyph,
+			loose: glyph.empty ? NO_RECT : mirroredRect(loose),
+			...tight ? { tight: mirroredRect(tight) } : {}
+		}))
+	};
+}
+function pageTextSegmentOf(segment, visible) {
+	return {
+		...segment,
+		quad: pageQuadOf(segment.quad, visible),
+		rect: pageBoxOf(segment.rect, visible)
+	};
+}
+/** A search batch in page space: each match measured on its own page. */
+function pageSearchSliceOf(slice, boxOf) {
+	return {
+		...slice,
+		matches: slice.matches.map((match) => {
+			const visible = boxOf(match.page);
+			return {
+				...match,
+				segments: match.segments.map((segment) => pageTextSegmentOf(segment, visible))
+			};
+		})
+	};
+}
+/**
+* The layout of a page's text geometry in page space. It runs the same
+* layout as the file's coordinates do, on the geometry flipped top to bottom,
+* and flips each answer back: the flip is exact and the layout doesn't depend
+* on where the origin is.
+*/
+function createTextLayout(snapshot) {
+	const layout = createPdfTextLayout({
+		...snapshot,
+		runs: snapshot.runs.map(mirroredRun)
+	});
+	const at = (value) => typeof value === "number" ? value : mirroredPoint(value);
+	return {
+		charCount: layout.charCount,
+		runs: snapshot.runs,
+		charAt: (point) => layout.charAt(mirroredPoint(point)),
+		wordAt: (value) => layout.wordAt(at(value)),
+		lineAt: (value) => layout.lineAt(at(value)),
+		segments: (range) => layout.segments(range).map((segment) => ({
+			...segment,
+			quad: unmirroredQuad(segment.quad),
+			rect: unmirroredBox(segment.rect)
+		})),
+		charQuad: (index) => {
+			const quad = layout.charQuad(index);
+			return quad ? unmirroredQuad(quad) : null;
+		}
+	};
+}
+//#endregion
+//#region src/annotation/drawnPoints.ts
+/**
+* The points of a line, polyline, polygon or ink as the page shows them: the
+* upright points a read gives, turned by `rotation` about the middle of their
+* box. One list for a line (its two ends) or a polygon, one per ink stroke;
+* `null` for any other kind.
+*/
+function pdfDrawnPointsOf(annotation) {
+	let sets;
+	switch (annotation.subtype) {
+		case "line":
+			sets = [[annotation.linePoints.start, annotation.linePoints.end]];
+			break;
+		case "polyline":
+		case "polygon":
+			sets = [annotation.vertices];
+			break;
+		case "ink":
+			sets = annotation.inkList.map((stroke) => [...stroke]);
+			break;
+		default: return null;
+	}
+	if (!annotation.rotation) return sets.map((set) => set.map((point) => ({ ...point })));
+	const turn = pdfTurnOfUpright(sets.flat(), annotation.rotation);
+	return sets.map((set) => set.map((point) => pdfPointTurned(point, turn)));
+}
+//#endregion
+//#region src/annotation/resolve/annotationOfDraft.ts
+const NO_BOX = {
+	x: 0,
+	y: 0,
+	width: 0,
+	height: 0
+};
+/**
+* A free text's rich text as a read spells it, and the text style it reads
+* back with: the resolved body over the engine's defaults, and its size,
+* text color and alignment beside it. The font keeps the name the draft
+* gave, or the default.
+*/
+function freeTextReadOf(given, read) {
+	const richText = given.richText;
+	const body = {
+		...DEFAULT_RICH_TEXT_BODY,
+		...richText?.body
+	};
+	body.color = body.color.toLowerCase();
+	read.richText = {
+		...read.richText,
+		body
+	};
+	read.fontSize = body.size;
+	read.fontColor = body.color;
+	read.textAlign = body.align;
+}
+/**
+* The annotation a resolved draft creates, as a read spells it: the draft's
+* data fields, the kind's defaults for those it leaves out, and what
+* `context` says for the fields the engine owns or stamps. Works in either
+* space: it only moves values by field name.
+*/
+function annotationOfResolvedDraft(resolved, context) {
+	const subtype = resolved.subtype;
+	const owners = kindFactsOf(subtype)?.owners ?? {};
+	const defaults = annotationDefaultsOf(subtype);
+	const given = resolved;
+	const read = { subtype };
+	for (const [name, owner] of Object.entries(owners)) if (owner === "data" && given[name] !== void 0) read[name] = readValueOf(name, given[name], void 0);
+	else if (owner === "data") read[name] = defaults[name] ?? null;
+	else if (owner === "attribution") read[name] = context.attribution?.[name] ?? null;
+	else read[name] = null;
+	if (read.nm === null && context.nm !== void 0) read.nm = context.nm;
+	read.ref = context.ref;
+	read.page = context.ref.page;
+	read.hasAppearance = !UNBAKED_KINDS.has(subtype);
+	if (read.rect === null) read.rect = context.rect ?? given.rect ?? given.box ?? NO_BOX;
+	if (subtype === "free-text") freeTextReadOf(given, read);
+	if (subtype === "link") {
+		const target = given.target;
+		read.actions = target && (target.kind === "uri" || target.kind === "goto") ? { activate: actionTreeOf(target) } : null;
+	}
+	if (subtype === "widget") read.fieldFamily = "unknown";
+	return read;
+}
+//#endregion
+//#region src/pageSpace/helpers.ts
+/**
+* The engine's geometry helpers, for page-space values. Each flips its
+* values top to bottom, runs the helper written for the file's coordinates
+* (y up), and flips the answer back: exact, and needing no page box, since
+* none of that math depends on where the origin is.
+*/
+const mirroredTurn = (turn) => ({
+	degrees: turn.degrees,
+	center: mirroredPoint(turn.center)
+});
+const unmirroredTurn = (turn) => ({
+	degrees: turn.degrees,
+	center: unmirroredPoint(turn.center)
+});
+/** The box around `points`; a zero box at the origin when there are none. */
+const pagePointsBounds = (points) => unmirroredBox(pdfPointsBounds(points.map(mirroredPoint)));
+/** `point` turned by `turn`; a negative angle turns it back. */
+const pagePointTurned = (point, turn) => unmirroredPoint(pdfPointTurned(mirroredPoint(point), mirroredTurn(turn)));
+/** `point` turned back by `turn`. */
+const pagePointUnturned = (point, turn) => unmirroredPoint(pdfPointUnturned(mirroredPoint(point), mirroredTurn(turn)));
+/** The turn that draws upright `points`: `degrees` about the middle of their box. */
+const pageTurnOfUpright = (points, degrees) => unmirroredTurn(pdfTurnOfUpright(points.map(mirroredPoint), degrees));
+/** The turn drawn `points` were made with: `degrees` about the middle of their upright box. */
+const pageTurnOfDrawn = (points, degrees) => unmirroredTurn(pdfTurnOfDrawn(points.map(mirroredPoint), degrees));
+/** The upright box around a quad, whatever its turn or skew. */
+const pageQuadBounds = (quad) => unmirroredBox(pdfQuadBounds(mirroredQuad(quad)));
+/** A glyph's loose cell as a quad. */
+const pageGlyphLooseQuad = (run, index) => unmirroredQuad(glyphLooseQuad(mirroredRun(run), index));
+/** A glyph's loose cell as an upright box. */
+const pageGlyphLooseBounds = (run, index) => unmirroredBox(glyphLooseBounds(mirroredRun(run), index));
+/**
+* The points of a line, polyline, polygon or ink as the page shows them: the
+* upright points a read gives, turned by `rotation` about the middle of their
+* box. One list for a line (its two ends) or a polygon, one per ink stroke;
+* `null` for any other kind.
+*/
+function drawnPointsOf(annotation) {
+	const flip = (points) => points.map(mirroredPoint);
+	let mirrored;
+	switch (annotation.subtype) {
+		case "line":
+			mirrored = {
+				subtype: "line",
+				rotation: annotation.rotation,
+				linePoints: {
+					start: mirroredPoint(annotation.linePoints.start),
+					end: mirroredPoint(annotation.linePoints.end)
+				}
+			};
+			break;
+		case "polyline":
+		case "polygon":
+			mirrored = {
+				subtype: annotation.subtype,
+				rotation: annotation.rotation,
+				vertices: flip(annotation.vertices)
+			};
+			break;
+		case "ink":
+			mirrored = {
+				subtype: "ink",
+				rotation: annotation.rotation,
+				inkList: annotation.inkList.map(flip)
+			};
+			break;
+		default: return null;
+	}
+	const sets = pdfDrawnPointsOf(mirrored);
+	return sets && sets.map((set) => set.map(unmirroredPoint));
+}
+/**
+* The turn an annotation's appearance raster is drawn without, degrees
+* clockwise, or `null` when the raster is drawn as the page shows it. A box
+* kind drawn turned whose drawing stays inside the turned box (its `rect` is
+* the upright box around it) renders upright over its `box`, for the
+* consumer to turn about the middle of `box`: a new turn needs no new
+* raster. A callout (its line isn't turned) and a drawing that reaches past
+* its box (a cloudy border's bumps) render as the page shows them, placed by
+* `rect`.
+*/
+function appearanceTurnOf(annotation) {
+	return pdfAppearanceTurnOf({
+		...annotation,
+		rect: mirroredRect(annotation.rect),
+		box: annotation.box ? mirroredRect(annotation.box) : annotation.box
+	});
+}
+/** Page space with its origin as the file's: turning one into the other is the mirror. */
+const MIRROR = {
+	left: 0,
+	bottom: 0,
+	right: 0,
+	top: 0
+};
+/** Shape fields hold no destinations, so nothing asks for another page's box. */
+const noOtherPage = () => {
+	throw new Error("a shape field holds no destination");
+};
+/**
+* The shape fields that put `annotation` at `rect`, the rule an update's
+* `rect` follows (`create({ ...copy, ...shapeForRect(copy, target) })` puts a
+* copy there).
+*
+* - 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 shapeForRect(annotation, rect) {
+	if (!DRAWN_RECT_KINDS.has(annotation.subtype)) return { rect };
+	const read = annotation;
+	const placed = pdfShapeForRect(pdfAnnotationOf(Object.fromEntries([
+		"subtype",
+		"rect",
+		...shapeFieldsOf(annotation.subtype)
+	].filter((name) => read[name] !== void 0).map((name) => [name, read[name]])), MIRROR, noOtherPage), mirroredRect(rect));
+	const { subtype: _kind, ...fields } = pageAnnotationPatchOf({
+		subtype: annotation.subtype,
+		...placed
+	}, MIRROR, noOtherPage);
+	return fields;
+}
+/**
+* `patch` with its `rect` resolved as the engine resolves it on update (the
+* same step, `pdfResolveRectCommand`):
+*
+* - the rect the annotation reads, sent back, is dropped: nothing moves;
+* - on a drawn kind, another rect becomes the shape fields that put the
+*   drawing there (`shapeForRect`);
+* - a new rect with a changed shape field is refused (`InvalidArg` on
+*   `rect`): which of the two to follow would be a guess.
+*
+* A kind whose shape is its rect keeps it as a plain field. A viewer runs
+* this before it merges fields it writes itself, so a `rect` behaves the same
+* from every door. Values `patch` gives come back as given.
+*/
+function resolveRectCommand(annotation, patch) {
+	const given = patch;
+	if (given.rect === void 0 || !DRAWN_RECT_KINDS.has(annotation.subtype)) return patch;
+	const read = annotation;
+	const shapeNames = shapeFieldsOf(annotation.subtype);
+	const pick = (from, names) => Object.fromEntries(names.filter((name) => from[name] !== void 0).map((name) => [name, from[name]]));
+	const { subtype: _kind, ...placed } = pageAnnotationPatchOf(pdfResolveRectCommand(pdfAnnotationOf({
+		subtype: annotation.subtype,
+		...pick(read, ["rect", ...shapeNames])
+	}, MIRROR, noOtherPage), pdfAnnotationPatchOf({
+		subtype: annotation.subtype,
+		...pick(given, ["rect", ...shapeNames])
+	}, MIRROR, noOtherPage)), MIRROR, noOtherPage);
+	const { rect: _rect, ...rest } = given;
+	const out = { ...rest };
+	for (const [name, value] of Object.entries(placed)) out[name] = given[name] !== void 0 && semanticEqual(value, given[name]) ? given[name] : value;
+	return out;
+}
+/**
+* Every page's box is the mirror, so a link's destination makes the round
+* trip into the file's coordinates and back unchanged, with no real page.
+*/
+const mirrorEveryPage = () => MIRROR;
+/**
+* The patch the engine writes for `patch` on `current`, as a viewer predicts
+* it: its subtype filled in, and every field that follows from it stated. A
+* drawn kind's new `rect` becomes the shape fields that put it there, values
+* sent back as read are dropped, a note's standard review state brings its
+* state model, a free text's contents and rich text follow each other, a
+* callout's line stays attached to its moved box, and a measurement's label
+* follows its points and scale. Values `patch` gives come back as given.
+*
+* Throws `InvalidArg` for what the engine refuses without its schemas: 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. The engine
+* checks the values against the kind's schema when the update reaches it,
+* and refuses there what this lets through.
+*/
+function resolveAnnotationPatch(current, patch, options = {}) {
+	const back = pageAnnotationPatchOf(pdfPredictAnnotationPatch(pdfAnnotationOf(current, MIRROR, mirrorEveryPage), pdfAnnotationPatchOf({
+		...patch,
+		subtype: patch.subtype ?? current.subtype
+	}, MIRROR, mirrorEveryPage), options), MIRROR, mirrorEveryPage);
+	const given = patch;
+	for (const name of Object.keys(back)) if (given[name] !== void 0 && semanticEqual(back[name], given[name])) back[name] = given[name];
+	return back;
+}
+/**
+* `current` as the engine will read it after `patch`: what a viewer shows
+* while the write is on its way. Fields the engine works out or stamps itself
+* (a drawn kind's `rect`, the modified date and author) keep their current
+* value until the engine's answer brings the new one. A field `patch` leaves
+* alone keeps its very value.
+*/
+function applyAnnotationPatch(current, patch, options = {}) {
+	return applyResolvedPatch(current, resolveAnnotationPatch(current, patch, options));
+}
+/**
+* The draft the engine writes for `draft`, as a viewer predicts it: every
+* field that follows from it stated. A box kind placed by its `rect` states
+* its `box`, a note's standard review state brings its state model, a free
+* text's rich text and contents follow each other, and a measurement's label
+* follows its points and scale. Fields left out stay out: the kind's
+* defaults (`ANNOTATION_DEFAULTS`) say what they read back. Values `draft`
+* gives come back as given.
+*
+* Throws `InvalidArg` for what the engine refuses without its schemas: a
+* field the kind doesn't declare, a box kind it can't place, and where
+* nothing can follow. The engine checks the values against the kind's schema
+* when the create reaches it, and refuses there what this lets through.
+*/
+function resolveAnnotationDraft(draft, options = {}) {
+	const back = pageAnnotationDraftOf(pdfPredictAnnotationDraft(pdfAnnotationDraftOf(draft, MIRROR, mirrorEveryPage), options), MIRROR, mirrorEveryPage);
+	const given = draft;
+	for (const name of Object.keys(back)) if (given[name] !== void 0 && semanticEqual(back[name], given[name])) back[name] = given[name];
+	return back;
+}
+/**
+* The annotation the engine will read back after creating `draft`: what a
+* viewer shows while the create is on its way. `context` says what the draft
+* doesn't: the ref and place it will have, who creates it, and, for a kind
+* whose `rect` the engine works out from its drawing, that box. The draft is
+* resolved as `resolveAnnotationDraft` does it, without the engine's schema
+* check: a create the engine refuses leaves the view when it answers.
+*/
+function annotationOfDraft(draft, context) {
+	return annotationOfResolvedDraft(resolveAnnotationDraft(draft, { describeFont: context.describeFont }), context);
+}
+//#endregion
+//#region src/search/fold.ts
+/**
+* Text folding for literal search: the deterministic normalization applied
+* to both the page text and the needle so that "Café" finds "cafe" and a
+* line-wrapped "hello\n  world" finds "hello world".
+*
+* Fold version 1:
+*   - whitespace runs collapse to a single space (any `\s`, including the
+*     spaces some compatibility decompositions emit) — or are dropped
+*     entirely with `dropWhitespace` (ignoreWhitespace),
+*   - each code point is NFKD-decomposed (ligatures split: "fi" → "fi",
+*     "²" → "2"),
+*   - combining marks are stripped unless `keepMarks`,
+*   - case is folded via upper→lower round-trip unless `keepCase` (this
+*     poor-man's full fold catches "ß"→"ss" and "ς"→"σ", which a plain
+*     `toLowerCase` misses).
+*
+* Every folded code unit remembers which original code point produced it
+* (`map`), so match ranges found in folded space translate back to exact
+* original-text ranges — the property the whole anchor stage rests on.
+*
+* Pre-folded corpus artifacts store this fold's output; bump
+* `SEARCH_FOLD_VERSION` on any semantic change so stored corpora are
+* rebuilt instead of silently mismatching fresh needles.
+*/
+/** Version stamp for persisted pre-folded corpus artifacts. */
+const SEARCH_FOLD_VERSION = 1;
+const WHITESPACE = /\s/;
+const MARKS = /\p{M}/gu;
+function foldText(original, options = {}) {
+	const units = [];
+	const map = [];
+	let lastWasSpace = false;
+	let index = 0;
+	for (const cp of original) {
+		let piece;
+		if (WHITESPACE.test(cp)) piece = " ";
+		else {
+			piece = cp.normalize("NFKD");
+			if (!options.keepMarks) piece = piece.replace(MARKS, "");
+			if (!options.keepCase) piece = piece.toUpperCase().toLowerCase();
+		}
+		for (let u = 0; u < piece.length; u++) {
+			const unit = piece[u];
+			if (WHITESPACE.test(unit)) {
+				if (options.dropWhitespace || lastWasSpace) continue;
+				units.push(" ");
+				map.push(index);
+				lastWasSpace = true;
+			} else {
+				units.push(unit);
+				map.push(index);
+				lastWasSpace = false;
+			}
+		}
+		index += cp.length;
+	}
+	return {
+		folded: units.join(""),
+		map: Uint32Array.from(map),
+		original
+	};
+}
+/** Code-unit length of the code point starting at `index` (1 or 2). */
+function codePointLengthAt(text, index) {
+	const unit = text.charCodeAt(index);
+	if (unit >= 55296 && unit <= 56319 && index + 1 < text.length) {
+		const next = text.charCodeAt(index + 1);
+		if (next >= 56320 && next <= 57343) return 2;
+	}
+	return 1;
+}
+/**
+* Translate a match found in folded space back to a range of the original
+* text (code units).
+* The range covers whole original code points: a hit on either folded
+* half of "fi" spans the full ligature, and a hit ending on a collapsed
+* space extends only through the first whitespace char of the run (the
+* remainder is presentation, not match).
+*/
+function toOriginalRange(folded, foldedStart, foldedLength) {
+	const start = folded.map[foldedStart];
+	const lastOriginal = folded.map[foldedStart + foldedLength - 1];
+	return {
+		start,
+		count: lastOriginal + codePointLengthAt(folded.original, lastOriginal) - start
+	};
+}
+//#endregion
+//#region src/measure/units.ts
+const METRES = {
+	pt: .0254 / 72,
+	mm: .001,
+	cm: .01,
+	m: 1,
+	km: 1e3,
+	in: .0254,
+	ft: .3048,
+	yd: .9144,
+	mi: 1609.344
+};
+const squareOf = (unit) => `${unit}2`;
+function squareMetres(unit) {
+	return unit === "ha" ? 1e4 : unit === "acre" ? 4046.8564224 : METRES[unit.slice(0, -1)] ** 2;
+}
+const areaUnitLabel = (unit) => unit.endsWith("2") ? unit.slice(0, -1) + "²" : unit;
+//#endregion
+//#region src/measure/calibrate.ts
+function invalid(message) {
+	return new EngineError(EngineErrorCode.InvalidArg, message);
+}
+function positive(value) {
+	if (!Number.isFinite(value) || value <= 0) throw invalid("Calibration requires finite positive lengths and scales");
+}
+function build(perPoint, unit, ratio, format) {
+	positive(Math.fround(perPoint));
+	const precision = format.precision ?? 100;
+	if (!Number.isInteger(Math.log10(precision)) || precision < 1 || precision > 1e9) throw invalid("Invalid decimal precision");
+	const areaUnit = format.areaUnit ?? squareOf(unit);
+	const common = {
+		precision,
+		...format.fixed === void 0 ? {} : { fixed: format.fixed }
+	};
+	const distance = format.imperialFeetInches ? [{
+		unit: "ft",
+		conversion: Math.fround(METRES[unit] / METRES.ft)
+	}, {
+		unit: "in",
+		conversion: 12,
+		fraction: "fraction",
+		precision: format.fractionalPrecision ?? 16,
+		..."fixed" in common ? { fixed: common.fixed } : {}
+	}] : [{
+		unit,
+		conversion: 1,
+		...common
+	}];
+	if (format.imperialFeetInches && (!Number.isInteger(distance[1].precision) || distance[1].precision < 1 || distance[1].precision > 2147483647)) throw invalid("Invalid fraction denominator");
+	const measure = {
+		subtype: "rectilinear",
+		ratio,
+		x: [{
+			unit,
+			conversion: Math.fround(perPoint),
+			...common
+		}],
+		distance,
+		area: [{
+			unit: areaUnitLabel(areaUnit),
+			conversion: Math.fround(METRES[unit] ** 2 / squareMetres(areaUnit)),
+			...common
+		}]
+	};
+	assertWritableMeasure(measure);
+	return measure;
+}
+function measureFromKnownLength(userSpaceLength, real, format = {}) {
+	positive(userSpaceLength);
+	positive(real.value);
+	const perPoint = real.value / userSpaceLength;
+	return build(perPoint, real.unit, `1 in = ${Number((perPoint * 72).toPrecision(8))} ${real.unit}`, format);
+}
+function measureFromRatio(paper, real, unit, options = {}) {
+	const { userUnit = 1, ...format } = options;
+	positive(paper);
+	positive(real);
+	positive(userUnit);
+	return build(userUnit / 72 * .0254 * (real / paper) / METRES[unit], unit, `${paper}:${real}`, format);
+}
+//#endregion
+export { pdfAppearanceTurnOf as $, createPdfTextLayout as A, renderTargetArea as At, mapActionNode as B, resolveAnnotationPatch as C, pageQuadOf as Ct, pageGeometryOf as D, pageTransform as Dt, createTextLayout as E, pdfRectOf as Et, pdfAnnotationOf as F, mapLinkTarget as G, mapAnnotationActions as H, pdfAnnotationPatchOf as I, pageDestinationOf as J, mapPageActions as K, pageMeasureOf as L, pageAnnotationOf as M, renderSize as Mt, pageAnnotationPatchOf as N, pageSearchSliceOf as O, renderAreaTransform as Ot, pdfAnnotationDraftOf as P, applyResolvedPatch as Q, pageViewportsOf as R, resolveAnnotationDraft as S, pagePointOf as St, shapeForRect as T, pdfQuadOf as Tt, mapDocumentActions as U, mapActionTree as V, mapFieldActions as W, ANNOTATION_DEFAULTS as X, pdfDestinationOf as Y, annotationDefaultsOf as Z, pagePointUnturned as _, isAbortError as _t, squareMetres as a, DEFAULT_BUNDLE_LIMITS as at, pageTurnOfDrawn as b, isRotatedGeometryRun as bt, foldText as c, ANNOTATION_RESOURCE_ROLE_NAMES as ct, appearanceTurnOf as d, hasAnnotationResources as dt, toAttachmentRef as et, applyAnnotationPatch as f, resolveAnnotationResources as ft, pagePointTurned as g, AbortError as gt, pageGlyphLooseQuad as h, resolveBinarySource as ht, areaUnitLabel as i, bundleCodec as it, pageAnnotationDraftOf as j, renderTransform as jt, pageTextSegmentOf as k, renderMatrix as kt, toOriginalRange as l, annotationResourceBuffers as lt, pageGlyphLooseBounds as m, sniffBinaryMetadata as mt, measureFromRatio as n, assertAnnotationBundle as nt, squareOf as o, assertWithinLimit as ot, drawnPointsOf as p, withFileFromResource as pt, mapTriggerActions as q, METRES as r, assertAnnotationBundleManifest as rt, SEARCH_FOLD_VERSION as s, manifestBytesOf as st, measureFromKnownLength as t, AnnotationTransfer as tt, annotationOfDraft as u, assertAnnotationResources as ut, pagePointsBounds as v, glyphLooseBounds as vt, resolveRectCommand as w, pdfPointOf as wt, pageTurnOfUpright as x, pageBoxOf as xt, pageQuadBounds as y, glyphLooseQuad as yt, pdfMeasureOf as z };
+
+//# sourceMappingURL=calibrate-7T3fnP8-.js.map