@embedpdf/engine-core 3.0.0-next.14 → 3.0.0-next.16

package/dist/calibrate-DJbi1wuK.cjs

@@ -0,0 +1,3012 @@
+const require_resolveAnnotationDraft = require("./resolveAnnotationDraft-7Ke4nV7F.cjs");
+const require_format = require("./format-Bp3QFSH1.cjs");
+const require_charmap = require("./charmap-aYlefQP9.cjs");
+//#region src/dto/PdfLinkTarget.ts
+/**
+* The action tree the engine writes for a target a write can make: one URI,
+* GoTo or Named action, as a read of it returns it. Links and outline items
+* both write their targets this way.
+*/
+function actionTreeOf(target) {
+	return {
+		root: target.kind === "uri" ? {
+			type: "uri",
+			subtype: "URI",
+			uri: target.uri,
+			isMap: false,
+			next: []
+		} : target.kind === "goto" ? {
+			type: "goto",
+			subtype: "GoTo",
+			destination: target.destination,
+			next: []
+		} : {
+			type: "named",
+			subtype: "Named",
+			name: target.name,
+			next: []
+		},
+		incomplete: false,
+		warningFlags: 0,
+		warnings: []
+	};
+}
+//#endregion
+//#region src/geometry/printSize.ts
+/**
+* The paper a print picture is sized for, in points: the larger of A4
+* (595 × 842) and Letter (612 × 792) on each side.
+*/
+const PRINT_PAPER = {
+	long: 842,
+	short: 612
+};
+/**
+* The scale (pixels per point) of a print picture of a page `size` points
+* big at `dpi` dots per inch of paper. A page that fits on the paper is
+* drawn at its own size at that DPI; a bigger one gets no more pixels than
+* it needs shrunk to fit, since the printer would throw the rest away. An
+* A0 drawing printed on office paper needs no more; printed at its own
+* size, it needs vectors (the print copy). Portrait or landscape doesn't
+* matter.
+*/
+function printScale(size, dpi) {
+	const long = Math.max(size.width, size.height);
+	const short = Math.min(size.width, size.height);
+	const fit = Math.min(1, PRINT_PAPER.long / long, PRINT_PAPER.short / short);
+	return dpi / 72 * fit;
+}
+//#endregion
+//#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`. A `dpi` viewport sizes a print picture for its paper
+* ({@link printScale}). 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 require_format.EngineError(require_format.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.kind === "dpi" ? printScale(area, viewport.dpi) : viewport.scale ?? 1;
+	if (!Number.isFinite(scale) || scale <= 0) throw new require_format.EngineError(require_format.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 require_format.EngineError(require_format.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 require_resolveAnnotationDraft.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 require_format.EngineError {
+	constructor(reason) {
+		super(require_format.EngineErrorCode.Aborted, reasonMessage(reason));
+		require_format._defineProperty(this, "name", "AbortError");
+		require_format._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/identity/OutlineItemRef.ts
+/** Build the address for an outline item from its object number. */
+function toOutlineItemRef(objectNumber) {
+	return {
+		kind: "objectNumber",
+		objectNumber
+	};
+}
+/** Structural equality for two outline item addresses. */
+function outlineItemRefsEqual(a, b) {
+	return a.kind === b.kind && a.objectNumber === b.objectNumber;
+}
+//#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 require_format.EngineError(require_format.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 require_format.EngineError(require_format.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 = require_resolveAnnotationDraft.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 require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `a ${subtype} annotation takes no '${role}' resource`);
+		if (!given && write === "create" && roles[role] === "required") throw new require_format.EngineError(require_format.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 require_format.EngineError(require_format.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 require_format.EngineError(require_format.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] = require_charmap.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 require_format.EngineError(require_format.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" ? require_charmap.decodedLengthOf(value) : null;
+				if (size === null) throw new require_format.EngineError(require_format.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] = require_charmap.fromBase64(value);
+			} catch (error) {
+				throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `resource ${id} is not base64`, { cause: error });
+			}
+			await require_resolveAnnotationDraft.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 = require_resolveAnnotationDraft.isRecord(bundle?.resources) ? bundle.resources : require_resolveAnnotationDraft.invalidBundle("annotation", "no resources");
+	const sizes = /* @__PURE__ */ new Map();
+	for (const [id, bytes] of Object.entries(resources)) {
+		if (!(bytes instanceof Uint8Array)) require_resolveAnnotationDraft.invalidBundle("annotation", `resource ${id} is not bytes`);
+		sizes.set(id, bytes.length);
+	}
+	assertAnnotationBundleManifest(bundle, sizes, limits);
+	await require_resolveAnnotationDraft.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 (!require_resolveAnnotationDraft.isRecord(manifest)) require_resolveAnnotationDraft.invalidBundle("annotation", "not an annotation bundle");
+	require_resolveAnnotationDraft.assertKnownFields("annotation", "the bundle", manifest, BUNDLE_FIELDS);
+	if (manifest.format !== "embedpdf/annotations") require_resolveAnnotationDraft.invalidBundle("annotation", `unknown format ${JSON.stringify(manifest.format)}`);
+	if (manifest.version !== 1) require_resolveAnnotationDraft.invalidBundle("annotation", `unknown version ${JSON.stringify(manifest.version)}`);
+	const { pages, items } = manifest;
+	if (!Array.isArray(pages)) require_resolveAnnotationDraft.invalidBundle("annotation", "pages is not a list");
+	if (!Array.isArray(items)) require_resolveAnnotationDraft.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 = require_resolveAnnotationDraft.assertBundlePages("annotation", pages);
+	const named = /* @__PURE__ */ new Set();
+	items.forEach((item, index) => {
+		if (!require_resolveAnnotationDraft.isRecord(item) || !require_resolveAnnotationDraft.isRecord(item.data) || typeof item.data.subtype !== "string") require_resolveAnnotationDraft.invalidBundle("annotation", `item ${index} has no annotation data`);
+		require_resolveAnnotationDraft.assertKnownFields("annotation", `item ${index}`, item, ITEM_FIELDS);
+		const ref = item.data.ref;
+		const page = require_resolveAnnotationDraft.isRecord(ref) ? ref.page : void 0;
+		if (!require_resolveAnnotationDraft.isBundlePageRef(page) || !pageKeys.has(require_format.encodePageKey(page))) require_resolveAnnotationDraft.invalidBundle("annotation", `item ${index} is on a page the bundle doesn't list`);
+		require_resolveAnnotationDraft.assertRowResources("annotation", `item ${index}`, item.resources, ANNOTATION_RESOURCE_ROLE_NAMES, resourceSizes, named);
+	});
+	require_resolveAnnotationDraft.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
+/**
+* How much of a file the local engine decodes: a download of a larger file,
+* from either home, is refused with `PayloadTooLarge`, before a small stream
+* that inflates to gigabytes takes the tab down. A file's declared size
+* can't be trusted. The cloud engine has its server's limit.
+*/
+const ATTACHMENT_LIMITS = { decodedBytes: 256 * 1024 * 1024 };
+/** 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 require_resolveAnnotationDraft.isSamePdfRect(require_resolveAnnotationDraft.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 ? {
+				...require_resolveAnnotationDraft.DEFAULT_RICH_TEXT_BODY,
+				...input.body
+			} : read?.body ?? require_resolveAnnotationDraft.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 = require_resolveAnnotationDraft.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 };
+}
+//#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 ? require_resolveAnnotationDraft.ANNOTATION_FIELD_SPACES_BY_NAME : require_resolveAnnotationDraft.ANNOTATION_FIELD_SPACES[subtype] ?? require_resolveAnnotationDraft.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 require_format.EngineError(require_format.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 = require_resolveAnnotationDraft.pdfTurnOfUpright(sets.flat(), annotation.rotation);
+	return sets.map((set) => set.map((point) => require_resolveAnnotationDraft.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 = {
+		...require_resolveAnnotationDraft.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 = require_resolveAnnotationDraft.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 = !require_resolveAnnotationDraft.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(require_resolveAnnotationDraft.pdfPointsBounds(points.map(mirroredPoint)));
+/** `point` turned by `turn`; a negative angle turns it back. */
+const pagePointTurned = (point, turn) => unmirroredPoint(require_resolveAnnotationDraft.pdfPointTurned(mirroredPoint(point), mirroredTurn(turn)));
+/** `point` turned back by `turn`. */
+const pagePointUnturned = (point, turn) => unmirroredPoint(require_resolveAnnotationDraft.pdfPointUnturned(mirroredPoint(point), mirroredTurn(turn)));
+/** The turn that draws upright `points`: `degrees` about the middle of their box. */
+const pageTurnOfUpright = (points, degrees) => unmirroredTurn(require_resolveAnnotationDraft.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(require_resolveAnnotationDraft.pdfTurnOfDrawn(points.map(mirroredPoint), degrees));
+/** The upright box around a quad, whatever its turn or skew. */
+const pageQuadBounds = (quad) => unmirroredBox(require_resolveAnnotationDraft.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 (!require_resolveAnnotationDraft.DRAWN_RECT_KINDS.has(annotation.subtype)) return { rect };
+	const read = annotation;
+	const placed = require_resolveAnnotationDraft.pdfShapeForRect(pdfAnnotationOf(Object.fromEntries([
+		"subtype",
+		"rect",
+		...require_resolveAnnotationDraft.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 || !require_resolveAnnotationDraft.DRAWN_RECT_KINDS.has(annotation.subtype)) return patch;
+	const read = annotation;
+	const shapeNames = require_resolveAnnotationDraft.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(require_resolveAnnotationDraft.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 && require_resolveAnnotationDraft.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(require_resolveAnnotationDraft.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 && require_resolveAnnotationDraft.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(require_resolveAnnotationDraft.pdfPredictAnnotationDraft(pdfAnnotationDraftOf(draft, MIRROR, mirrorEveryPage), options), MIRROR, mirrorEveryPage);
+	const given = draft;
+	for (const name of Object.keys(back)) if (given[name] !== void 0 && require_resolveAnnotationDraft.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 require_format.EngineError(require_format.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
+		}]
+	};
+	require_resolveAnnotationDraft.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
+Object.defineProperty(exports, "ANNOTATION_DEFAULTS", {
+	enumerable: true,
+	get: function() {
+		return ANNOTATION_DEFAULTS;
+	}
+});
+Object.defineProperty(exports, "ANNOTATION_RESOURCE_ROLE_NAMES", {
+	enumerable: true,
+	get: function() {
+		return ANNOTATION_RESOURCE_ROLE_NAMES;
+	}
+});
+Object.defineProperty(exports, "ATTACHMENT_LIMITS", {
+	enumerable: true,
+	get: function() {
+		return ATTACHMENT_LIMITS;
+	}
+});
+Object.defineProperty(exports, "AbortError", {
+	enumerable: true,
+	get: function() {
+		return AbortError;
+	}
+});
+Object.defineProperty(exports, "AnnotationTransfer", {
+	enumerable: true,
+	get: function() {
+		return AnnotationTransfer;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_BUNDLE_LIMITS", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_BUNDLE_LIMITS;
+	}
+});
+Object.defineProperty(exports, "METRES", {
+	enumerable: true,
+	get: function() {
+		return METRES;
+	}
+});
+Object.defineProperty(exports, "PRINT_PAPER", {
+	enumerable: true,
+	get: function() {
+		return PRINT_PAPER;
+	}
+});
+Object.defineProperty(exports, "SEARCH_FOLD_VERSION", {
+	enumerable: true,
+	get: function() {
+		return SEARCH_FOLD_VERSION;
+	}
+});
+Object.defineProperty(exports, "actionTreeOf", {
+	enumerable: true,
+	get: function() {
+		return actionTreeOf;
+	}
+});
+Object.defineProperty(exports, "annotationDefaultsOf", {
+	enumerable: true,
+	get: function() {
+		return annotationDefaultsOf;
+	}
+});
+Object.defineProperty(exports, "annotationOfDraft", {
+	enumerable: true,
+	get: function() {
+		return annotationOfDraft;
+	}
+});
+Object.defineProperty(exports, "annotationResourceBuffers", {
+	enumerable: true,
+	get: function() {
+		return annotationResourceBuffers;
+	}
+});
+Object.defineProperty(exports, "appearanceTurnOf", {
+	enumerable: true,
+	get: function() {
+		return appearanceTurnOf;
+	}
+});
+Object.defineProperty(exports, "applyAnnotationPatch", {
+	enumerable: true,
+	get: function() {
+		return applyAnnotationPatch;
+	}
+});
+Object.defineProperty(exports, "applyResolvedPatch", {
+	enumerable: true,
+	get: function() {
+		return applyResolvedPatch;
+	}
+});
+Object.defineProperty(exports, "areaUnitLabel", {
+	enumerable: true,
+	get: function() {
+		return areaUnitLabel;
+	}
+});
+Object.defineProperty(exports, "assertAnnotationBundle", {
+	enumerable: true,
+	get: function() {
+		return assertAnnotationBundle;
+	}
+});
+Object.defineProperty(exports, "assertAnnotationBundleManifest", {
+	enumerable: true,
+	get: function() {
+		return assertAnnotationBundleManifest;
+	}
+});
+Object.defineProperty(exports, "assertAnnotationResources", {
+	enumerable: true,
+	get: function() {
+		return assertAnnotationResources;
+	}
+});
+Object.defineProperty(exports, "assertWithinLimit", {
+	enumerable: true,
+	get: function() {
+		return assertWithinLimit;
+	}
+});
+Object.defineProperty(exports, "bundleCodec", {
+	enumerable: true,
+	get: function() {
+		return bundleCodec;
+	}
+});
+Object.defineProperty(exports, "createPdfTextLayout", {
+	enumerable: true,
+	get: function() {
+		return createPdfTextLayout;
+	}
+});
+Object.defineProperty(exports, "createTextLayout", {
+	enumerable: true,
+	get: function() {
+		return createTextLayout;
+	}
+});
+Object.defineProperty(exports, "drawnPointsOf", {
+	enumerable: true,
+	get: function() {
+		return drawnPointsOf;
+	}
+});
+Object.defineProperty(exports, "foldText", {
+	enumerable: true,
+	get: function() {
+		return foldText;
+	}
+});
+Object.defineProperty(exports, "glyphLooseBounds", {
+	enumerable: true,
+	get: function() {
+		return glyphLooseBounds;
+	}
+});
+Object.defineProperty(exports, "glyphLooseQuad", {
+	enumerable: true,
+	get: function() {
+		return glyphLooseQuad;
+	}
+});
+Object.defineProperty(exports, "hasAnnotationResources", {
+	enumerable: true,
+	get: function() {
+		return hasAnnotationResources;
+	}
+});
+Object.defineProperty(exports, "isAbortError", {
+	enumerable: true,
+	get: function() {
+		return isAbortError;
+	}
+});
+Object.defineProperty(exports, "isRotatedGeometryRun", {
+	enumerable: true,
+	get: function() {
+		return isRotatedGeometryRun;
+	}
+});
+Object.defineProperty(exports, "manifestBytesOf", {
+	enumerable: true,
+	get: function() {
+		return manifestBytesOf;
+	}
+});
+Object.defineProperty(exports, "mapActionNode", {
+	enumerable: true,
+	get: function() {
+		return mapActionNode;
+	}
+});
+Object.defineProperty(exports, "mapActionTree", {
+	enumerable: true,
+	get: function() {
+		return mapActionTree;
+	}
+});
+Object.defineProperty(exports, "mapAnnotationActions", {
+	enumerable: true,
+	get: function() {
+		return mapAnnotationActions;
+	}
+});
+Object.defineProperty(exports, "mapDocumentActions", {
+	enumerable: true,
+	get: function() {
+		return mapDocumentActions;
+	}
+});
+Object.defineProperty(exports, "mapFieldActions", {
+	enumerable: true,
+	get: function() {
+		return mapFieldActions;
+	}
+});
+Object.defineProperty(exports, "mapLinkTarget", {
+	enumerable: true,
+	get: function() {
+		return mapLinkTarget;
+	}
+});
+Object.defineProperty(exports, "mapPageActions", {
+	enumerable: true,
+	get: function() {
+		return mapPageActions;
+	}
+});
+Object.defineProperty(exports, "mapTriggerActions", {
+	enumerable: true,
+	get: function() {
+		return mapTriggerActions;
+	}
+});
+Object.defineProperty(exports, "measureFromKnownLength", {
+	enumerable: true,
+	get: function() {
+		return measureFromKnownLength;
+	}
+});
+Object.defineProperty(exports, "measureFromRatio", {
+	enumerable: true,
+	get: function() {
+		return measureFromRatio;
+	}
+});
+Object.defineProperty(exports, "outlineItemRefsEqual", {
+	enumerable: true,
+	get: function() {
+		return outlineItemRefsEqual;
+	}
+});
+Object.defineProperty(exports, "pageAnnotationDraftOf", {
+	enumerable: true,
+	get: function() {
+		return pageAnnotationDraftOf;
+	}
+});
+Object.defineProperty(exports, "pageAnnotationOf", {
+	enumerable: true,
+	get: function() {
+		return pageAnnotationOf;
+	}
+});
+Object.defineProperty(exports, "pageAnnotationPatchOf", {
+	enumerable: true,
+	get: function() {
+		return pageAnnotationPatchOf;
+	}
+});
+Object.defineProperty(exports, "pageBoxOf", {
+	enumerable: true,
+	get: function() {
+		return pageBoxOf;
+	}
+});
+Object.defineProperty(exports, "pageDestinationOf", {
+	enumerable: true,
+	get: function() {
+		return pageDestinationOf;
+	}
+});
+Object.defineProperty(exports, "pageGeometryOf", {
+	enumerable: true,
+	get: function() {
+		return pageGeometryOf;
+	}
+});
+Object.defineProperty(exports, "pageGlyphLooseBounds", {
+	enumerable: true,
+	get: function() {
+		return pageGlyphLooseBounds;
+	}
+});
+Object.defineProperty(exports, "pageGlyphLooseQuad", {
+	enumerable: true,
+	get: function() {
+		return pageGlyphLooseQuad;
+	}
+});
+Object.defineProperty(exports, "pageMeasureOf", {
+	enumerable: true,
+	get: function() {
+		return pageMeasureOf;
+	}
+});
+Object.defineProperty(exports, "pagePointOf", {
+	enumerable: true,
+	get: function() {
+		return pagePointOf;
+	}
+});
+Object.defineProperty(exports, "pagePointTurned", {
+	enumerable: true,
+	get: function() {
+		return pagePointTurned;
+	}
+});
+Object.defineProperty(exports, "pagePointUnturned", {
+	enumerable: true,
+	get: function() {
+		return pagePointUnturned;
+	}
+});
+Object.defineProperty(exports, "pagePointsBounds", {
+	enumerable: true,
+	get: function() {
+		return pagePointsBounds;
+	}
+});
+Object.defineProperty(exports, "pageQuadBounds", {
+	enumerable: true,
+	get: function() {
+		return pageQuadBounds;
+	}
+});
+Object.defineProperty(exports, "pageQuadOf", {
+	enumerable: true,
+	get: function() {
+		return pageQuadOf;
+	}
+});
+Object.defineProperty(exports, "pageSearchSliceOf", {
+	enumerable: true,
+	get: function() {
+		return pageSearchSliceOf;
+	}
+});
+Object.defineProperty(exports, "pageTextSegmentOf", {
+	enumerable: true,
+	get: function() {
+		return pageTextSegmentOf;
+	}
+});
+Object.defineProperty(exports, "pageTransform", {
+	enumerable: true,
+	get: function() {
+		return pageTransform;
+	}
+});
+Object.defineProperty(exports, "pageTurnOfDrawn", {
+	enumerable: true,
+	get: function() {
+		return pageTurnOfDrawn;
+	}
+});
+Object.defineProperty(exports, "pageTurnOfUpright", {
+	enumerable: true,
+	get: function() {
+		return pageTurnOfUpright;
+	}
+});
+Object.defineProperty(exports, "pageViewportsOf", {
+	enumerable: true,
+	get: function() {
+		return pageViewportsOf;
+	}
+});
+Object.defineProperty(exports, "pdfAnnotationDraftOf", {
+	enumerable: true,
+	get: function() {
+		return pdfAnnotationDraftOf;
+	}
+});
+Object.defineProperty(exports, "pdfAnnotationOf", {
+	enumerable: true,
+	get: function() {
+		return pdfAnnotationOf;
+	}
+});
+Object.defineProperty(exports, "pdfAnnotationPatchOf", {
+	enumerable: true,
+	get: function() {
+		return pdfAnnotationPatchOf;
+	}
+});
+Object.defineProperty(exports, "pdfAppearanceTurnOf", {
+	enumerable: true,
+	get: function() {
+		return pdfAppearanceTurnOf;
+	}
+});
+Object.defineProperty(exports, "pdfDestinationOf", {
+	enumerable: true,
+	get: function() {
+		return pdfDestinationOf;
+	}
+});
+Object.defineProperty(exports, "pdfMeasureOf", {
+	enumerable: true,
+	get: function() {
+		return pdfMeasureOf;
+	}
+});
+Object.defineProperty(exports, "pdfPointOf", {
+	enumerable: true,
+	get: function() {
+		return pdfPointOf;
+	}
+});
+Object.defineProperty(exports, "pdfQuadOf", {
+	enumerable: true,
+	get: function() {
+		return pdfQuadOf;
+	}
+});
+Object.defineProperty(exports, "pdfRectOf", {
+	enumerable: true,
+	get: function() {
+		return pdfRectOf;
+	}
+});
+Object.defineProperty(exports, "printScale", {
+	enumerable: true,
+	get: function() {
+		return printScale;
+	}
+});
+Object.defineProperty(exports, "renderAreaTransform", {
+	enumerable: true,
+	get: function() {
+		return renderAreaTransform;
+	}
+});
+Object.defineProperty(exports, "renderMatrix", {
+	enumerable: true,
+	get: function() {
+		return renderMatrix;
+	}
+});
+Object.defineProperty(exports, "renderSize", {
+	enumerable: true,
+	get: function() {
+		return renderSize;
+	}
+});
+Object.defineProperty(exports, "renderTargetArea", {
+	enumerable: true,
+	get: function() {
+		return renderTargetArea;
+	}
+});
+Object.defineProperty(exports, "renderTransform", {
+	enumerable: true,
+	get: function() {
+		return renderTransform;
+	}
+});
+Object.defineProperty(exports, "resolveAnnotationDraft", {
+	enumerable: true,
+	get: function() {
+		return resolveAnnotationDraft;
+	}
+});
+Object.defineProperty(exports, "resolveAnnotationPatch", {
+	enumerable: true,
+	get: function() {
+		return resolveAnnotationPatch;
+	}
+});
+Object.defineProperty(exports, "resolveAnnotationResources", {
+	enumerable: true,
+	get: function() {
+		return resolveAnnotationResources;
+	}
+});
+Object.defineProperty(exports, "resolveBinarySource", {
+	enumerable: true,
+	get: function() {
+		return resolveBinarySource;
+	}
+});
+Object.defineProperty(exports, "resolveRectCommand", {
+	enumerable: true,
+	get: function() {
+		return resolveRectCommand;
+	}
+});
+Object.defineProperty(exports, "shapeForRect", {
+	enumerable: true,
+	get: function() {
+		return shapeForRect;
+	}
+});
+Object.defineProperty(exports, "sniffBinaryMetadata", {
+	enumerable: true,
+	get: function() {
+		return sniffBinaryMetadata;
+	}
+});
+Object.defineProperty(exports, "squareMetres", {
+	enumerable: true,
+	get: function() {
+		return squareMetres;
+	}
+});
+Object.defineProperty(exports, "squareOf", {
+	enumerable: true,
+	get: function() {
+		return squareOf;
+	}
+});
+Object.defineProperty(exports, "toAttachmentRef", {
+	enumerable: true,
+	get: function() {
+		return toAttachmentRef;
+	}
+});
+Object.defineProperty(exports, "toOriginalRange", {
+	enumerable: true,
+	get: function() {
+		return toOriginalRange;
+	}
+});
+Object.defineProperty(exports, "toOutlineItemRef", {
+	enumerable: true,
+	get: function() {
+		return toOutlineItemRef;
+	}
+});
+Object.defineProperty(exports, "withFileFromResource", {
+	enumerable: true,
+	get: function() {
+		return withFileFromResource;
+	}
+});
+
+//# sourceMappingURL=calibrate-DJbi1wuK.cjs.map