@inkbar/core 0.3.0 → 0.5.0

package/dist/signatures-CMapTKrC.mjs

@@ -0,0 +1,4712 @@
+import { Circle, Color, FreeText, FreeTextStyle, Fringe, GLOSS_FORMAT, GLOSS_FORMAT as GLOSS_FORMAT$1, GLOSS_MEDIA_TYPE, GLOSS_SCHEMA_ID, GLOSS_VERSION, GLOSS_VERSION as GLOSS_VERSION$1, Highlight, IMAGE_DATA_URL, INTENTS, Ink, LINE_ENDINGS, Line, LineEnding, NOTE_ICONS, Note, NoteIcon, PDF_NAME, PDF_NAME as PDF_NAME$1, Point, Polygon, Polyline, Rect, Redact, Square, Stamp, commonFields } from "gloss-format";
+import { z } from "zod";
+import { v7 } from "uuid";
+//#region src/model/errors.ts
+var InkError = class extends Error {
+	name = "InkError";
+	code;
+	details;
+	constructor(code, message, details = {}, cause) {
+		super(message, cause === void 0 ? void 0 : { cause });
+		this.code = code;
+		this.details = details;
+	}
+};
+function isInkError(value) {
+	return value instanceof InkError || typeof value === "object" && value !== null && value.name === "InkError";
+}
+//#endregion
+//#region src/model/events.ts
+var Emitter = class {
+	listeners = /* @__PURE__ */ new Map();
+	on(event, fn) {
+		let set = this.listeners.get(event);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.listeners.set(event, set);
+		}
+		set.add(fn);
+		return () => {
+			set?.delete(fn);
+		};
+	}
+	emit(event, payload) {
+		const set = this.listeners.get(event);
+		if (!set) return;
+		for (const fn of [...set]) fn(payload);
+	}
+	clear() {
+		this.listeners.clear();
+	}
+};
+//#endregion
+//#region src/model/geometry.ts
+function approxEqual(a, b, eps = .01) {
+	return Math.abs(a - b) <= eps;
+}
+function rectFromPoints(a, b) {
+	return {
+		x: Math.min(a.x, b.x),
+		y: Math.min(a.y, b.y),
+		width: Math.abs(a.x - b.x),
+		height: Math.abs(a.y - b.y)
+	};
+}
+function rectFromQuad(q) {
+	const xs = [
+		q.p1.x,
+		q.p2.x,
+		q.p3.x,
+		q.p4.x
+	];
+	const ys = [
+		q.p1.y,
+		q.p2.y,
+		q.p3.y,
+		q.p4.y
+	];
+	const x = Math.min(...xs);
+	const y = Math.min(...ys);
+	return {
+		x,
+		y,
+		width: Math.max(...xs) - x,
+		height: Math.max(...ys) - y
+	};
+}
+function quadFromRect(r) {
+	const top = r.y + r.height;
+	const right = r.x + r.width;
+	return {
+		p1: {
+			x: r.x,
+			y: top
+		},
+		p2: {
+			x: right,
+			y: top
+		},
+		p3: {
+			x: r.x,
+			y: r.y
+		},
+		p4: {
+			x: right,
+			y: r.y
+		}
+	};
+}
+function unionRects(rects) {
+	if (rects.length === 0) throw new RangeError("unionRects needs at least one rect");
+	let x1 = Infinity;
+	let y1 = Infinity;
+	let x2 = -Infinity;
+	let y2 = -Infinity;
+	for (const r of rects) {
+		x1 = Math.min(x1, r.x);
+		y1 = Math.min(y1, r.y);
+		x2 = Math.max(x2, r.x + r.width);
+		y2 = Math.max(y2, r.y + r.height);
+	}
+	return {
+		x: x1,
+		y: y1,
+		width: x2 - x1,
+		height: y2 - y1
+	};
+}
+function rectsIntersect(a, b) {
+	return a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
+}
+function rectContainsPoint(r, p) {
+	return p.x >= r.x && p.x <= r.x + r.width && p.y >= r.y && p.y <= r.y + r.height;
+}
+function translateRect(r, dx, dy) {
+	return {
+		x: r.x + dx,
+		y: r.y + dy,
+		width: r.width,
+		height: r.height
+	};
+}
+function translateQuad(q, dx, dy) {
+	const t = (p) => ({
+		x: p.x + dx,
+		y: p.y + dy
+	});
+	return {
+		p1: t(q.p1),
+		p2: t(q.p2),
+		p3: t(q.p3),
+		p4: t(q.p4)
+	};
+}
+function applyMatrix(m, p) {
+	return {
+		x: m[0] * p.x + m[2] * p.y + m[4],
+		y: m[1] * p.x + m[3] * p.y + m[5]
+	};
+}
+function invertMatrix(m) {
+	const det = m[0] * m[3] - m[1] * m[2];
+	if (det === 0) throw new RangeError("matrix is not invertible");
+	return [
+		m[3] / det,
+		-m[1] / det,
+		-m[2] / det,
+		m[0] / det,
+		(m[2] * m[5] - m[3] * m[4]) / det,
+		(m[1] * m[4] - m[0] * m[5]) / det
+	];
+}
+/** Returns the matrix that applies `a` first, then `b`. */
+function multiplyMatrix(a, b) {
+	return [
+		a[0] * b[0] + a[1] * b[2],
+		a[0] * b[1] + a[1] * b[3],
+		a[2] * b[0] + a[3] * b[2],
+		a[2] * b[1] + a[3] * b[3],
+		a[4] * b[0] + a[5] * b[2] + b[4],
+		a[4] * b[1] + a[5] * b[3] + b[5]
+	];
+}
+function pointsFromFlat(flat) {
+	const out = [];
+	for (let i = 0; i + 1 < flat.length; i += 2) out.push({
+		x: flat[i],
+		y: flat[i + 1]
+	});
+	return out;
+}
+/** Eight numbers per quad, in PDF.js's normalised order. Trailing partial quads are dropped. */
+function quadsFromFlat(flat) {
+	const pts = pointsFromFlat(flat);
+	const out = [];
+	for (let i = 0; i + 3 < pts.length; i += 4) out.push({
+		p1: pts[i],
+		p2: pts[i + 1],
+		p3: pts[i + 2],
+		p4: pts[i + 3]
+	});
+	return out;
+}
+//#endregion
+//#region src/model/readable.ts
+function writable(initial) {
+	let value = initial;
+	const subs = /* @__PURE__ */ new Set();
+	const set = (next) => {
+		if (Object.is(next, value)) return;
+		value = next;
+		for (const fn of [...subs]) fn(value);
+	};
+	return {
+		get: () => value,
+		set,
+		update(fn) {
+			set(fn(value));
+		},
+		subscribe(fn) {
+			subs.add(fn);
+			return () => {
+				subs.delete(fn);
+			};
+		}
+	};
+}
+/**
+* A readable computed from `source`. It subscribes to the source only while it has
+* subscribers of its own, so an unobserved derived value holds no reference to the source.
+*/
+function derived(source, fn) {
+	const subs = /* @__PURE__ */ new Set();
+	let cached;
+	let stopSource;
+	const onSource = (v) => {
+		const next = fn(v);
+		if (Object.is(next, cached)) return;
+		cached = next;
+		for (const sub of [...subs]) sub(next);
+	};
+	return {
+		get: () => stopSource ? cached : fn(source.get()),
+		subscribe(sub) {
+			if (!stopSource) {
+				cached = fn(source.get());
+				stopSource = source.subscribe(onSource);
+			}
+			subs.add(sub);
+			return () => {
+				if (!subs.delete(sub) || subs.size > 0) return;
+				stopSource?.();
+				stopSource = void 0;
+			};
+		}
+	};
+}
+function readonly(w) {
+	return {
+		get: () => w.get(),
+		subscribe: (fn) => w.subscribe(fn)
+	};
+}
+//#endregion
+//#region src/model/selection.ts
+const union = (a, b) => {
+	const x = Math.min(a.x, b.x);
+	const y = Math.min(a.y, b.y);
+	return {
+		x,
+		y,
+		width: Math.max(a.x + a.width, b.x + b.width) - x,
+		height: Math.max(a.y + a.height, b.y + b.height) - y
+	};
+};
+const centreY = (r) => r.y + r.height / 2;
+function median(values) {
+	const sorted = [...values].sort((a, b) => a - b);
+	const mid = sorted.length >> 1;
+	return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+/**
+* Merges glyph boxes that share a line into one quad per run, ordered top to bottom (by
+* vertical centre) then left to right. Boxes whose vertical centres are within `tolerance`
+* points count as the same line; boxes with no area are dropped. Within a line, a horizontal
+* gap wider than `gap` points (default 1.5 × the line's median box height) starts a new run,
+* so text selected across a column gutter yields one quad per column. Pure user-space maths.
+*/
+function mergeLineRects(rects, tolerance = 2, gap) {
+	const lines = [];
+	for (const r of rects) {
+		if (!(r.width > 0 && r.height > 0)) continue;
+		const line = lines.find((l) => Math.abs(centreY(l.bounds) - centreY(r)) <= tolerance);
+		if (!line) {
+			lines.push({
+				bounds: { ...r },
+				boxes: [r]
+			});
+			continue;
+		}
+		line.bounds = union(line.bounds, r);
+		line.boxes.push(r);
+	}
+	const runs = [];
+	for (const line of lines) {
+		const maxGap = gap ?? 1.5 * median(line.boxes.map((b) => b.height));
+		const boxes = [...line.boxes].sort((a, b) => a.x - b.x);
+		let run = { ...boxes[0] };
+		for (const b of boxes.slice(1)) if (b.x - (run.x + run.width) > maxGap) {
+			runs.push(run);
+			run = { ...b };
+		} else run = union(run, b);
+		runs.push(run);
+	}
+	runs.sort((a, b) => centreY(b) - centreY(a) || a.x - b.x);
+	return runs.map(quadFromRect);
+}
+//#endregion
+//#region src/pdfjs/load.ts
+const REQUIRED = [
+	"worker",
+	"cMaps",
+	"standardFonts",
+	"wasm"
+];
+function assertAssets(value) {
+	const record = typeof value === "object" && value !== null ? value : {};
+	const missing = REQUIRED.filter((k) => typeof record[k] !== "string" || record[k] === "");
+	if (value === void 0 || value === null || missing.length > 0) throw new InkError("AssetConfigMissing", "openDocument needs an `assets` option naming the PDF.js worker, cMaps, standardFonts and wasm locations. Vite users: add the @inkbar/core/vite plugin and pass `assets` from \"virtual:inkbar-assets\".", { missing: value == null ? [...REQUIRED] : missing });
+}
+let modulePromise;
+let configuredWorker;
+/**
+* Loads PDF.js once. `#pdfjs` resolves to the legacy build in Node and the
+* modern build everywhere else (see package.json "imports").
+*/
+async function loadPdfjs(assets) {
+	assertAssets(assets);
+	modulePromise ??= import("#pdfjs").catch((cause) => {
+		modulePromise = void 0;
+		throw new InkError("AssetLoadFailed", "PDF.js could not be imported", { url: assets.worker }, cause);
+	});
+	const pdfjs = await modulePromise;
+	if (configuredWorker === void 0) {
+		pdfjs.GlobalWorkerOptions.workerSrc = assets.worker;
+		configuredWorker = assets.worker;
+	} else if (configuredWorker !== assets.worker) throw new InkError("AssetConfigMissing", "PDF.js worker URL cannot change after the first document is opened", {
+		configured: configuredWorker,
+		requested: assets.worker
+	});
+	return pdfjs;
+}
+async function openProxy(pdfjs, bytes, options) {
+	const { assets, password, verbosity } = options;
+	const task = pdfjs.getDocument({
+		data: bytes,
+		...password !== void 0 ? { password } : {},
+		...verbosity !== void 0 ? { verbosity } : {},
+		cMapUrl: assets.cMaps,
+		cMapPacked: true,
+		standardFontDataUrl: assets.standardFonts,
+		wasmUrl: assets.wasm,
+		...assets.icc !== void 0 ? { iccUrl: assets.icc } : {}
+	});
+	try {
+		return {
+			task,
+			proxy: await task.promise
+		};
+	} catch (cause) {
+		try {
+			await task.destroy();
+		} catch {}
+		throw mapLoadError(cause, {
+			assets,
+			passwordSupplied: password !== void 0
+		});
+	}
+}
+/** `PasswordResponses` values from PDF.js (`NEED_PASSWORD = 1`, `INCORRECT_PASSWORD = 2`). */
+const INCORRECT_PASSWORD = 2;
+/**
+* PDF.js raises these from `task.promise` when the worker script cannot be
+* imported (in browsers after its real Worker fails and the fake-worker
+* fallback also fails to import `workerSrc`).
+*/
+const WORKER_FAILURE = /Setting up fake worker failed|No "GlobalWorkerOptions\.workerSrc" specified/i;
+/**
+* Only the worker is mapped here. CMap, standard-font and wasm failures are
+* PDF.js warnings with fallbacks that never reject the open promise, so they
+* cannot be detected at open time.
+*
+* PDF.js 6 exports only some exception classes (`PasswordException`,
+* `InvalidPDFException`, `ResponseException`, `AbortException`), and errors
+* that cross the worker boundary are rebuilt by name, so match on `name`.
+* Inputs here are always in-memory bytes, so there is no fetch to fail:
+* every non-password failure means the bytes are not a usable PDF.
+*/
+function mapLoadError(cause, context) {
+	const { assets, passwordSupplied = false } = context;
+	const name = cause?.name;
+	const rawMessage = cause?.message;
+	const message = typeof rawMessage === "string" && rawMessage !== "" ? rawMessage : "Unknown PDF.js error";
+	if (WORKER_FAILURE.test(message)) return new InkError("AssetLoadFailed", "The PDF.js worker could not be loaded. Check the `assets.worker` URL.", { url: assets.worker }, cause);
+	if (name === "PasswordException") {
+		const wrong = cause.code === INCORRECT_PASSWORD;
+		return new InkError("PasswordRequired", wrong ? "The password is incorrect" : "This document is encrypted and needs a password", {
+			passwordSupplied,
+			incorrect: wrong
+		}, cause);
+	}
+	return new InkError("InvalidPdf", message, {
+		pdfjsErrorName: typeof name === "string" ? name : void 0,
+		pdfjsMessage: message
+	}, cause);
+}
+//#endregion
+//#region src/model/annotations/defaults.ts
+const COLORS = {
+	highlight: "#F2C230",
+	underline: "#2B5A9E",
+	strikeout: "#C0392B",
+	squiggly: "#1F7A4D",
+	text: "#F2C230",
+	freetext: "#151820",
+	square: "#C0392B",
+	circle: "#C0392B",
+	line: "#151820",
+	polyline: "#151820",
+	polygon: "#151820",
+	ink: "#151820",
+	stamp: "#151820",
+	loupe: "#151820",
+	mask: "#000000",
+	redact: "#C0392B"
+};
+const staticDefaults = {
+	color: (type) => COLORS[type],
+	fill: () => "#000000",
+	opacity: (type) => type === "highlight" ? .4 : 1
+};
+const VARIABLES = {
+	highlight: "--ink-highlight",
+	underline: "--ink-underline",
+	strikeout: "--ink-strikeout",
+	squiggly: "--ink-squiggly",
+	text: "--ink-note",
+	freetext: "--ink-free-text",
+	square: "--ink-shape",
+	circle: "--ink-shape",
+	line: "--ink-shape",
+	polyline: "--ink-shape",
+	polygon: "--ink-shape",
+	ink: "--ink-ink",
+	stamp: "--ink-ink",
+	loupe: "--ink-shape",
+	mask: "--ink-mask",
+	redact: "--ink-redact"
+};
+/** Resolves default colours from CSS custom properties on `el`, falling back to `staticDefaults`. */
+function cssVariableDefaults(el) {
+	const read = (name) => {
+		const view = el.ownerDocument.defaultView;
+		if (!view) return void 0;
+		return normalizeColor(view.getComputedStyle(el).getPropertyValue(name));
+	};
+	return {
+		color: (type) => read(VARIABLES[type]) ?? staticDefaults.color(type),
+		fill: () => read("--ink-redact-fill") ?? staticDefaults.fill(),
+		opacity: (type) => staticDefaults.opacity(type)
+	};
+}
+/** Accepts `#rgb`, `#rrggbb`, `rgb(r, g, b)` and `rgb(r g b)`; returns `#RRGGBB` or undefined. */
+function normalizeColor(value) {
+	const v = value.trim();
+	const short = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/i.exec(v);
+	if (short) {
+		const [, r = "", g = "", b = ""] = short;
+		return `#${r}${r}${g}${g}${b}${b}`.toUpperCase();
+	}
+	if (/^#[0-9a-f]{6}$/i.test(v)) return v.toUpperCase();
+	const rgb = /^rgba?\(\s*(\d{1,3})[\s,]+(\d{1,3})[\s,]+(\d{1,3})/i.exec(v);
+	if (rgb) return `#${[
+		rgb[1],
+		rgb[2],
+		rgb[3]
+	].map((n) => Math.min(255, Number(n)).toString(16).padStart(2, "0")).join("")}`.toUpperCase();
+}
+//#endregion
+//#region src/model/pdf-date.ts
+/** Parses a PDF date string (`D:YYYYMMDDHHmmSSOHH'mm'`) into ISO 8601. Returns `fallback` on anything unparseable. */
+function parsePdfDate(value, fallback) {
+	if (!value) return fallback;
+	const m = /^(?:D:)?(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?(Z|[+-]\d{2}(?:'\d{2}')?)?/.exec(value.trim());
+	if (!m) return fallback;
+	const [, y, mo = "01", d = "01", h = "00", mi = "00", s = "00", zone] = m;
+	let offsetMinutes = 0;
+	if (zone && zone !== "Z") {
+		const sign = zone.startsWith("-") ? -1 : 1;
+		const zh = Number(zone.slice(1, 3));
+		const zm = Number(zone.slice(4, 6) || 0);
+		offsetMinutes = sign * (zh * 60 + zm);
+	}
+	const utc = Date.UTC(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi), Number(s)) - offsetMinutes * 6e4;
+	if (Number.isNaN(utc)) return fallback;
+	return new Date(utc).toISOString();
+}
+//#endregion
+//#region src/model/annotations/pdf-names.ts
+/**
+* A set of PDF names Inkbar knows that stays open: any other valid PDF name loads, is kept and
+* is written back unchanged. The output type keeps autocomplete for the known values.
+*/
+function pdfNameSet(known) {
+	return z.union([z.enum(known), z.string().regex(PDF_NAME, "expected a PDF name")]).describe(`One of ${known.join(", ")}. Any other PDF name is allowed and kept unchanged.`);
+}
+/** True when `v` is one of the values in `list`. */
+function isKnown(list, v) {
+	return list.includes(v);
+}
+//#endregion
+//#region src/model/annotations/callout.ts
+/**
+* The insets from a free text's `rect` to its text box, in points (PDF `/RD`, XFDF `fringe`,
+* both in this order).
+*/
+const FringeSchema = z.object(Fringe.shape);
+/** An ending's length, and its full width, as a multiple of the stroke width. */
+const ENDING_SCALE = 3;
+/**
+* A free text's text box: `rect` inset by `fringe`, or `rect` itself without one. Insets wider
+* or taller than `rect` leave a box of width or height 0 at the inset origin.
+*/
+function freeTextBox(a) {
+	const { rect, fringe } = a;
+	if (!fringe) return rect;
+	return {
+		x: rect.x + fringe.left,
+		y: rect.y + fringe.bottom,
+		width: Math.max(0, rect.width - fringe.left - fringe.right),
+		height: Math.max(0, rect.height - fringe.top - fringe.bottom)
+	};
+}
+/**
+* True for a free-text callout drawn the standard way: a box with a leader line through
+* `callout`. A callout with `cornerRadius` is Inkbar's speech bubble instead.
+*/
+function isStandardCallout(a) {
+	return a.type === "freetext" && a.intent === "FreeTextCallout" && a.callout !== void 0 && a.callout.length >= 2 && a.cornerRadius === void 0;
+}
+/**
+* The leader line's stroke: the border colour, else the text colour, and the border width, with
+* 1 pt when the box has no border.
+*/
+function calloutStroke(a) {
+	return {
+		color: a.borderColor ?? a.defaultStyle.color,
+		width: a.width > 0 ? a.width : 1
+	};
+}
+/**
+* The `rect` and `fringe` that hold the text box `box` and a leader line through `callout`
+* stroked `width` points wide: every point is padded by half the stroke, and by the ending's
+* size as well when `head` is one Inkbar draws.
+*/
+function withCalloutBounds(box, callout, width, head) {
+	const drawn = head !== void 0 && head !== "None" && isKnown(LINE_ENDINGS, head);
+	const pad = width / 2 + (drawn ? ENDING_SCALE * Math.max(width, 1) : 0);
+	const xs = [
+		box.x,
+		box.x + box.width,
+		...callout.map((p) => p.x)
+	];
+	const ys = [
+		box.y,
+		box.y + box.height,
+		...callout.map((p) => p.y)
+	];
+	const left = Math.min(...xs) - pad;
+	const bottom = Math.min(...ys) - pad;
+	const right = Math.max(...xs) + pad;
+	const top = Math.max(...ys) + pad;
+	return {
+		rect: {
+			x: left,
+			y: bottom,
+			width: right - left,
+			height: top - bottom
+		},
+		fringe: {
+			left: box.x - left,
+			top: top - (box.y + box.height),
+			right: right - (box.x + box.width),
+			bottom: box.y - bottom
+		}
+	};
+}
+//#endregion
+//#region src/model/annotations/types.ts
+const PointSchema = z.object(Point.shape);
+const RectSchema = z.object(Rect.shape);
+const QuadSchema = z.object({
+	p1: PointSchema,
+	p2: PointSchema,
+	p3: PointSchema,
+	p4: PointSchema
+});
+/** What Inkbar adds to every Gloss type: the fields it always fills in, and its viewer state. */
+const Base = {
+	/** Bounding box in PDF user space. */
+	rect: RectSchema,
+	/** Resolved #RRGGBB. Written into the PDF later, so it is always concrete. */
+	color: Color,
+	opacity: commonFields.opacity.removeDefault(),
+	createdAt: commonFields.createdAt.unwrap(),
+	modifiedAt: commonFields.modifiedAt.unwrap(),
+	/** Created in this session, or imported from the file. Viewer state, never exported. */
+	source: z.enum(["session", "pdf"]),
+	/** Embedded annotations are locked until the engine can rewrite the file. Viewer state, never exported. */
+	locked: z.boolean().optional()
+};
+const Quads = z.array(QuadSchema).min(1);
+const TextMarkupSchema = z.object({
+	...Highlight.shape,
+	...Base,
+	type: z.enum([
+		"highlight",
+		"underline",
+		"strikeout",
+		"squiggly"
+	]),
+	quads: Quads
+});
+/** A note's icon (XFDF `icon`): a PDF name, so a name Inkbar does not know is kept. */
+const NoteIconSchema = NoteIcon;
+const NoteSchema = z.object({
+	...Note.shape,
+	...Base
+});
+/** A line ending (XFDF `head`/`tail`): a PDF name, so a name Inkbar does not know is kept. */
+const LineEndingSchema = LineEnding;
+/**
+* A key a type refuses outright rather than dropping like other unknown keys: one an older
+* shape used (so its value is not silently lost), or one that means nothing on the type (so a
+* later version is free to give it a meaning).
+*/
+const Refused = z.never().optional();
+/**
+* A free-text box's text style, keyed by the CSS property names XFDF writes in its
+* `defaultstyle` string. The older `align` is refused; other unknown keys are dropped.
+*/
+const FreeTextStyleSchema = z.object({
+	...FreeTextStyle.shape,
+	/** The text colour. */
+	color: Color,
+	align: Refused
+});
+/**
+* Free text, as XFDF has it: `color` is the box's fill and the text style lives in
+* `defaultStyle`. A box in the older shape (top-level `fontFamily`, `fontSize`, `align`) is
+* refused rather than silently losing its style; other unknown keys are dropped.
+*/
+const FreeTextSchema = z.object({
+	...FreeText.shape,
+	...Base,
+	/** The box's fill (XFDF `color`). Absent means no fill. */
+	color: FreeText.shape.color,
+	/** The box's border colour. Absent means the text colour. */
+	borderColor: Color.optional(),
+	defaultStyle: FreeTextStyleSchema,
+	fringe: FringeSchema.optional(),
+	callout: z.array(PointSchema).min(2).max(3).optional(),
+	fontFamily: Refused,
+	fontSize: Refused,
+	align: Refused
+});
+const SquareSchema = z.object({
+	...Square.shape,
+	...Base
+});
+const CircleSchema = z.object({
+	...Circle.shape,
+	...Base,
+	cornerRadius: Refused
+});
+const ShapeSchema = z.discriminatedUnion("type", [SquareSchema, CircleSchema]);
+const LineSchema = z.object({
+	...Line.shape,
+	...Base,
+	start: PointSchema,
+	end: PointSchema
+});
+const Vertices = z.array(PointSchema).min(2);
+const PolylineSchema = z.object({
+	...Polyline.shape,
+	...Base,
+	vertices: Vertices
+});
+const PolygonSchema = z.object({
+	...Polygon.shape,
+	...Base,
+	vertices: Vertices,
+	head: Refused,
+	tail: Refused
+});
+const PolySchema = z.discriminatedUnion("type", [PolylineSchema, PolygonSchema]);
+const InkShape = z.object({
+	...Ink.shape,
+	...Base,
+	inklist: z.array(z.array(PointSchema).min(1)).min(1),
+	/** Pen pressure from 0 to 1, one value per point of each stroke. Absent means even pressure. */
+	pressure: z.array(z.array(z.number().min(0).max(1))).optional()
+});
+/** Pressure must have one value per point of each stroke. */
+function checkPressure(a, ctx) {
+	if (!a.pressure) return;
+	if (!(a.pressure.length === a.inklist.length && a.pressure.every((p, i) => p.length === a.inklist[i]?.length))) ctx.addIssue({
+		code: "custom",
+		path: ["pressure"],
+		message: "pressure must have the same shape as inklist"
+	});
+}
+const InkSchema = InkShape.superRefine(checkPressure);
+/**
+* An image on the page (XFDF `stamp`), drawn to fill `rect`. Image and typed signatures are
+* stamps with `subject: 'Signature'`.
+*/
+const StampSchema = z.object({
+	...Stamp.shape,
+	...Base
+});
+/**
+* A loupe (Inkbar's own type, a circle with `custom.inkbar.type: 'loupe'` in a file): a circle
+* inscribed in `rect` that shows the page content under its own centre, magnified. `color` and
+* `width` draw its rim.
+*/
+const LoupeSchema = z.object({
+	type: z.literal("loupe"),
+	...commonFields,
+	/** How many times larger the content under the centre is drawn. Above 1. */
+	magnification: z.number().gt(1).default(2),
+	/** The rim's width in points. */
+	width: z.number().nonnegative().default(2),
+	...Base
+});
+/**
+* A mask (Inkbar's own type, a circle or square with `custom.inkbar.type: 'mask'` in a file):
+* dims everything on the page outside `shape` drawn in `rect`, an ellipse inscribed in it or the
+* rectangle itself. `color` is the dimming colour and `dim` how strongly it covers, from 0 to 1.
+* One per page: adding a second replaces the first.
+*/
+const MaskSchema = z.object({
+	type: z.literal("mask"),
+	...commonFields,
+	shape: z.enum(["rect", "ellipse"]),
+	dim: z.number().min(0).max(1).default(.5),
+	...Base
+});
+const RedactSchema = z.object({
+	...Redact.shape,
+	...Base,
+	/** Present when the mark came from text; absent for an area mark. */
+	quads: Quads.optional(),
+	/** Colour the redaction will be filled with when applied. */
+	interiorColor: Color
+});
+const AnnotationSchema = z.discriminatedUnion("type", [
+	TextMarkupSchema,
+	NoteSchema,
+	FreeTextSchema,
+	SquareSchema,
+	CircleSchema,
+	LineSchema,
+	PolylineSchema,
+	PolygonSchema,
+	InkSchema,
+	StampSchema,
+	LoupeSchema,
+	MaskSchema,
+	RedactSchema
+]);
+/** The viewer's own state on an annotation, left out of exports. */
+const VIEWER_STATE = {
+	source: true,
+	locked: true
+};
+/** One exported annotation: the stored annotation without its viewer state. */
+const ExportedAnnotationSchema = z.discriminatedUnion("type", [
+	TextMarkupSchema.omit(VIEWER_STATE),
+	NoteSchema.omit(VIEWER_STATE),
+	FreeTextSchema.omit(VIEWER_STATE),
+	SquareSchema.omit(VIEWER_STATE),
+	CircleSchema.omit(VIEWER_STATE),
+	LineSchema.omit(VIEWER_STATE),
+	PolylineSchema.omit(VIEWER_STATE),
+	PolygonSchema.omit(VIEWER_STATE),
+	InkShape.omit(VIEWER_STATE).superRefine(checkPressure),
+	StampSchema.omit(VIEWER_STATE),
+	LoupeSchema.omit(VIEWER_STATE),
+	MaskSchema.omit(VIEWER_STATE),
+	RedactSchema.omit(VIEWER_STATE)
+]);
+const AnnotationDocumentSchema = z.object({
+	format: z.literal(GLOSS_FORMAT),
+	version: z.literal(GLOSS_VERSION),
+	documentKey: z.string().optional(),
+	/** Validated item by item on import so unknown types can be preserved. */
+	annotations: z.array(z.unknown())
+});
+//#endregion
+//#region src/model/annotations/embedded.ts
+const SUPPORTED_SUBTYPES = /* @__PURE__ */ new Set([
+	"Highlight",
+	"Underline",
+	"StrikeOut",
+	"Squiggly",
+	"Text",
+	"FreeText",
+	"Square",
+	"Circle",
+	"Line",
+	"Polygon",
+	"PolyLine",
+	"Ink",
+	"Redact"
+]);
+function pdfColorToHex(c, fallback) {
+	if (!c || c.length < 3) return fallback;
+	return `#${[
+		c[0],
+		c[1],
+		c[2]
+	].map((n) => Math.round(n).toString(16).padStart(2, "0")).join("")}`.toUpperCase();
+}
+/** PDF.js hands back `rect` already in user space, but not always ordered; normalise with min/max. */
+function rectFromPdf(r) {
+	return rectFromPoints({
+		x: r[0],
+		y: r[1]
+	}, {
+		x: r[2],
+		y: r[3]
+	});
+}
+/** A PDF name exactly as PDF.js gives it (names are case-sensitive), or undefined if invalid. */
+function pdfName(raw) {
+	return raw !== void 0 && PDF_NAME$1.test(raw) ? raw : void 0;
+}
+/** `head` and `tail` from a Line's or PolyLine's `/LE`, left out when both are `None`. */
+function lineEndingsOf(raw) {
+	const endings = raw?.map((e) => pdfName(e) ?? "None");
+	return endings && endings.length === 2 && endings.some((e) => e !== "None") ? {
+		head: endings[0],
+		tail: endings[1]
+	} : {};
+}
+/**
+* Imported ids are `pdf:<page>:<pdfjsId>` (page is 0-based, pdfjsId is the annotation's object
+* reference such as `12R`). They are stable across opens of the same file, and `inReplyTo`
+* uses the same scheme so threads resolve.
+*/
+function importedId(page, pdfjsId) {
+	return `pdf:${page}:${pdfjsId}`;
+}
+/**
+* Imports one page's PDF.js annotation data. `targets` is @internal: the annotations whose
+* missing fields the document reads from the file after `ready`.
+*/
+function importEmbeddedPage(page, raw, importedAt) {
+	const counts = {};
+	const annotations = [];
+	const targets = [];
+	for (const data of raw) {
+		counts[data.subtype] = (counts[data.subtype] ?? 0) + 1;
+		if (!SUPPORTED_SUBTYPES.has(data.subtype) || data.hidden || data.noView) continue;
+		const converted = convert(page, data, importedAt);
+		if (!converted) continue;
+		annotations.push(converted);
+		const target = targetOf(converted.id, data);
+		if (target) targets.push(target);
+	}
+	return {
+		annotations,
+		counts,
+		targets
+	};
+}
+function targetOf(id, d) {
+	const rect = Array.from(d.rect);
+	if (d.subtype === "Text") return d.name === "NoIcon" ? {
+		id,
+		subtype: "Text",
+		rect
+	} : void 0;
+	if (d.subtype !== "FreeText") return void 0;
+	const daFont = d.defaultAppearanceData?.fontName;
+	return {
+		id,
+		subtype: "FreeText",
+		rect,
+		...daFont ? { daFont } : {}
+	};
+}
+function summarise(perPage) {
+	const totals = /* @__PURE__ */ new Map();
+	for (const counts of perPage) for (const [k, v] of Object.entries(counts)) totals.set(k, (totals.get(k) ?? 0) + v);
+	return [...totals.entries()].map(([subtype, count]) => ({
+		subtype,
+		count,
+		supported: SUPPORTED_SUBTYPES.has(subtype)
+	})).sort((a, b) => a.subtype < b.subtype ? -1 : a.subtype > b.subtype ? 1 : 0);
+}
+function convert(page, d, importedAt) {
+	const created = parsePdfDate(d.creationDate, parsePdfDate(d.modificationDate, importedAt));
+	const author = d.titleObj?.str;
+	const contents = d.contentsObj?.str;
+	const stroke = d.borderStyle?.width ?? 1;
+	const quads = d.quadPoints ? quadsFromFlat(d.quadPoints) : [];
+	const optional = (v) => v !== void 0 && v !== "";
+	const withColor = (type, source = d.color) => pdfColorToHex(source, staticDefaults.color(type));
+	const intent = pdfName(d.it);
+	const base = (type, color = withColor(type)) => ({
+		id: importedId(page, d.id),
+		page,
+		rect: rectFromPdf(d.rect),
+		color,
+		opacity: d.opacity ?? 1,
+		...optional(author) ? { author } : {},
+		...optional(contents) ? { contents } : {},
+		...d.inReplyTo ? { inReplyTo: importedId(page, d.inReplyTo) } : {},
+		...intent !== void 0 ? { intent } : {},
+		createdAt: created,
+		modifiedAt: parsePdfDate(d.modificationDate, created),
+		source: "pdf",
+		locked: true
+	});
+	const fillOf = (c) => c && c.length >= 3 ? { interiorColor: pdfColorToHex(c, "#FFFFFF") } : {};
+	let candidate;
+	switch (d.subtype) {
+		case "Highlight":
+		case "Underline":
+		case "StrikeOut":
+		case "Squiggly": {
+			if (quads.length === 0) return void 0;
+			const type = d.subtype === "StrikeOut" ? "strikeout" : d.subtype.toLowerCase();
+			candidate = {
+				...base(type),
+				type,
+				quads
+			};
+			break;
+		}
+		case "Text": {
+			const icon = d.name === "NoIcon" ? void 0 : pdfName(d.name);
+			candidate = {
+				...base("text"),
+				type: "text",
+				...icon !== void 0 ? { icon } : {}
+			};
+			break;
+		}
+		case "FreeText": {
+			const da = d.defaultAppearanceData;
+			const { color: _stroke, ...rest } = base("freetext");
+			candidate = {
+				...rest,
+				...d.color && d.color.length >= 3 ? { color: pdfColorToHex(d.color, "#FFFFFF") } : {},
+				type: "freetext",
+				contents: contents ?? "",
+				width: d.borderStyle?.width ?? 0,
+				defaultStyle: {
+					color: pdfColorToHex(da?.fontColor, staticDefaults.color("freetext")),
+					...da && da.fontSize > 0 ? { fontSize: da.fontSize } : {}
+				}
+			};
+			break;
+		}
+		case "Square":
+		case "Circle": {
+			const type = d.subtype.toLowerCase();
+			candidate = {
+				...base(type),
+				type,
+				width: stroke,
+				...fillOf(d.interiorColor)
+			};
+			break;
+		}
+		case "Line": {
+			const l = d.lineCoordinates ?? [
+				d.rect[0],
+				d.rect[1],
+				d.rect[2],
+				d.rect[3]
+			];
+			candidate = {
+				...base("line"),
+				type: "line",
+				start: {
+					x: l[0],
+					y: l[1]
+				},
+				end: {
+					x: l[2],
+					y: l[3]
+				},
+				width: stroke,
+				...lineEndingsOf(d.lineEndings)
+			};
+			break;
+		}
+		case "Polygon":
+		case "PolyLine": {
+			const type = d.subtype === "Polygon" ? "polygon" : "polyline";
+			const vertices = d.vertices ? pointsFromFlat(d.vertices) : [];
+			if (vertices.length < 2) return void 0;
+			candidate = {
+				...base(type),
+				type,
+				vertices,
+				width: stroke,
+				...fillOf(d.interiorColor),
+				...type === "polyline" ? lineEndingsOf(d.lineEndings) : {}
+			};
+			break;
+		}
+		case "Ink": {
+			const inklist = (d.inkLists ?? []).map((p) => pointsFromFlat(p)).filter((p) => p.length > 0);
+			if (inklist.length === 0) return void 0;
+			candidate = {
+				...base("ink"),
+				type: "ink",
+				inklist,
+				width: stroke
+			};
+			break;
+		}
+		case "Redact":
+			candidate = {
+				...base("redact"),
+				type: "redact",
+				interiorColor: pdfColorToHex(d.interiorColor, staticDefaults.fill()),
+				...quads.length > 0 ? { quads } : {}
+			};
+			break;
+		default: return;
+	}
+	const parsed = AnnotationSchema.safeParse(candidate);
+	return parsed.success ? parsed.data : void 0;
+}
+//#endregion
+//#region src/pdf/lexer.ts
+/** Thrown when the bytes are not valid PDF object syntax. */
+var PdfSyntaxError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PdfSyntaxError";
+	}
+};
+const isWhite$1 = (c) => c === 0 || c === 9 || c === 10 || c === 12 || c === 13 || c === 32;
+const isDelimiter = (c) => c === 40 || c === 41 || c === 60 || c === 62 || c === 91 || c === 93 || c === 123 || c === 125 || c === 47 || c === 37;
+const isRegular = (c) => !isWhite$1(c) && !isDelimiter(c);
+const isDigit = (c) => c >= 48 && c <= 57;
+const latin1$1 = (bytes, from, to) => {
+	let out = "";
+	for (let i = from; i < to; i++) out += String.fromCharCode(bytes[i]);
+	return out;
+};
+function skipSpace(bytes, offset) {
+	let i = offset;
+	while (i < bytes.length) {
+		const c = bytes[i];
+		if (isWhite$1(c)) i++;
+		else if (c === 37) while (i < bytes.length && bytes[i] !== 10 && bytes[i] !== 13) i++;
+		else break;
+	}
+	return i;
+}
+function tokenEnd(bytes, offset) {
+	let i = offset;
+	while (i < bytes.length && isRegular(bytes[i])) i++;
+	return i;
+}
+const hexValue = (c) => {
+	if (c === void 0) return -1;
+	if (c >= 48 && c <= 57) return c - 48;
+	if (c >= 65 && c <= 70) return c - 65 + 10;
+	if (c >= 97 && c <= 102) return c - 97 + 10;
+	return -1;
+};
+function parseName(bytes, offset) {
+	const end = tokenEnd(bytes, offset + 1);
+	let name = "";
+	for (let i = offset + 1; i < end; i++) {
+		const c = bytes[i];
+		const hi = c === 35 ? hexValue(bytes[i + 1]) : -1;
+		const lo = hi >= 0 ? hexValue(bytes[i + 2]) : -1;
+		if (hi >= 0 && lo >= 0 && i + 2 < end) {
+			name += String.fromCharCode(hi * 16 + lo);
+			i += 2;
+		} else name += String.fromCharCode(c);
+	}
+	return {
+		value: {
+			kind: "name",
+			name
+		},
+		end
+	};
+}
+function skipLiteralString(bytes, offset) {
+	let depth = 0;
+	for (let i = offset; i < bytes.length; i++) {
+		const c = bytes[i];
+		if (c === 92) i++;
+		else if (c === 40) depth++;
+		else if (c === 41 && --depth === 0) return i + 1;
+	}
+	throw new PdfSyntaxError("Unterminated string");
+}
+/** After a non-negative integer ending at `end`, looks for `gen R`. */
+function tryReference(bytes, num, end) {
+	let i = end;
+	if (i >= bytes.length || !isWhite$1(bytes[i])) return void 0;
+	i = skipSpace(bytes, i);
+	const genStart = i;
+	while (i < bytes.length && isDigit(bytes[i])) i++;
+	if (i === genStart || i >= bytes.length || !isWhite$1(bytes[i])) return void 0;
+	const gen = Number(latin1$1(bytes, genStart, i));
+	i = skipSpace(bytes, i);
+	if (bytes[i] !== 82 || i + 1 < bytes.length && isRegular(bytes[i + 1])) return;
+	return {
+		value: {
+			kind: "ref",
+			num,
+			gen
+		},
+		end: i + 1
+	};
+}
+function parseNumberOrKeyword(bytes, offset) {
+	const end = tokenEnd(bytes, offset);
+	const token = latin1$1(bytes, offset, end);
+	if (token === "true") return {
+		value: true,
+		end
+	};
+	if (token === "false") return {
+		value: false,
+		end
+	};
+	if (token === "null") return {
+		value: null,
+		end
+	};
+	if (/^[+-]?(\d+\.?\d*|\.\d+)$/.test(token)) {
+		const n = Number(token);
+		if (/^\d+$/.test(token)) {
+			const ref = tryReference(bytes, n, end);
+			if (ref) return ref;
+		}
+		return {
+			value: n,
+			end
+		};
+	}
+	throw new PdfSyntaxError(`Unexpected token "${token}" at ${offset}`);
+}
+/** Parses one value at `offset`, skipping whitespace and comments first. */
+function parseValue(bytes, offset) {
+	const i = skipSpace(bytes, offset);
+	if (i >= bytes.length) throw new PdfSyntaxError("Unexpected end of data");
+	const c = bytes[i];
+	if (c === 47) return parseName(bytes, i);
+	if (c === 40) return {
+		value: { kind: "string" },
+		end: skipLiteralString(bytes, i)
+	};
+	if (c === 60 && bytes[i + 1] === 60) return parseDict(bytes, i + 2);
+	if (c === 60) {
+		let j = i + 1;
+		while (j < bytes.length && bytes[j] !== 62) j++;
+		if (j >= bytes.length) throw new PdfSyntaxError("Unterminated hex string");
+		return {
+			value: { kind: "string" },
+			end: j + 1
+		};
+	}
+	if (c === 91) return parseArray(bytes, i + 1);
+	if (isRegular(c)) return parseNumberOrKeyword(bytes, i);
+	throw new PdfSyntaxError(`Unexpected "${String.fromCharCode(c)}" at ${i}`);
+}
+function parseArray(bytes, offset) {
+	const items = [];
+	let i = offset;
+	for (;;) {
+		i = skipSpace(bytes, i);
+		if (i >= bytes.length) throw new PdfSyntaxError("Unterminated array");
+		if (bytes[i] === 93) return {
+			value: items,
+			end: i + 1
+		};
+		const item = parseValue(bytes, i);
+		items.push(item.value);
+		i = item.end;
+	}
+}
+function parseDict(bytes, offset) {
+	const entries = /* @__PURE__ */ new Map();
+	let i = offset;
+	for (;;) {
+		i = skipSpace(bytes, i);
+		if (i >= bytes.length) throw new PdfSyntaxError("Unterminated dictionary");
+		if (bytes[i] === 62 && bytes[i + 1] === 62) return {
+			value: {
+				kind: "dict",
+				entries
+			},
+			end: i + 2
+		};
+		if (bytes[i] !== 47) throw new PdfSyntaxError(`Expected a name key at ${i}`);
+		const key = parseName(bytes, i);
+		const val = parseValue(bytes, key.end);
+		entries.set(key.value.name, val.value);
+		i = val.end;
+	}
+}
+function readInteger(bytes, offset) {
+	const i = skipSpace(bytes, offset);
+	let end = i;
+	while (end < bytes.length && isDigit(bytes[end])) end++;
+	if (end === i) throw new PdfSyntaxError(`Expected an integer at ${i}`);
+	return {
+		n: Number(latin1$1(bytes, i, end)),
+		end
+	};
+}
+/** Parses `num gen obj <value> [stream]` at `offset`. `streamStart` is the first data byte after `stream` and its EOL. */
+function parseIndirect(bytes, offset) {
+	const num = readInteger(bytes, offset);
+	const gen = readInteger(bytes, num.end);
+	const kw = skipSpace(bytes, gen.end);
+	if (latin1$1(bytes, kw, tokenEnd(bytes, kw)) !== "obj") throw new PdfSyntaxError(`Expected "obj" at ${kw}`);
+	const { value, end } = parseValue(bytes, kw + 3);
+	const result = {
+		num: num.n,
+		gen: gen.n,
+		value
+	};
+	const next = skipSpace(bytes, end);
+	if (latin1$1(bytes, next, next + 6) === "stream" && !isRegular(bytes[next + 6] ?? 32)) {
+		let start = next + 6;
+		if (bytes[start] === 13 && bytes[start + 1] === 10) start += 2;
+		else if (bytes[start] === 10 || bytes[start] === 13) start += 1;
+		result.streamStart = start;
+	}
+	return result;
+}
+/** Reads a dictionary entry. */
+const dictGet = (d, key) => d.entries.get(key);
+/** True for a name object, optionally one with the given spelling. */
+const isName = (v, name) => typeof v === "object" && v !== null && v.kind === "name" && (name === void 0 || v.name === name);
+/** True for a dictionary object. */
+const isDict = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && v.kind === "dict";
+/** True for an indirect reference. */
+const isRef = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && v.kind === "ref";
+//#endregion
+//#region src/pdf/annotation-fields.ts
+/** `12R` → {num:12,gen:0}, `12R3` → {num:12,gen:3}; anything else undefined. */
+function refOfPdfjsId(id) {
+	const m = /^(\d+)R(\d+)?$/.exec(id);
+	if (!m) return void 0;
+	return {
+		kind: "ref",
+		num: Number(m[1]),
+		gen: m[2] === void 0 ? 0 : Number(m[2])
+	};
+}
+const FAMILIES = [
+	[/^(helvetica|helv)/i, "Helvetica"],
+	[/^(times|tiro)/i, "Times"],
+	[/^cour(ier|$)/i, "Courier"]
+];
+/**
+* BaseFont (or bare resource name) → Inkbar font fields; undefined for Symbol and ZapfDingbats.
+* A family matches by prefix, so `HelveticaNeue` reads as Helvetica and `CourierNewPS` as
+* Courier. Any other name keeps its own family, minus a trailing `MT` or `PSMT`.
+* With `knownOnly`, a name outside Helvetica, Times and Courier gives undefined: a bare
+* resource id such as `F1` is not a family.
+*/
+function fontFromBaseName(name, knownOnly = false) {
+	const bare = name.replace(/^[A-Z]{6}\+/, "");
+	if (/^(symbol|zapfdingbats|zadb)/i.test(bare)) return void 0;
+	const cut = bare.search(/[-,]/);
+	const base = cut < 0 ? bare : bare.slice(0, cut);
+	const style = cut < 0 ? "" : bare.slice(cut + 1);
+	const known = FAMILIES.find(([re]) => re.test(base));
+	if (knownOnly && !known) return void 0;
+	const fontFamily = known ? known[1] : base.replace(/(PS)?MT$/, "");
+	if (!fontFamily) return void 0;
+	const font = { fontFamily };
+	if (/bold|black|heavy/i.test(style)) font.fontWeight = "bold";
+	if (/italic|oblique/i.test(style)) font.fontStyle = "italic";
+	return font;
+}
+const finite = (v) => typeof v === "number" && Number.isFinite(v);
+async function numbers$1(objs, v, counts) {
+	const arr = await objs.resolve(v);
+	if (!Array.isArray(arr) || !counts.includes(arr.length)) return void 0;
+	const out = await Promise.all(arr.map((n) => objs.resolve(n)));
+	return out.every(finite) ? out : void 0;
+}
+async function dictOf(objs, v) {
+	const d = await objs.resolve(v);
+	return isDict(d) ? d : void 0;
+}
+/** The font's /BaseFont, looked up in a /DR resource dictionary. */
+async function baseFontIn(objs, dr, resource) {
+	const res = await dictOf(objs, dr);
+	const fonts = res && await dictOf(objs, dictGet(res, "Font"));
+	const font = fonts && await dictOf(objs, dictGet(fonts, resource));
+	const base = font && await objs.resolve(dictGet(font, "BaseFont"));
+	return isName(base) ? base.name : void 0;
+}
+async function readFont(objs, annot, daFont) {
+	const root = await dictOf(objs, dictGet(objs.trailer, "Root"));
+	const acroForm = root && await dictOf(objs, dictGet(root, "AcroForm"));
+	const sources = [dictGet(annot, "DR"), acroForm && dictGet(acroForm, "DR")];
+	for (const dr of sources) {
+		const base = await baseFontIn(objs, dr, daFont);
+		if (base !== void 0) return fontFromBaseName(base);
+	}
+	return fontFromBaseName(daFont, true);
+}
+async function readHead(objs, le) {
+	let v = await objs.resolve(le);
+	if (Array.isArray(v)) v = await objs.resolve(v[0]);
+	return isName(v) && PDF_NAME$1.test(v.name) ? v.name : void 0;
+}
+/** `rect` is the annotation's [x1 y1 x2 y2], used to reject a fringe that leaves no box. */
+async function readFreeTextFields(objs, ref, rect, daFont) {
+	const fields = {};
+	try {
+		const annot = await objs.get(ref);
+		if (!isDict(annot)) return fields;
+		const cl = await numbers$1(objs, dictGet(annot, "CL"), [4, 6]);
+		if (cl) {
+			fields.callout = [];
+			for (let i = 0; i < cl.length; i += 2) fields.callout.push({
+				x: cl[i],
+				y: cl[i + 1]
+			});
+		}
+		const rd = await numbers$1(objs, dictGet(annot, "RD"), [4]);
+		if (rd && rect.length === 4 && rd.every((n) => n >= 0)) {
+			const [left, top, right, bottom] = rd;
+			const width = Math.abs(rect[2] - rect[0]);
+			const height = Math.abs(rect[3] - rect[1]);
+			if (left + right < width && top + bottom < height) fields.fringe = {
+				left,
+				top,
+				right,
+				bottom
+			};
+		}
+		const head = await readHead(objs, dictGet(annot, "LE"));
+		if (head !== void 0) fields.head = head;
+		if (daFont !== void 0) {
+			const font = await readFont(objs, annot, daFont);
+			if (font) fields.font = font;
+		}
+	} catch {}
+	return fields;
+}
+async function readTextIcon(objs, ref) {
+	try {
+		const annot = await objs.get(ref);
+		if (!isDict(annot)) return void 0;
+		const name = await objs.resolve(dictGet(annot, "Name"));
+		return isName(name) && PDF_NAME$1.test(name.name) ? name.name : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/pdf/stream.ts
+const ENDSTREAM = Uint8Array.from("endstream", (c) => c.charCodeAt(0));
+function matchesAt(bytes, at, pattern) {
+	if (at < 0 || at + pattern.length > bytes.length) return false;
+	for (let i = 0; i < pattern.length; i++) if (bytes[at + i] !== pattern[i]) return false;
+	return true;
+}
+function findEndstream(bytes, from) {
+	for (let i = from; i + ENDSTREAM.length <= bytes.length; i++) if (matchesAt(bytes, i, ENDSTREAM)) return i;
+	return bytes.length;
+}
+/** Raw stream bytes: trusts `length` when `endstream` follows it, otherwise scans. */
+function rawData(bytes, start, length) {
+	if (length !== void 0 && Number.isInteger(length) && length >= 0) {
+		let i = start + length;
+		while (i < bytes.length && (bytes[i] === 10 || bytes[i] === 13 || bytes[i] === 32)) i++;
+		if (matchesAt(bytes, i, ENDSTREAM)) return bytes.subarray(start, start + length);
+	}
+	let end = findEndstream(bytes, start);
+	if (end > start && bytes[end - 1] === 10) end--;
+	if (end > start && bytes[end - 1] === 13) end--;
+	return bytes.subarray(start, end);
+}
+/** The single filter parameter dictionary, if any. Anything else that is defined is an error. */
+function decodeParms(dict) {
+	const parms = dictGet(dict, "DecodeParms") ?? dictGet(dict, "DP");
+	const first = Array.isArray(parms) ? parms[0] : parms;
+	if (first === void 0 || first === null) return void 0;
+	if (!isDict(first)) throw new PdfSyntaxError("Unsupported /DecodeParms");
+	return first;
+}
+function numberParam(parms, key, fallback) {
+	const v = parms ? dictGet(parms, key) : void 0;
+	return typeof v === "number" ? v : fallback;
+}
+async function inflate(data) {
+	const stream = new Blob([data]).stream().pipeThrough(new DecompressionStream("deflate"));
+	return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+function paeth(a, b, c) {
+	const p = a + b - c;
+	const pa = Math.abs(p - a);
+	const pb = Math.abs(p - b);
+	const pc = Math.abs(p - c);
+	if (pa <= pb && pa <= pc) return a;
+	return pb <= pc ? b : c;
+}
+function undoPngPredictor(data, columns, colors, bits) {
+	const bpp = Math.max(1, Math.ceil(colors * bits / 8));
+	const rowBytes = Math.ceil(columns * colors * bits / 8);
+	const rows = Math.floor(data.length / (rowBytes + 1));
+	const out = new Uint8Array(rows * rowBytes);
+	for (let r = 0; r < rows; r++) {
+		const type = data[r * (rowBytes + 1)];
+		const src = r * (rowBytes + 1) + 1;
+		const dst = r * rowBytes;
+		for (let x = 0; x < rowBytes; x++) {
+			const raw = data[src + x];
+			const left = x >= bpp ? out[dst + x - bpp] : 0;
+			const up = r > 0 ? out[dst - rowBytes + x] : 0;
+			const upLeft = r > 0 && x >= bpp ? out[dst - rowBytes + x - bpp] : 0;
+			let value;
+			switch (type) {
+				case 0:
+					value = raw;
+					break;
+				case 1:
+					value = raw + left;
+					break;
+				case 2:
+					value = raw + up;
+					break;
+				case 3:
+					value = raw + (left + up >> 1);
+					break;
+				case 4:
+					value = raw + paeth(left, up, upLeft);
+					break;
+				default: throw new PdfSyntaxError(`Unknown PNG filter type ${type}`);
+			}
+			out[dst + x] = value & 255;
+		}
+	}
+	return out;
+}
+/** The decoded data of the stream whose dictionary is `dict` and whose data starts at `start`. `length` is `/Length`, already resolved. */
+async function decodeStream(bytes, dict, start, length) {
+	const filter = dictGet(dict, "Filter") ?? dictGet(dict, "F");
+	const filters = Array.isArray(filter) ? filter : filter === void 0 ? [] : [filter];
+	if (filters.length === 0) return rawData(bytes, start, length);
+	if (filters.length > 1 || !isName(filters[0], "FlateDecode")) throw new PdfSyntaxError("Unsupported stream filter");
+	const inflated = await inflate(rawData(bytes, start, length));
+	const parms = decodeParms(dict);
+	const predictor = numberParam(parms, "Predictor", 1);
+	if (predictor === 1) return inflated;
+	if (predictor < 10) throw new PdfSyntaxError(`Unsupported predictor ${predictor}`);
+	return undoPngPredictor(inflated, numberParam(parms, "Columns", 1), numberParam(parms, "Colors", 1), numberParam(parms, "BitsPerComponent", 8));
+}
+//#endregion
+//#region src/pdf/xref.ts
+const isWhite = (c) => c === 0 || c === 9 || c === 10 || c === 12 || c === 13 || c === 32;
+const latin1 = (bytes, from, to) => {
+	let out = "";
+	for (let i = from; i < to; i++) out += String.fromCharCode(bytes[i]);
+	return out;
+};
+function readToken(bytes, offset) {
+	let i = offset;
+	while (i < bytes.length && isWhite(bytes[i])) i++;
+	const start = i;
+	while (i < bytes.length && !isWhite(bytes[i])) i++;
+	return {
+		token: latin1(bytes, start, i),
+		end: i
+	};
+}
+function readInt(bytes, offset) {
+	const { token, end } = readToken(bytes, offset);
+	if (!/^\d+$/.test(token)) throw new Error(`Expected an integer at ${offset}`);
+	return {
+		n: Number(token),
+		end
+	};
+}
+function findStartxref(bytes) {
+	const tail = latin1(bytes, Math.max(0, bytes.length - 1024), bytes.length);
+	const at = tail.lastIndexOf("startxref");
+	if (at < 0) throw new Error("No startxref");
+	return readInt(bytes, bytes.length - tail.length + at + 9).n;
+}
+function readTable(bytes, offset) {
+	const entries = /* @__PURE__ */ new Map();
+	let i = readToken(bytes, offset).end;
+	for (;;) {
+		const head = readToken(bytes, i);
+		if (head.token.startsWith("trailer")) {
+			const trailer = parseValue(bytes, head.end - (head.token.length - 7)).value;
+			if (!isDict(trailer)) throw new Error("Trailer is not a dictionary");
+			return {
+				entries,
+				trailer
+			};
+		}
+		const first = readInt(bytes, i);
+		const count = readInt(bytes, first.end);
+		i = count.end;
+		for (let k = 0; k < count.n; k++) {
+			const off = readInt(bytes, i);
+			const gen = readInt(bytes, off.end);
+			const kind = readToken(bytes, gen.end);
+			i = kind.end;
+			if (kind.token === "n") entries.set(first.n + k, {
+				type: "offset",
+				offset: off.n,
+				gen: gen.n
+			});
+			else if (kind.token === "f") entries.set(first.n + k, { type: "free" });
+			else throw new Error(`Bad xref entry type "${kind.token}"`);
+		}
+	}
+}
+const numbers = (v) => Array.isArray(v) && v.every((x) => typeof x === "number" && x >= 0) ? v : void 0;
+async function readStream(bytes, offset) {
+	const obj = parseIndirect(bytes, offset);
+	const dict = obj.value;
+	if (!isDict(dict) || obj.streamStart === void 0) throw new Error("Xref stream expected");
+	const length = dict.entries.get("Length");
+	const data = await decodeStream(bytes, dict, obj.streamStart, typeof length === "number" ? length : void 0);
+	const w = numbers(dict.entries.get("W"));
+	if (!w || w.length !== 3 || w.some((x) => x > 8)) throw new Error("Bad /W");
+	const size = dict.entries.get("Size");
+	const index = numbers(dict.entries.get("Index")) ?? [0, typeof size === "number" ? size : 0];
+	const [w0, w1, w2] = w;
+	const rowLength = w0 + w1 + w2;
+	if (rowLength === 0) throw new Error("Empty xref rows");
+	const field = (at, width) => {
+		let n = 0;
+		for (let k = 0; k < width; k++) n = n * 256 + data[at + k];
+		return n;
+	};
+	const entries = /* @__PURE__ */ new Map();
+	let row = 0;
+	for (let s = 0; s + 1 < index.length; s += 2) for (let k = 0; k < index[s + 1]; k++, row++) {
+		const at = row * rowLength;
+		if (at + rowLength > data.length) return {
+			entries,
+			trailer: dict
+		};
+		const type = w0 === 0 ? 1 : field(at, w0);
+		const a = field(at + w0, w1);
+		const b = field(at + w0 + w1, w2);
+		const num = index[s] + k;
+		if (type === 0) entries.set(num, { type: "free" });
+		else if (type === 1) entries.set(num, {
+			type: "offset",
+			offset: a,
+			gen: b
+		});
+		else if (type === 2) entries.set(num, {
+			type: "compressed",
+			stream: a,
+			index: b
+		});
+	}
+	return {
+		entries,
+		trailer: dict
+	};
+}
+async function readSection(bytes, offset) {
+	if (!Number.isInteger(offset) || offset < 0 || offset >= bytes.length) throw new Error("Xref offset out of range");
+	return readToken(bytes, offset).token === "xref" ? readTable(bytes, offset) : readStream(bytes, offset);
+}
+/** Newest entry wins along the /Prev chain (and a hybrid file's /XRefStm). Undefined when startxref or a section cannot be read. */
+async function readXref(bytes) {
+	try {
+		const entries = /* @__PURE__ */ new Map();
+		const visited = /* @__PURE__ */ new Set();
+		let trailer;
+		let next = findStartxref(bytes);
+		while (next !== void 0 && !visited.has(next)) {
+			visited.add(next);
+			const section = await readSection(bytes, next);
+			trailer ??= section.trailer;
+			const hybrid = section.trailer.entries.get("XRefStm");
+			if (typeof hybrid === "number" && !visited.has(hybrid)) {
+				visited.add(hybrid);
+				const extra = await readSection(bytes, hybrid);
+				for (const [num, e] of extra.entries) if (!entries.has(num)) entries.set(num, e);
+			}
+			for (const [num, e] of section.entries) if (!entries.has(num)) entries.set(num, e);
+			const prev = section.trailer.entries.get("Prev");
+			next = typeof prev === "number" ? prev : void 0;
+		}
+		return trailer ? {
+			entries,
+			trailer
+		} : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/pdf/objects.ts
+var Reader = class {
+	bytes;
+	xref;
+	trailer;
+	objectStreams = /* @__PURE__ */ new Map();
+	constructor(bytes, xref) {
+		this.bytes = bytes;
+		this.xref = xref;
+		this.trailer = xref.trailer;
+	}
+	async get(ref) {
+		try {
+			return await this.load(ref, true);
+		} catch {
+			return;
+		}
+	}
+	async resolve(v) {
+		return isRef(v) ? this.get(v) : v;
+	}
+	/** `followLength` is false while resolving a /Length, so a self-referencing length cannot recurse. */
+	async load(ref, followLength) {
+		const entry = this.xref.entries.get(ref.num);
+		if (!entry || entry.type === "free") return void 0;
+		if (entry.type === "offset") {
+			if (entry.gen !== ref.gen) return void 0;
+			const obj = parseIndirect(this.bytes, entry.offset);
+			return obj.num === ref.num && obj.gen === ref.gen ? obj.value : void 0;
+		}
+		if (ref.gen !== 0) return void 0;
+		const container = await this.objectStream(entry.stream, followLength);
+		if (!container) return void 0;
+		let pair = container.pairs[entry.index];
+		if (pair?.num !== ref.num) pair = container.pairs.find((p) => p.num === ref.num);
+		if (!pair) return void 0;
+		return parseValue(container.decoded, container.first + pair.offset).value;
+	}
+	objectStream(num, followLength) {
+		let cached = this.objectStreams.get(num);
+		if (!cached) {
+			cached = this.readObjectStream(num, followLength).catch(() => void 0);
+			this.objectStreams.set(num, cached);
+		}
+		return cached;
+	}
+	async readObjectStream(num, followLength) {
+		const entry = this.xref.entries.get(num);
+		if (entry?.type !== "offset") return void 0;
+		const obj = parseIndirect(this.bytes, entry.offset);
+		const dict = obj.value;
+		if (obj.num !== num || !isDict(dict) || obj.streamStart === void 0) return void 0;
+		const n = dict.entries.get("N");
+		const first = dict.entries.get("First");
+		if (typeof n !== "number" || typeof first !== "number") return void 0;
+		let length = dict.entries.get("Length");
+		if (isRef(length)) length = followLength ? await this.loadLength(length) : void 0;
+		const decoded = await decodeStream(this.bytes, dict, obj.streamStart, typeof length === "number" ? length : void 0);
+		const pairs = [];
+		let at = 0;
+		for (let i = 0; i < n; i++) {
+			const a = parseValue(decoded, at);
+			const b = parseValue(decoded, a.end);
+			if (typeof a.value !== "number" || typeof b.value !== "number") return void 0;
+			pairs.push({
+				num: a.value,
+				offset: b.value
+			});
+			at = b.end;
+		}
+		return {
+			decoded,
+			first,
+			pairs
+		};
+	}
+	async loadLength(ref) {
+		try {
+			return await this.load(ref, false);
+		} catch {
+			return;
+		}
+	}
+};
+/** Undefined when the file is encrypted (`/Encrypt` in the trailer) or its xref cannot be read. */
+async function openPdfObjects(bytes) {
+	try {
+		const xref = await readXref(bytes);
+		if (!xref || xref.trailer.entries.has("Encrypt")) return void 0;
+		return new Reader(bytes, xref);
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/model/annotations/embedded-fields.ts
+/**
+* `a` with `fields` merged in: `callout`, `fringe`, `head` and the font keys of `defaultStyle`
+* on a FreeText, `icon` on a note. Undefined when `a` is not embedded, the fields do not fit its
+* type, or the result fails the schema.
+*/
+function withEmbeddedFields(a, fields) {
+	if (a.source !== "pdf") return void 0;
+	const { callout, fringe, head, icon, font } = fields;
+	let candidate;
+	if (a.type === "text") {
+		if (icon === void 0 || callout || fringe || head !== void 0 || font) return void 0;
+		candidate = {
+			...a,
+			icon
+		};
+	} else if (a.type === "freetext") {
+		if (icon !== void 0) return void 0;
+		candidate = {
+			...a,
+			...callout ? { callout } : {},
+			...fringe ? { fringe } : {},
+			...head !== void 0 ? { head } : {},
+			defaultStyle: {
+				...a.defaultStyle,
+				...font
+			}
+		};
+	} else return;
+	const parsed = AnnotationSchema.safeParse(candidate);
+	return parsed.success ? parsed.data : void 0;
+}
+/**
+* Reads every target once, calling `getData` only if a target names an annotation in
+* `annotations` by an object reference, and returns the fields read, by id. A target the file
+* adds nothing to, or whose fields would fail the schema, is left out. Never throws: any
+* failure leaves the annotations as they are.
+*/
+async function readEmbeddedFields(annotations, targets, getData) {
+	const read = /* @__PURE__ */ new Map();
+	if (targets.length === 0) return read;
+	try {
+		const byId = new Map(annotations.map((a) => [a.id, a]));
+		const work = targets.flatMap((target) => {
+			const current = byId.get(target.id);
+			const ref = refOfPdfjsId(target.id.split(":")[2] ?? "");
+			return current && ref ? [{
+				target,
+				current,
+				ref
+			}] : [];
+		});
+		if (work.length === 0) return read;
+		const objs = await openPdfObjects(await getData());
+		if (!objs) return read;
+		for (const { target, current, ref } of work) try {
+			const fields = await readFields(objs, target, ref);
+			if (fields && withEmbeddedFields(current, fields)) read.set(current.id, fields);
+		} catch {}
+	} catch {}
+	return read;
+}
+async function readFields(objs, target, ref) {
+	if (target.subtype === "Text") {
+		const icon = await readTextIcon(objs, ref);
+		return icon === void 0 ? void 0 : { icon };
+	}
+	const fields = await readFreeTextFields(objs, ref, target.rect, target.daFont);
+	return Object.keys(fields).length > 0 ? fields : void 0;
+}
+//#endregion
+//#region src/model/env.ts
+/** True only when the build or runtime says production; browsers without `process` count as dev. */
+function isProduction() {
+	try {
+		return process.env.NODE_ENV === "production";
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/model/annotations/history.ts
+/**
+* Snapshot-based undo and redo over an uncontrolled store.
+*
+* In controlled mode the host owns the list, so history is the host's concern (the Vue layer
+* offers `useHistory`). There `createHistory` returns an inert History: `canUndo` and `canRedo`
+* stay false, `undo` and `redo` do nothing, and nothing is recorded.
+*/
+function createHistory(store, opts = {}) {
+	const canUndo = writable(false);
+	const canRedo = writable(false);
+	if (store.mode === "controlled") return {
+		canUndo: readonly(canUndo),
+		canRedo: readonly(canRedo),
+		undo() {},
+		redo() {},
+		clear() {},
+		batch(fn) {
+			fn();
+		},
+		destroy() {}
+	};
+	const limit = opts.limit ?? 200;
+	const undoStack = [];
+	const redoStack = [];
+	let previous = store.list.get();
+	let replaying = false;
+	/** Open batch depth; while above zero, changes update `previous` but push no entry. */
+	let depth = 0;
+	/** The list when the outermost batch opened (or was restarted by a replace). */
+	let batchStart = null;
+	const sync = () => {
+		canUndo.set(undoStack.length > 0);
+		canRedo.set(redoStack.length > 0);
+	};
+	let destroyed = false;
+	const unsubscribe = store.on("change", (change) => {
+		const current = store.list.get();
+		if (replaying || change.kind === "replace" && change.reason === "history") {
+			previous = current;
+			return;
+		}
+		if (change.kind === "replace" && change.reason === "embedded") {
+			const fill = (list) => list.map((a) => {
+				const f = change.fields.get(a.id);
+				return f && withEmbeddedFields(a, f) || a;
+			});
+			for (const entry of [...undoStack, ...redoStack]) {
+				entry.before = fill(entry.before);
+				entry.after = fill(entry.after);
+			}
+			if (batchStart) batchStart = fill(batchStart);
+			previous = current;
+			return;
+		}
+		if (change.kind === "replace") {
+			undoStack.length = 0;
+			redoStack.length = 0;
+			previous = current;
+			if (depth > 0) batchStart = current;
+			sync();
+			return;
+		}
+		if (depth > 0) {
+			previous = current;
+			return;
+		}
+		undoStack.push({
+			before: previous,
+			after: current
+		});
+		if (undoStack.length > limit) undoStack.shift();
+		redoStack.length = 0;
+		previous = current;
+		sync();
+	});
+	const apply = (list) => {
+		replaying = true;
+		try {
+			store.replaceAll([...list], "history");
+		} finally {
+			replaying = false;
+		}
+	};
+	return {
+		canUndo: readonly(canUndo),
+		canRedo: readonly(canRedo),
+		undo() {
+			const entry = undoStack.pop();
+			if (destroyed || !entry) return;
+			redoStack.push(entry);
+			apply(entry.before);
+			sync();
+		},
+		redo() {
+			const entry = redoStack.pop();
+			if (destroyed || !entry) return;
+			undoStack.push(entry);
+			apply(entry.after);
+			sync();
+		},
+		batch(fn) {
+			if (destroyed) {
+				fn();
+				return;
+			}
+			if (depth++ === 0) batchStart = store.list.get();
+			try {
+				const result = fn();
+				if (result !== null && typeof result === "object" && typeof result.then === "function" && !isProduction()) console.warn("[inkbar] history.batch(fn): fn returned a promise. Changes after its first await are not part of the batch.");
+			} finally {
+				if (--depth === 0 && !destroyed) {
+					const before = batchStart;
+					batchStart = null;
+					const after = store.list.get();
+					if (before && !sameAnnotations(before, after)) {
+						undoStack.push({
+							before,
+							after
+						});
+						if (undoStack.length > limit) undoStack.shift();
+						redoStack.length = 0;
+						sync();
+					}
+				}
+			}
+		},
+		destroy() {
+			destroyed = true;
+			batchStart = null;
+			unsubscribe();
+			undoStack.length = 0;
+			redoStack.length = 0;
+			sync();
+		},
+		clear() {
+			undoStack.length = 0;
+			redoStack.length = 0;
+			previous = store.list.get();
+			sync();
+		}
+	};
+}
+/** The same annotation objects in the same order. */
+function sameAnnotations(a, b) {
+	return a === b || a.length === b.length && a.every((x, i) => x === b[i]);
+}
+//#endregion
+//#region src/model/annotations/gloss-mapping.ts
+const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+/** `rest` with `own` merged into a copy of its `custom.inkbar`; `own` wins. */
+function withCustom(rest, own) {
+	const custom = isObject(rest.custom) ? rest.custom : {};
+	const inkbar = isObject(custom.inkbar) ? custom.inkbar : {};
+	return {
+		...rest,
+		custom: {
+			...custom,
+			inkbar: {
+				...inkbar,
+				...own
+			}
+		}
+	};
+}
+/**
+* An annotation as a Gloss file writes it. Gloss has no loupe or mask and no pen pressure or
+* free-text border colour, so these go under `custom.inkbar`, with loupes and masks written as
+* the circle or square they draw.
+*/
+function toFile(annotation) {
+	switch (annotation.type) {
+		case "ink": {
+			const { pressure, ...rest } = annotation;
+			return pressure ? withCustom(rest, { pressure }) : rest;
+		}
+		case "freetext": {
+			const { borderColor, ...rest } = annotation;
+			return borderColor ? withCustom(rest, { borderColor }) : rest;
+		}
+		case "loupe": {
+			const { magnification, ...rest } = annotation;
+			return withCustom({
+				...rest,
+				type: "circle"
+			}, {
+				type: "loupe",
+				magnification
+			});
+		}
+		case "mask": {
+			const { shape, dim, ...rest } = annotation;
+			return withCustom({
+				...rest,
+				type: shape === "ellipse" ? "circle" : "square"
+			}, {
+				type: "mask",
+				dim
+			});
+		}
+		default: return annotation;
+	}
+}
+/**
+* Moves `keys` from `custom.inkbar` to the top level of `raw`, replacing any top-level value
+* (an absent key deletes it), then drops `custom.inkbar`, and `custom`, if that leaves them
+* empty. Everything else under `custom` stays as it was.
+*/
+function lift(raw, inkbar, keys, extra = {}) {
+	const item = {
+		...raw,
+		...extra
+	};
+	const left = { ...inkbar };
+	let consumed = false;
+	for (const key of keys) {
+		delete item[key];
+		if (key in left) {
+			item[key] = left[key];
+			delete left[key];
+			consumed = true;
+		}
+	}
+	if (!consumed || !isObject(raw.custom)) return item;
+	const { inkbar: _inkbar, ...others } = raw.custom;
+	const custom = Object.keys(left).length > 0 ? {
+		...others,
+		inkbar: left
+	} : others;
+	if (Object.keys(custom).length > 0) item.custom = custom;
+	else delete item.custom;
+	return item;
+}
+/**
+* A raw file item as Inkbar parses it: Inkbar's own data moves out of `custom.inkbar`. An item
+* it doesn't recognise passes through unchanged.
+*/
+function fromFile(raw) {
+	const inkbar = isObject(raw.custom) && isObject(raw.custom.inkbar) ? raw.custom.inkbar : {};
+	const from = (keys, extra) => ({
+		item: lift(raw, inkbar, keys, extra),
+		lifted: keys
+	});
+	const unchanged = {
+		item: raw,
+		lifted: []
+	};
+	switch (raw.type) {
+		case "ink": return from(["pressure"]);
+		case "freetext": return from(["borderColor"]);
+		case "circle":
+			if (inkbar.type === "loupe") return from(["type", "magnification"]);
+			if (inkbar.type === "mask") return from(["type", "dim"], { shape: "ellipse" });
+			return unchanged;
+		case "square":
+			if (inkbar.type === "mask") return from(["type", "dim"], { shape: "rect" });
+			return unchanged;
+		default: return unchanged;
+	}
+}
+//#endregion
+//#region src/model/annotations/json.ts
+/**
+* @internal The Gloss types this core parses, taken from its own schemas rather than Gloss's
+* list, so a type a later Gloss adds is still treated as foreign here. Loupes and masks are
+* Inkbar's own types: a file writes them as circles and squares, so a `loupe` or `mask` item is
+* foreign too.
+*/
+const KNOWN_TYPES = new Set(ExportedAnnotationSchema.options.flatMap((o) => [...o.shape.type._zod.values]).filter((type) => type !== "loupe" && type !== "mask"));
+/**
+* Session annotations plus any preserved foreign items. Embedded (`source: 'pdf'`) ones stay in
+* the file. `source` and `locked` are viewer state and are left out.
+*
+* The result is a JSON copy (`JSON.parse(JSON.stringify(...))`), the same data a serialised
+* export would carry: editing it never touches the store, and values JSON cannot hold, such as
+* functions or `undefined` inside `custom`, are left out exactly as `JSON.stringify` would.
+*
+* Gloss has no loupe or mask, pen pressure or free-text border colour, so Inkbar writes these
+* under `custom.inkbar`, with loupes and masks as the circle or square they draw. Every other key
+* under `custom` goes out as it is.
+*
+* The result validates against the Gloss schema (`gloss-format/schema.json`). Foreign items
+* validate as unknown annotations while their type is one Gloss does not define.
+*/
+function exportAnnotations(store, preserved = [], documentKey) {
+	const session = store.list.get().filter((a) => a.source === "session").map(({ source: _source, locked: _locked, ...rest }) => toFile(rest));
+	return {
+		format: GLOSS_FORMAT$1,
+		version: GLOSS_VERSION$1,
+		...documentKey === void 0 ? {} : { documentKey },
+		annotations: JSON.parse(JSON.stringify([...session, ...preserved]))
+	};
+}
+/**
+* Validates the envelope (throws a TypeError when it is not a gloss v1 document),
+* then each item on its own. Embedded annotations are never touched; imported items become
+* session annotations.
+*/
+function importAnnotations(store, data, opts) {
+	const plan = planImport(store, data, opts);
+	plan.apply();
+	return plan.result;
+}
+/**
+* @internal Validation half of `importAnnotations`, so the document can record foreign items
+* before the store publishes the change.
+*
+* Ids are unique across the payload: the first item with an id claims it, and later ones (known
+* or foreign) are reported in `errors`, even when the first was itself rejected. An id that
+* matches an embedded annotation is rejected for known and foreign items alike. In `merge` mode an incoming item replaces whatever session
+* annotation has its id, whether the incoming item is known or foreign.
+*/
+function planImport(store, data, opts) {
+	const raw = typeof data === "string" ? JSON.parse(data) : data;
+	const envelope = AnnotationDocumentSchema.safeParse(raw);
+	if (!envelope.success) throw new TypeError(`Expected a ${GLOSS_FORMAT$1} v${GLOSS_VERSION$1} document: ${envelope.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ")}`);
+	const embeddedIds = new Set(store.list.get().filter((a) => a.source === "pdf").map((a) => a.id));
+	const result = {
+		imported: 0,
+		unknown: [],
+		errors: []
+	};
+	const incoming = [];
+	/** id -> index of the first item that used it, whether that item was accepted or not. */
+	const seen = /* @__PURE__ */ new Map();
+	/** Ids the import actually brings in. */
+	const accepted = /* @__PURE__ */ new Set();
+	/**
+	* Reserves `id` for the item at `index`. Later items with the same id are duplicates even
+	* when this one is rejected for reusing an embedded id.
+	*/
+	const claim = (id, index) => {
+		const first = seen.get(id);
+		if (first !== void 0) {
+			result.errors.push({
+				index,
+				issues: [`id: duplicate id "${id}", already used by item ${first}`]
+			});
+			return false;
+		}
+		seen.set(id, index);
+		if (embeddedIds.has(id)) {
+			result.errors.push({
+				index,
+				issues: ["id: matches an annotation embedded in the PDF, which import never replaces"]
+			});
+			return false;
+		}
+		accepted.add(id);
+		return true;
+	};
+	envelope.data.annotations.forEach((raw, index) => {
+		const type = raw?.type;
+		if (typeof type === "string" && !KNOWN_TYPES.has(type)) {
+			if (!isForeign(raw)) result.errors.push({
+				index,
+				issues: [`type: unknown type "${type}" needs a string id and a numeric page to be preserved`]
+			});
+			else if (claim(raw.id, index)) result.unknown.push(raw);
+			return;
+		}
+		const { item, lifted } = isRecord(raw) && typeof type === "string" ? fromFile(raw) : {
+			item: raw,
+			lifted: []
+		};
+		const parsed = ExportedAnnotationSchema.safeParse(item);
+		if (!parsed.success) {
+			result.errors.push({
+				index,
+				issues: parsed.error.issues.map((i) => {
+					const path = i.path.join(".");
+					return `${typeof i.path[0] === "string" && lifted.includes(i.path[0]) ? `custom.inkbar.${path}` : path}: ${i.message}`;
+				})
+			});
+			return;
+		}
+		if (!claim(parsed.data.id, index)) return;
+		incoming.push({
+			...parsed.data,
+			source: "session"
+		});
+		result.imported++;
+	});
+	if (result.unknown.length > 0 && !isProduction()) {
+		const types = [...new Set(result.unknown.map((u) => u.type))];
+		console.warn(`[inkbar] importAnnotations kept ${result.unknown.length} annotation(s) of unknown type (${types.join(", ")}). They are not shown, and exportAnnotations writes them back out.`);
+	}
+	const ids = accepted;
+	return {
+		result,
+		ids,
+		apply() {
+			const current = store.list.get();
+			const embedded = current.filter((a) => a.source === "pdf");
+			if (opts.mode === "replace") {
+				store.replaceAll([...embedded, ...incoming], "import");
+				return;
+			}
+			const byId = new Map(current.filter((a) => a.source === "session" && !ids.has(a.id)).map((a) => [a.id, a]));
+			for (const a of incoming) byId.set(a.id, a);
+			store.replaceAll([...embedded, ...byId.values()], "import");
+		}
+	};
+}
+function isRecord(item) {
+	return typeof item === "object" && item !== null && !Array.isArray(item);
+}
+function isForeign(item) {
+	if (!isRecord(item)) return false;
+	const { type, id, page } = item;
+	return typeof type === "string" && typeof id === "string" && typeof page === "number";
+}
+//#endregion
+//#region src/model/annotations/store.ts
+/** Keys a locked annotation refuses to change. */
+const LOCKED_KEYS = /* @__PURE__ */ new Set([
+	"page",
+	"rect",
+	"quads",
+	"inklist",
+	"start",
+	"end",
+	"vertices",
+	"callout",
+	"contents",
+	"imagedata",
+	"rotation"
+]);
+function keepKey(target, from, key) {
+	if (Object.prototype.hasOwnProperty.call(from, key)) target[key] = from[key];
+	else delete target[key];
+}
+/** `proposed` as a replacement for embedded `current`, with what the file owns kept from `current`. */
+function guardEmbedded(current, proposed) {
+	if (proposed === current) return current;
+	if (proposed.type !== current.type) return current;
+	const candidate = {
+		...proposed,
+		id: current.id,
+		createdAt: current.createdAt,
+		source: "pdf"
+	};
+	keepKey(candidate, current, "locked");
+	if (current.locked) for (const key of LOCKED_KEYS) keepKey(candidate, current, key);
+	const parsed = AnnotationSchema.safeParse(candidate);
+	return parsed.success ? parsed.data : current;
+}
+function deriveRect(input) {
+	switch (input.type) {
+		case "highlight":
+		case "underline":
+		case "strikeout":
+		case "squiggly": return unionRects(input.quads.map(rectFromQuad));
+		case "redact":
+			if (input.quads) return unionRects(input.quads.map(rectFromQuad));
+			break;
+		case "ink": {
+			const pad = (input.width ?? 2) / 2;
+			const r = bounds(input.inklist.flat());
+			return {
+				x: r.x - pad,
+				y: r.y - pad,
+				width: r.width + pad * 2,
+				height: r.height + pad * 2
+			};
+		}
+		case "line": return bounds([input.start, input.end]);
+		case "polyline":
+		case "polygon": return bounds(input.vertices);
+	}
+	if (input.rect) return input.rect;
+	throw new TypeError(`rect is required for ${input.type}`);
+}
+function bounds(pts) {
+	const xs = pts.map((p) => p.x);
+	const ys = pts.map((p) => p.y);
+	const x = Math.min(...xs);
+	const y = Math.min(...ys);
+	return {
+		x,
+		y,
+		width: Math.max(...xs) - x,
+		height: Math.max(...ys) - y
+	};
+}
+/** `o` without its `undefined` values. */
+function withoutUndefined(o) {
+	return Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
+}
+/**
+* A `defaultStyle` patch merges one level deep into the current one, so changing the weight
+* keeps the font and size. An `undefined` value removes its key.
+*/
+function mergedStyle(before, patch) {
+	const next = patch.defaultStyle;
+	if (before.type !== "freetext" || next === void 0 || next === null) return {};
+	return { defaultStyle: withoutUndefined({
+		...before.defaultStyle,
+		...next
+	}) };
+}
+/** Pending-map key; only annotation changes are tracked, and the prefix keeps ids apart from any other slot. */
+function changeKey(change) {
+	return `annotation:${change.kind === "update" ? change.id : change.annotation.id}`;
+}
+/** Structural equality for plain JSON values, ignoring `modifiedAt` at the top level. */
+function sameIgnoringModifiedAt(a, b) {
+	const { modifiedAt: _a, ...restA } = a;
+	const { modifiedAt: _b, ...restB } = b;
+	return deepEqual(restA, restB);
+}
+function deepEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	if (Array.isArray(a) !== Array.isArray(b)) return false;
+	const ka = Object.keys(a);
+	const kb = Object.keys(b);
+	if (ka.length !== kb.length) return false;
+	return ka.every((k) => Object.prototype.hasOwnProperty.call(b, k) && deepEqual(a[k], b[k]));
+}
+function isApplied(change, current) {
+	switch (change.kind) {
+		case "add": return current.some((a) => a.id === change.annotation.id);
+		case "remove": return !current.some((a) => a.id === change.annotation.id);
+		case "update": {
+			const mine = current.find((a) => a.id === change.id);
+			if (!mine) return false;
+			return mine === change.after || sameIgnoringModifiedAt(mine, change.after);
+		}
+		case "replace": return true;
+	}
+}
+function createAnnotationStore(opts) {
+	const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+	const nextId = opts.id ?? (() => v7());
+	const list = writable([...opts.mode.initial ?? []]);
+	const selection = writable([]);
+	const emitter = new Emitter();
+	const controlled = opts.mode.mode === "controlled" ? opts.mode : void 0;
+	const pending = /* @__PURE__ */ new Map();
+	/**
+	* Controlled mode: the list as the store last proposed it, embedded items included. Later
+	* proposals build on it, so several mutations in a row (one highlight per page, a bulk
+	* remove, add then select) all reach the host. It resets to the applied list when the host
+	* pushes a value or a pending change's check fires without one.
+	*/
+	let proposed;
+	let destroyed = false;
+	/** What mutations build on: the pending proposal in controlled mode, else the list. */
+	const basis = () => proposed ?? list.get();
+	const findIn = (items, id) => items.find((a) => a.id === id);
+	function completeInput(input) {
+		const ts = now();
+		const candidate = {
+			...input,
+			id: input.id ?? nextId(),
+			rect: input.rect ?? deriveRect(input),
+			color: input.color ?? opts.defaults.color(input.type),
+			opacity: input.opacity ?? opts.defaults.opacity(input.type),
+			createdAt: ts,
+			modifiedAt: ts,
+			source: "session"
+		};
+		if (input.type === "freetext") {
+			if (input.color === void 0) delete candidate.color;
+			candidate.defaultStyle = {
+				color: opts.defaults.color("freetext"),
+				...withoutUndefined(input.defaultStyle ?? {})
+			};
+		}
+		if (input.type === "redact") {
+			if (input.interiorColor === void 0) candidate.interiorColor = opts.defaults.fill();
+		}
+		return AnnotationSchema.parse(candidate);
+	}
+	function clearPending(key) {
+		const entry = pending.get(key);
+		if (!entry) return;
+		clearTimeout(entry.timer);
+		pending.delete(key);
+	}
+	function warnIfIgnored(key) {
+		const entry = pending.get(key);
+		if (!entry) return;
+		pending.delete(key);
+		if (pending.size === 0) proposed = void 0;
+		pruneSelection(basis());
+		if (isApplied(entry.change, list.get()) || isProduction()) return;
+		console.warn(`[inkbar] ControlledMutationIgnored: the host did not apply a ${entry.change.kind} for annotation ${entry.id}. In controlled mode, pass the list from onChange back into the store.`);
+	}
+	function commit(next, change) {
+		if (controlled) {
+			if (change.kind !== "replace") {
+				const key = changeKey(change);
+				clearPending(key);
+				const entry = {
+					id: change.kind === "update" ? change.id : change.annotation.id,
+					change,
+					timer: setTimeout(() => {
+						entry.timer = setTimeout(() => {
+							warnIfIgnored(key);
+						}, 0);
+					}, 0)
+				};
+				pending.set(key, entry);
+			}
+			proposed = change.kind === "replace" ? [...list.get().filter((a) => a.source === "pdf"), ...next.filter((a) => a.source !== "pdf")] : next;
+			controlled.onChange(next.filter((a) => a.source !== "pdf"), change);
+			return;
+		}
+		list.set(next);
+		emitter.emit("change", change);
+	}
+	/**
+	* Uncontrolled `replaceAll` cannot drop or forge embedded annotations: every current embedded
+	* item stays (taking the list's version of it, guarded like `update`, when the list has one),
+	* and items claiming `source: 'pdf'` that the store does not hold are dropped. History
+	* snapshots contain the embedded items, so undo and redo of their edits still work.
+	*/
+	function withEmbedded(proposed) {
+		const current = new Map(list.get().filter((a) => a.source === "pdf").map((a) => [a.id, a]));
+		const seen = /* @__PURE__ */ new Set();
+		const out = [];
+		for (const a of proposed) {
+			const mine = current.get(a.id);
+			if (mine) {
+				if (!seen.has(a.id)) out.push(guardEmbedded(mine, a));
+				seen.add(a.id);
+			} else if (a.source !== "pdf") out.push(a);
+		}
+		return [...[...current.values()].filter((a) => !seen.has(a.id)), ...out];
+	}
+	function pruneSelection(next) {
+		const known = new Set(next.map((a) => a.id));
+		const current = selection.get();
+		if (current.every((id) => known.has(id))) return;
+		selection.set(current.filter((id) => known.has(id)));
+	}
+	return {
+		mode: opts.mode.mode,
+		list: readonly(list),
+		selection: readonly(selection),
+		defaults: opts.defaults,
+		get: (id) => list.get().find((a) => a.id === id),
+		_getProposed: (id) => findIn(basis(), id),
+		byPage: (page) => list.get().filter((a) => a.page === page),
+		completeInput,
+		add(input) {
+			const a = completeInput(input);
+			if (findIn(basis(), a.id)) throw new Error(`An annotation with id ${a.id} already exists`);
+			if (destroyed) return a;
+			const replaced = a.type === "mask" ? basis().filter((x) => x.type === "mask" && x.page === a.page && x.source !== "pdf") : [];
+			const gone = new Set(replaced.map((x) => x.id));
+			for (const x of replaced) clearPending(changeKey({
+				kind: "add",
+				annotation: x
+			}));
+			commit([...basis().filter((x) => !gone.has(x.id)), a], {
+				kind: "add",
+				annotation: a
+			});
+			if (!controlled && gone.size > 0) pruneSelection(list.get());
+			return a;
+		},
+		update(id, patch) {
+			const before = findIn(basis(), id);
+			if (destroyed || !before) return void 0;
+			if (before.locked && Object.keys(patch).some((k) => LOCKED_KEYS.has(k))) return void 0;
+			const candidate = {
+				...before,
+				...patch,
+				...mergedStyle(before, patch),
+				id: before.id,
+				type: before.type,
+				createdAt: before.createdAt,
+				source: before.source,
+				modifiedAt: now()
+			};
+			if (before.source === "pdf") keepKey(candidate, before, "locked");
+			const after = AnnotationSchema.parse(candidate);
+			const swap = (items) => items.map((a) => a.id === id ? after : a);
+			const next = swap(basis());
+			const change = {
+				kind: "update",
+				id,
+				before,
+				after
+			};
+			if (controlled && before.source === "pdf") {
+				list.set(swap(list.get()));
+				if (proposed) proposed = next;
+				emitter.emit("change", change);
+			} else commit(next, change);
+			return after;
+		},
+		remove(id) {
+			const items = basis();
+			const target = findIn(items, id);
+			if (destroyed || !target || target.locked) return false;
+			const doomed = /* @__PURE__ */ new Set([id]);
+			let grew = true;
+			while (grew) {
+				grew = false;
+				for (const a of items) if (a.inReplyTo !== void 0 && doomed.has(a.inReplyTo) && !doomed.has(a.id)) {
+					doomed.add(a.id);
+					grew = true;
+				}
+			}
+			const next = items.filter((a) => !doomed.has(a.id));
+			commit(next, {
+				kind: "remove",
+				annotation: target,
+				removed: [target, ...items.filter((a) => a.id !== id && doomed.has(a.id))]
+			});
+			if (!controlled) pruneSelection(next);
+			return true;
+		},
+		select(ids) {
+			const known = new Set(basis().map((a) => a.id));
+			selection.set(ids.filter((id) => known.has(id)));
+		},
+		replaceAll(list, reason) {
+			if (destroyed) return;
+			const next = controlled ? [...list] : withEmbedded(list);
+			commit(next, {
+				kind: "replace",
+				reason
+			});
+			if (!controlled) pruneSelection(next);
+		},
+		setControlledValue(value) {
+			if (!controlled) throw new TypeError("setControlledValue is only valid in controlled mode");
+			if (destroyed) return;
+			const embedded = list.get().filter((a) => a.source === "pdf");
+			const embeddedIds = new Set(embedded.map((a) => a.id));
+			const next = [...embedded, ...value.filter((a) => !embeddedIds.has(a.id))];
+			list.set(next);
+			proposed = void 0;
+			for (const [key, entry] of [...pending]) if (isApplied(entry.change, next)) clearPending(key);
+			pruneSelection(next);
+			emitter.emit("change", {
+				kind: "replace",
+				reason: "sync"
+			});
+		},
+		_setEmbedded(items) {
+			if (destroyed) return;
+			const ids = new Set(items.map((a) => a.id));
+			const next = [...items, ...list.get().filter((a) => a.source !== "pdf" && !ids.has(a.id))];
+			proposed = void 0;
+			list.set(next);
+			pruneSelection(next);
+			emitter.emit("change", {
+				kind: "replace",
+				reason: "import"
+			});
+		},
+		_patchEmbedded(fields) {
+			if (destroyed) return;
+			const applied = /* @__PURE__ */ new Map();
+			const merge = (items) => items.map((a) => {
+				const f = a.source === "pdf" ? fields.get(a.id) : void 0;
+				const merged = f && withEmbeddedFields(a, f);
+				if (!merged) return a;
+				applied.set(a.id, f);
+				return merged;
+			});
+			const next = merge(list.get());
+			if (applied.size === 0) return;
+			list.set(next);
+			if (proposed) proposed = merge(proposed);
+			emitter.emit("change", {
+				kind: "replace",
+				reason: "embedded",
+				fields: applied
+			});
+		},
+		on: (event, fn) => emitter.on(event, fn),
+		destroy() {
+			destroyed = true;
+			proposed = void 0;
+			for (const key of [...pending.keys()]) clearPending(key);
+			emitter.clear();
+		}
+	};
+}
+//#endregion
+//#region src/model/page-cache.ts
+function createPageCache(fetch) {
+	const cache = /* @__PURE__ */ new Map();
+	return {
+		get(index) {
+			const cached = cache.get(index);
+			if (cached) return cached;
+			const fetched = fetch(index);
+			cache.set(index, fetched);
+			fetched.catch(() => {
+				if (cache.get(index) === fetched) cache.delete(index);
+			});
+			return fetched;
+		},
+		clear: () => cache.clear()
+	};
+}
+//#endregion
+//#region src/model/pages.ts
+function pageInfoFromProxy(page, index) {
+	const [x1, y1, x2, y2] = page.view;
+	const box = {
+		x: Math.min(x1, x2),
+		y: Math.min(y1, y2),
+		width: Math.abs(x2 - x1),
+		height: Math.abs(y2 - y1)
+	};
+	return {
+		index,
+		box,
+		rotate: normaliseRotation(page.rotate),
+		userUnit: page.userUnit > 0 ? page.userUnit : 1,
+		width: box.width,
+		height: box.height
+	};
+}
+/** PDF.js already rejects /Rotate values that are not multiples of 90; this also folds negatives. */
+function normaliseRotation(rotate) {
+	return (Math.round(rotate / 90) * 90 % 360 + 360) % 360;
+}
+//#endregion
+//#region src/model/source.ts
+function resolveSource(src, fetchImpl = globalThis.fetch) {
+	if (typeof src === "string") return {
+		key: src,
+		bytes: () => fetchBytes(src, fetchImpl)
+	};
+	if (src instanceof ArrayBuffer || src instanceof Uint8Array) {
+		const data = toBytes(src);
+		return {
+			key: `bytes:${v7()}`,
+			bytes: () => Promise.resolve(data.slice())
+		};
+	}
+	if ("url" in src) {
+		const { url } = src;
+		return {
+			key: src.key,
+			bytes: () => fetchBytes(url, fetchImpl)
+		};
+	}
+	if ("data" in src) {
+		const data = toBytes(src.data);
+		return {
+			key: src.key,
+			bytes: () => Promise.resolve(data.slice())
+		};
+	}
+	const blob = src;
+	return {
+		key: `bytes:${v7()}`,
+		bytes: async () => new Uint8Array(await blob.arrayBuffer())
+	};
+}
+/**
+* A view over the host's bytes. `bytes()` hands PDF.js a copy each time: PDF.js transfers the
+* buffer it is given to its worker, which would empty the host's array and break a reopen
+* (a password retry, for one).
+*/
+function toBytes(data) {
+	return data instanceof Uint8Array ? data : new Uint8Array(data);
+}
+async function fetchBytes(url, fetchImpl) {
+	if (typeof fetchImpl !== "function") throw new InkError("SourceFetchFailed", "No fetch implementation available for URL sources", { url });
+	let res;
+	try {
+		res = await fetchImpl(url, { credentials: "same-origin" });
+	} catch (cause) {
+		throw new InkError("SourceFetchFailed", `Could not fetch ${url}`, { url }, cause);
+	}
+	if (!res.ok) throw new InkError("SourceFetchFailed", `Fetching ${url} returned HTTP ${res.status}`, {
+		url,
+		status: res.status
+	});
+	try {
+		return new Uint8Array(await res.arrayBuffer());
+	} catch (cause) {
+		throw new InkError("SourceFetchFailed", `Reading the body of ${url} failed`, { url }, cause);
+	}
+}
+//#endregion
+//#region src/model/text.ts
+/** Fractions of the font size used when PDF.js has no usable metrics for the font. */
+const FALLBACK_ASCENT = .75;
+const FALLBACK_DESCENT = .25;
+/**
+* Converts `getTextContent()` output to user-space boxes.
+*
+* For an item with transform [a, b, c, d, e, f] (already in user space):
+* - (e, f) is the start of the run on the baseline;
+* - u = (a, b) / |(a, b)| is the baseline direction, along which the run advances `width`;
+* - v = (c, d) / |(c, d)| is the glyph-up direction, and `fontSize` = |(c, d)|;
+* - the box spans from `descent * fontSize` below the baseline to `ascent * fontSize` above it,
+*   using the font's ascent/descent from `styles` when PDF.js provides them, else 0.75 / 0.25.
+*
+* So p3 = (e, f) - v * descent * fontSize, p4 = p3 + u * width, p1 = p3 + v * (ascent + descent) * fontSize,
+* p2 = p4 + (p1 - p3). `rect` is the axis-aligned bounding box of the quad.
+*/
+function textContentFromPdfjs(page, tc) {
+	const items = [];
+	for (const raw of tc.items) {
+		if (!("str" in raw)) continue;
+		const item = raw;
+		const [a, b, c, d, e, f] = item.transform;
+		const baseLen = Math.hypot(a, b);
+		const fontSize = Math.hypot(c, d);
+		const u = baseLen === 0 ? {
+			x: 1,
+			y: 0
+		} : {
+			x: a / baseLen,
+			y: b / baseLen
+		};
+		const v = fontSize === 0 ? {
+			x: -u.y,
+			y: u.x
+		} : {
+			x: c / fontSize,
+			y: d / fontSize
+		};
+		const { ascent, descent } = metrics(tc.styles[item.fontName]);
+		const below = descent * fontSize;
+		const total = (ascent + descent) * fontSize;
+		const w = item.width;
+		const p3 = {
+			x: e - v.x * below,
+			y: f - v.y * below
+		};
+		const p4 = {
+			x: p3.x + u.x * w,
+			y: p3.y + u.y * w
+		};
+		const quad = {
+			p1: {
+				x: p3.x + v.x * total,
+				y: p3.y + v.y * total
+			},
+			p2: {
+				x: p4.x + v.x * total,
+				y: p4.y + v.y * total
+			},
+			p3,
+			p4
+		};
+		items.push({
+			str: item.str,
+			dir: isDir(item.dir) ? item.dir : "ltr",
+			fontName: item.fontName,
+			fontSize,
+			hasEOL: item.hasEOL,
+			quad,
+			rect: rectFromQuad(quad)
+		});
+	}
+	return {
+		page,
+		items
+	};
+}
+function metrics(style) {
+	if (!style || style.vertical) return {
+		ascent: FALLBACK_ASCENT,
+		descent: FALLBACK_DESCENT
+	};
+	const ascent = style.ascent;
+	const descent = Math.abs(style.descent);
+	if (!(ascent > 0) || !Number.isFinite(descent) || ascent + descent <= 0) return {
+		ascent: FALLBACK_ASCENT,
+		descent: FALLBACK_DESCENT
+	};
+	return {
+		ascent,
+		descent
+	};
+}
+function isDir(dir) {
+	return dir === "ltr" || dir === "rtl" || dir === "ttb";
+}
+//#endregion
+//#region src/model/document.ts
+/**
+* Opens a document. Resolves once loading has finished, whether it succeeded or not:
+* check `status` or await `ready`, which rejects with the InkError. Only a missing
+* `assets` option (a programmer error) makes this promise itself reject.
+*/
+async function openDocument(source, options) {
+	assertAssets(options?.assets);
+	const resolved = resolveSource(source, options.fetch);
+	const status = writable({ state: "loading" });
+	const pages = [];
+	const info = {
+		pageCount: 0,
+		isEncrypted: false
+	};
+	let pageCache;
+	let destroyed = false;
+	let handles;
+	let destroyTask;
+	const store = createAnnotationStore({
+		mode: options.annotations ?? { mode: "uncontrolled" },
+		defaults: options.defaults ?? staticDefaults
+	});
+	const embedded = [];
+	let preserved = [];
+	/** Embedded annotations whose PDF.js data lacks fields the file holds; read after `ready`. */
+	const targets = [];
+	const destroyedError = () => new InkError("DocumentDestroyed", "The document has been destroyed");
+	const ready = (async () => {
+		const pdfjs = await loadPdfjs(options.assets);
+		const { task, proxy } = await openProxy(pdfjs, await resolved.bytes(), {
+			assets: options.assets,
+			password: options.password,
+			verbosity: options.verbosity
+		});
+		destroyTask = () => task.destroy();
+		const cache = createPageCache((index) => proxy.getPage(index + 1));
+		pageCache = cache;
+		const getPage = (index) => {
+			if (destroyed) return Promise.reject(destroyedError());
+			if (!Number.isInteger(index) || index < 0 || index >= proxy.numPages) return Promise.reject(new InkError("PageOutOfRange", `Page ${index} does not exist`, {
+				index,
+				pageCount: proxy.numPages
+			}));
+			return cache.get(index);
+		};
+		handles = {
+			module: pdfjs,
+			proxy,
+			getPage
+		};
+		const docInfo = (await proxy.getMetadata().catch(() => {}))?.info ?? {};
+		const title = nonEmptyString(docInfo.Title);
+		const author = nonEmptyString(docInfo.Author);
+		if (title !== void 0) info.title = title;
+		if (author !== void 0) info.author = author;
+		info.pageCount = proxy.numPages;
+		info.isEncrypted = docInfo.EncryptFilterName !== null && docInfo.EncryptFilterName !== void 0;
+		for (let i = 0; i < proxy.numPages; i++) pages.push(pageInfoFromProxy(await getPage(i), i));
+		const importedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const perPage = await mapInOrder(proxy.numPages, EMBEDDED_CONCURRENCY, async (i) => {
+			return importEmbeddedPage(i, await (await getPage(i)).getAnnotations().catch(() => {
+				return [];
+			}), importedAt);
+		});
+		embedded.push(...summarise(perPage.map((r) => r.counts)));
+		const fromFile = perPage.flatMap((r) => r.annotations);
+		targets.push(...perPage.flatMap((r) => r.targets));
+		if (fromFile.length > 0) store._setEmbedded(fromFile);
+	})().then(() => {
+		status.set({ state: "ready" });
+	}, (cause) => {
+		const error = isInkError(cause) ? cause : new InkError("InvalidPdf", errorMessage(cause), {}, cause);
+		if (error.code === "PasswordRequired") info.isEncrypted = true;
+		status.set({
+			state: "error",
+			error
+		});
+		throw error;
+	});
+	await ready.catch(() => void 0);
+	const historyOption = options.history ?? true;
+	const historyLimit = historyOption === false ? 0 : historyOption === true ? void 0 : historyOption.limit;
+	const history = createHistory(store, historyLimit === void 0 ? {} : { limit: historyLimit });
+	ready.then(() => {
+		if (destroyed || !handles) return;
+		const { proxy } = handles;
+		readEmbeddedFields(store.list.get(), targets, () => proxy.getData()).then((patched) => {
+			if (!destroyed && patched.size > 0) store._patchEmbedded(patched);
+		}).catch(() => void 0);
+	}, () => void 0);
+	return {
+		key: resolved.key,
+		status: readonly(status),
+		ready,
+		pages,
+		info,
+		async text(page) {
+			if (destroyed) throw destroyedError();
+			if (!handles) throw statusError(status.get());
+			return textContentFromPdfjs(page, await (await handles.getPage(page)).getTextContent());
+		},
+		annotations: store,
+		embedded,
+		history,
+		exportAnnotations(format) {
+			if (format !== "json") throw new TypeError(`Unsupported export format ${String(format)}`);
+			return exportAnnotations(store, preserved, resolved.key);
+		},
+		importAnnotations(data, opts = { mode: "replace" }) {
+			const plan = planImport(store, data, opts);
+			preserved = opts.mode === "replace" ? plan.result.unknown : [...preserved.filter((u) => !plan.ids.has(u.id)), ...plan.result.unknown];
+			plan.apply();
+			return plan.result;
+		},
+		save() {
+			return Promise.reject(new InkError("EngineUnavailable", "Saving needs @inkbar/engine, which is not registered. Use exportAnnotations(\"json\") to keep annotations without writing the PDF."));
+		},
+		destroy() {
+			if (destroyed) return;
+			destroyed = true;
+			history.destroy();
+			store.destroy();
+			pageCache?.clear();
+			if (destroyTask) teardown(destroyTask);
+		},
+		get _pdfjs() {
+			if (!handles) throw statusError(status.get());
+			return handles;
+		}
+	};
+}
+const EMBEDDED_CONCURRENCY = 8;
+/** Runs `task(0..count-1)` with at most `limit` in flight; results come back in index order. */
+async function mapInOrder(count, limit, task) {
+	const results = new Array(count);
+	let next = 0;
+	const worker = async () => {
+		while (next < count) {
+			const i = next++;
+			results[i] = await task(i);
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, count) }, worker));
+	return results;
+}
+function teardown(destroyTask) {
+	destroyTask().catch(() => {});
+}
+function statusError(s) {
+	return s.state === "error" ? s.error : new InkError("InvalidPdf", "The document has not finished loading");
+}
+function nonEmptyString(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+function errorMessage(cause) {
+	if (cause instanceof Error) return cause.message;
+	return String(cause);
+}
+const shift = (p, dx, dy) => ({
+	x: p.x + dx,
+	y: p.y + dy
+});
+/** The geometry patch that translates `a` by (dx, dy) in user space. */
+function translated(a, dx, dy) {
+	const patch = { rect: translateRect(a.rect, dx, dy) };
+	if ("quads" in a && a.quads) patch.quads = a.quads.map((q) => translateQuad(q, dx, dy));
+	if ("callout" in a && a.callout) patch.callout = a.callout.map((p) => shift(p, dx, dy));
+	switch (a.type) {
+		case "line":
+			patch.start = shift(a.start, dx, dy);
+			patch.end = shift(a.end, dx, dy);
+			break;
+		case "polyline":
+		case "polygon":
+			patch.vertices = a.vertices.map((p) => shift(p, dx, dy));
+			break;
+		case "ink": patch.inklist = a.inklist.map((path) => path.map((p) => shift(p, dx, dy)));
+	}
+	return patch;
+}
+/**
+* True when `rect` is the annotation's whole shape, so resizing means changing `rect`: area
+* redactions, free text, squares, circles, stamps, loupes and masks. Text-derived marks (quads), note icons and
+* point-based shapes are not.
+*/
+function hasRectGeometry(a) {
+	switch (a.type) {
+		case "redact": return a.quads === void 0 || a.quads.length === 0;
+		case "freetext":
+		case "square":
+		case "circle":
+		case "stamp":
+		case "loupe":
+		case "mask": return true;
+		default: return false;
+	}
+}
+/**
+* Grows (positive) or shrinks (negative) a rect by `dw` and `dh` points, keeping its top-left
+* corner (user space: left edge and top edge, `y + height`) where it is. Neither side goes
+* below `MIN_SIZE`. With `keepAspect`, the side that changes leads and the other follows it in
+* proportion (the width when both change).
+*/
+function resizedRect(r, dw, dh, keepAspect = false) {
+	let width = Math.max(1, r.width + dw);
+	let height = Math.max(1, r.height + dh);
+	if (keepAspect && r.width > 0 && r.height > 0) {
+		const aspect = r.width / r.height;
+		if (dw !== 0) height = width / aspect;
+		else width = height * aspect;
+		const grow = Math.max(1 / width, 1 / height, 1);
+		width *= grow;
+		height *= grow;
+	}
+	const top = r.y + r.height;
+	return {
+		x: r.x,
+		y: top - height,
+		width,
+		height
+	};
+}
+/**
+* True for highlight, underline, strikeout and squiggly: marks on text, which a drag passes
+* through to text selection and a click selects.
+*/
+function isTextMarkup(a) {
+	return a.type === "highlight" || a.type === "underline" || a.type === "strikeout" || a.type === "squiggly";
+}
+/**
+* True for the point-based shapes a corner handle resizes by scaling their points: polylines,
+* polygons and ink. With `hasRectGeometry`, the annotations that get corner handles.
+*/
+function scalesPoints(a) {
+	return a.type === "polyline" || a.type === "polygon" || a.type === "ink";
+}
+/** True when a corner handle resizes `a`: rect-shaped types and point-based shapes. */
+function hasCornerHandles(a) {
+	return hasRectGeometry(a) || scalesPoints(a);
+}
+/**
+* The geometry patch that maps `a` from the box `from` onto the box `to`, both in user space:
+* `rect`, every point field (quads, ink paths, vertices, line ends, callout) and a free text's
+* `fringe` scale with the boxes. Stroke widths and font sizes stay as they are.
+*/
+function scaled(a, from, to) {
+	const sx = from.width === 0 ? 1 : to.width / from.width;
+	const sy = from.height === 0 ? 1 : to.height / from.height;
+	const map = (p) => ({
+		x: to.x + (p.x - from.x) * sx,
+		y: to.y + (p.y - from.y) * sy
+	});
+	const sameBox = (r) => r.x === from.x && r.y === from.y && r.width === from.width && r.height === from.height;
+	const patch = { rect: sameBox(a.rect) ? { ...to } : {
+		...map(a.rect),
+		width: a.rect.width * sx,
+		height: a.rect.height * sy
+	} };
+	if ("quads" in a && a.quads) patch.quads = a.quads.map((q) => ({
+		p1: map(q.p1),
+		p2: map(q.p2),
+		p3: map(q.p3),
+		p4: map(q.p4)
+	}));
+	if ("callout" in a && a.callout) patch.callout = a.callout.map(map);
+	if (a.type === "freetext" && a.fringe) patch.fringe = {
+		left: a.fringe.left * sx,
+		top: a.fringe.top * sy,
+		right: a.fringe.right * sx,
+		bottom: a.fringe.bottom * sy
+	};
+	switch (a.type) {
+		case "line":
+			patch.start = map(a.start);
+			patch.end = map(a.end);
+			break;
+		case "polyline":
+		case "polygon":
+			patch.vertices = a.vertices.map(map);
+			break;
+		case "ink": patch.inklist = a.inklist.map((path) => path.map(map));
+	}
+	return patch;
+}
+/**
+* The patch that moves one end of a line to `to` and refits `rect` to the new ends, padded by
+* half the stroke width on every side.
+*/
+function movedEndpoint(a, which, to) {
+	const start = which === "start" ? to : a.start;
+	const end = which === "end" ? to : a.end;
+	const pad = a.width / 2;
+	const x = Math.min(start.x, end.x);
+	const y = Math.min(start.y, end.y);
+	return {
+		[which]: { ...to },
+		rect: {
+			x: x - pad,
+			y: y - pad,
+			width: Math.abs(end.x - start.x) + pad * 2,
+			height: Math.abs(end.y - start.y) + pad * 2
+		}
+	};
+}
+/**
+* True for annotations whose resize keeps their aspect ratio without `Shift`: stamps, loupes,
+* masks and signatures (ink with subject `Signature`).
+*/
+function keepsAspect(a) {
+	if (a.type === "stamp" || a.type === "loupe" || a.type === "mask") return true;
+	return a.type === "ink" && a.subject === "Signature";
+}
+/**
+* True for a speech bubble: a standard free-text callout (`intent: 'FreeTextCallout'`, `rect`,
+* `fringe`, `callout`) with Inkbar's `cornerRadius`. Inkbar draws it as one rounded outline with
+* a wedge from where `callout`'s last point meets the box to the tip, `callout[0]`.
+*/
+function isBubble(a) {
+	return a.type === "freetext" && a.intent === "FreeTextCallout" && a.cornerRadius !== void 0 && a.callout !== void 0 && a.callout.length >= 2;
+}
+/** True for a free text with a callout to edit: a speech bubble or a standard callout. */
+function hasCallout(a) {
+	return isBubble(a) || isStandardCallout(a);
+}
+/**
+* The patch that puts a free text's text box at `box`, refitting `rect` and `fringe` around
+* it. A callout's points become `callout` (its own by default) and `rect` holds them too; any
+* other box keeps its fringe, or has `rect` equal to the box without one.
+*/
+function withBox(a, box, callout = a.callout) {
+	if (hasCallout(a) && callout) return {
+		...withCalloutBounds(box, callout, calloutStroke(a).width, a.head),
+		callout: callout.map((p) => ({ ...p }))
+	};
+	const f = a.fringe;
+	if (!f) return { rect: { ...box } };
+	return { rect: {
+		x: box.x - f.left,
+		y: box.y - f.bottom,
+		width: box.width + f.left + f.right,
+		height: box.height + f.bottom + f.top
+	} };
+}
+const EDGES = [
+	"left",
+	"right",
+	"bottom",
+	"top"
+];
+/**
+* The edge of `box` nearest `p`. `bubblePath` (dom/overlay-render.ts) picks the wedge's edge by
+* the same rule in CSS px; change both together.
+*/
+function nearestEdge(p, box) {
+	const gaps = {
+		left: Math.abs(p.x - box.x),
+		right: Math.abs(p.x - (box.x + box.width)),
+		bottom: Math.abs(p.y - box.y),
+		top: Math.abs(p.y - (box.y + box.height))
+	};
+	return EDGES.reduce((best, e) => gaps[e] < gaps[best] ? e : best);
+}
+/** The side of `box` that `p` lies furthest beyond. */
+function edgeBeyond(p, box) {
+	const beyond = {
+		left: box.x - p.x,
+		right: p.x - (box.x + box.width),
+		bottom: box.y - p.y,
+		top: p.y - (box.y + box.height)
+	};
+	return EDGES.reduce((best, e) => beyond[e] > beyond[best] ? e : best);
+}
+/**
+* `p` carried from the box `from` onto the box `to`: it keeps its fraction along the box edge
+* nearest it and its distance off that edge.
+*/
+function onMovedEdge(p, from, to) {
+	const edge = nearestEdge(p, from);
+	const along = (v, start, size, next, nextSize) => next + (size === 0 ? nextSize / 2 : (v - start) / size * nextSize);
+	if (edge === "left" || edge === "right") {
+		const x = edge === "left" ? from.x : from.x + from.width;
+		return {
+			x: (edge === "left" ? to.x : to.x + to.width) + p.x - x,
+			y: along(p.y, from.y, from.height, to.y, to.height)
+		};
+	}
+	const y = edge === "bottom" ? from.y : from.y + from.height;
+	const ny = edge === "bottom" ? to.y : to.y + to.height;
+	return {
+		x: along(p.x, from.x, from.width, to.x, to.width),
+		y: ny + p.y - y
+	};
+}
+/**
+* `p` placed on `box`'s `edge` at its own position along it, kept `margin` points clear of the
+* corners (at most half the edge).
+*/
+function ontoEdge(p, box, edge, margin) {
+	const clamp = (v, start, size) => {
+		const m = Math.min(margin, size / 2);
+		return Math.min(Math.max(v, start + m), start + size - m);
+	};
+	if (edge === "left" || edge === "right") return {
+		x: edge === "left" ? box.x : box.x + box.width,
+		y: clamp(p.y, box.y, box.height)
+	};
+	return {
+		x: clamp(p.x, box.x, box.width),
+		y: edge === "bottom" ? box.y : box.y + box.height
+	};
+}
+/**
+* The patch that resizes a free text's text box to `to`. A callout's tip and bend stay where
+* they are and its last point moves with the box edge it sits on (`onMovedEdge`).
+*/
+function resizedBox(a, to) {
+	if (!hasCallout(a)) return withBox(a, to);
+	const from = freeTextBox(a);
+	const last = a.callout.length - 1;
+	return withBox(a, to, a.callout.map((p, i) => i === last ? onMovedEdge(p, from, to) : p));
+}
+/**
+* The patch that moves a callout's tip to `to`, leaving its text box where it is. A callout
+* without a bend (every bubble) moves its edge point to the side the tip now lies furthest
+* beyond, at its own position along that side and clear of the corners, so the line or wedge
+* never crosses the box; on the same side it stays put. A bend and its edge point stay.
+*/
+function movedTip(a, to) {
+	const box = freeTextBox(a);
+	if (a.callout.length !== 2) return withBox(a, box, [to, ...a.callout.slice(1)]);
+	const edge = a.callout[1];
+	const side = edgeBeyond(to, box);
+	const margin = (a.cornerRadius ?? 0) + 8;
+	return withBox(a, box, [to, nearestEdge(edge, box) === side ? edge : ontoEdge(edge, box, side, margin)]);
+}
+//#endregion
+//#region src/model/annotations/style-map.ts
+/** For each type, the control-level props it supports and the field each writes. */
+const FIELDS = {
+	square: {
+		border: "color",
+		fill: "interiorColor",
+		opacity: "opacity",
+		width: "width",
+		dashes: "dashes"
+	},
+	circle: {
+		border: "color",
+		fill: "interiorColor",
+		opacity: "opacity",
+		width: "width",
+		dashes: "dashes"
+	},
+	polygon: {
+		border: "color",
+		fill: "interiorColor",
+		opacity: "opacity",
+		width: "width",
+		dashes: "dashes"
+	},
+	polyline: {
+		border: "color",
+		opacity: "opacity",
+		width: "width",
+		dashes: "dashes",
+		head: "head",
+		tail: "tail"
+	},
+	line: {
+		border: "color",
+		opacity: "opacity",
+		width: "width",
+		dashes: "dashes",
+		head: "head",
+		tail: "tail"
+	},
+	ink: {
+		border: "color",
+		opacity: "opacity",
+		width: "width"
+	},
+	highlight: {
+		border: "color",
+		opacity: "opacity"
+	},
+	underline: {
+		border: "color",
+		opacity: "opacity"
+	},
+	strikeout: {
+		border: "color",
+		opacity: "opacity"
+	},
+	squiggly: {
+		border: "color",
+		opacity: "opacity"
+	},
+	redact: {
+		border: "color",
+		opacity: "opacity"
+	},
+	freetext: {
+		border: "borderColor",
+		fill: "color",
+		textColor: "defaultStyle.color",
+		opacity: "opacity",
+		width: "width",
+		dashes: "dashes",
+		fontFamily: "defaultStyle.fontFamily",
+		fontSize: "defaultStyle.fontSize",
+		fontWeight: "defaultStyle.fontWeight",
+		fontStyle: "defaultStyle.fontStyle",
+		textDecoration: "defaultStyle.textDecoration",
+		textAlign: "defaultStyle.textAlign"
+	},
+	loupe: {
+		border: "color",
+		opacity: "opacity",
+		width: "width"
+	},
+	mask: {},
+	text: {},
+	stamp: {}
+};
+const GROUPS = {
+	square: "shape",
+	circle: "shape",
+	line: "shape",
+	polyline: "shape",
+	polygon: "shape",
+	loupe: "shape",
+	ink: "ink",
+	freetext: "text",
+	highlight: "markup",
+	underline: "markup",
+	strikeout: "markup",
+	squiggly: "markup",
+	redact: "redact",
+	text: void 0,
+	stamp: void 0,
+	mask: void 0
+};
+const SUPPORTED = new Map(Object.keys(FIELDS).map((type) => [type, new Set(Object.keys(FIELDS[type]))]));
+/**
+* The props a speech bubble (`intent: 'FreeTextCallout'`) takes from the `shape` group: its
+* outline, fill and opacity, as the shape tool creates it. Its text props stay in `text`.
+*/
+const BUBBLE_SHAPE_PROPS = /* @__PURE__ */ new Set([
+	"border",
+	"fill",
+	"opacity",
+	"width",
+	"dashes"
+]);
+/**
+* The style group an annotation's type belongs to; notes belong to none. With `key`, the group
+* that owns that prop on `a`: a speech bubble's outline and fill are `shape`'s, its text `text`'s.
+*/
+function styleGroupOf(a, key) {
+	if (key !== void 0 && a.type === "freetext" && a.intent === "FreeTextCallout" && BUBBLE_SHAPE_PROPS.has(key)) return "shape";
+	return GROUPS[a.type];
+}
+/** Every group that owns some prop on `a`: two for a speech bubble, else at most one. */
+function styleGroupsOf(a) {
+	const out = /* @__PURE__ */ new Set();
+	const own = GROUPS[a.type];
+	if (own) out.add(own);
+	for (const key of supportedProps(a.type)) {
+		const g = styleGroupOf(a, key);
+		if (g) out.add(g);
+	}
+	return [...out];
+}
+/** The types in `group`, from the same table `styleGroupOf` reads. */
+function typesInGroup(group) {
+	return Object.keys(GROUPS).filter((t) => GROUPS[t] === group);
+}
+/** The style group a type belongs to. */
+function styleGroupOfType(type) {
+	return GROUPS[type];
+}
+/** The control-level props `type` supports. */
+function supportedProps(type) {
+	return SUPPORTED.get(type) ?? /* @__PURE__ */ new Set();
+}
+/**
+* The control values a field leaves out: `normal` weight and style, no decoration. The field
+* is absent rather than holding them, as XFDF writes only what differs.
+*/
+const UNSET = {
+	fontWeight: "normal",
+	fontStyle: "normal",
+	textDecoration: "none"
+};
+/** The prefix of a field nested in `defaultStyle` (free text). */
+const STYLE = "defaultStyle.";
+/**
+* The field patch `patch` means on `type`. Props the type lacks are dropped. A `null` fill
+* becomes `interiorColor: undefined` (`color` on free text), which removes the fill when the
+* store applies it; so does `normal` weight or style and no decoration. Free-text text props go
+* into a partial `defaultStyle`, which the store merges into the current one.
+*/
+function toFields(type, patch) {
+	const fields = FIELDS[type];
+	const out = {};
+	for (const key of Object.keys(patch)) {
+		const field = fields[key];
+		if (field === void 0) continue;
+		const raw = patch[key];
+		const value = raw === null || raw === UNSET[key] ? void 0 : raw;
+		if (field.startsWith(STYLE)) {
+			const style = out.defaultStyle ??= {};
+			style[field.slice(13)] = value;
+		} else out[field] = value;
+	}
+	return out;
+}
+/** The control-level props an annotation shows, for the props its type supports. */
+function fromAnnotation(a) {
+	const fields = FIELDS[a.type];
+	const record = a;
+	const style = record.defaultStyle ?? {};
+	const out = {};
+	for (const key of Object.keys(fields)) {
+		const field = fields[key];
+		const value = field.startsWith(STYLE) ? style[field.slice(13)] : record[field];
+		if (value !== void 0) out[key] = value;
+		else if (key === "fill" || key === "dashes") out[key] = null;
+		else if (key === "head" || key === "tail") out[key] = "None";
+		else if (UNSET[key] !== void 0) out[key] = UNSET[key];
+	}
+	return out;
+}
+//#endregion
+//#region src/model/annotations/tool-style.ts
+const STYLE_GROUPS = [
+	"shape",
+	"ink",
+	"text",
+	"markup",
+	"redact"
+];
+/** Every prop some type in `group` supports. */
+function groupProps(group) {
+	const out = /* @__PURE__ */ new Set();
+	for (const type of typesInGroup(group)) for (const key of supportedProps(type)) out.add(key);
+	return out;
+}
+function sameValue(a, b) {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => Object.is(v, b[i]));
+	return false;
+}
+function sameRecord(a, b) {
+	const ka = Object.keys(a);
+	if (ka.length !== Object.keys(b).length) return false;
+	return ka.every((k) => k in b && sameValue(a[k], b[k]));
+}
+function sameSet(a, b) {
+	return a.size === b.size && [...a].every((v) => b.has(v));
+}
+/**
+* A readable recomputed from `fn` whenever any source fires, subscribed to its sources only
+* while it has subscribers. Equal results (by `eq`) are not re-emitted and keep their identity.
+*/
+function computed(sources, fn, eq) {
+	const subs = /* @__PURE__ */ new Set();
+	let cached;
+	let stops;
+	/** Recomputes, keeping the previous value's identity when equal. True when it changed. */
+	const recompute = () => {
+		const next = fn();
+		if (cached && eq(next, cached.value)) return false;
+		cached = { value: next };
+		return true;
+	};
+	const refresh = () => {
+		if (!recompute() || !cached) return;
+		const value = cached.value;
+		for (const sub of [...subs]) sub(value);
+	};
+	return {
+		get: () => {
+			if (!stops) recompute();
+			return cached.value;
+		},
+		subscribe(sub) {
+			if (!stops) {
+				recompute();
+				stops = sources.map((s) => s.subscribe(refresh));
+			}
+			subs.add(sub);
+			return () => {
+				if (!subs.delete(sub) || subs.size > 0) return;
+				for (const stop of stops ?? []) stop();
+				stops = void 0;
+			};
+		}
+	};
+}
+function createToolStyle(deps) {
+	const { store, history, activeGroup } = deps;
+	const groups = new Map(STYLE_GROUPS.map((g) => [g, writable({})]));
+	const groupStore = (g) => {
+		const w = groups.get(g);
+		if (!w) throw new RangeError(`Unknown style group ${String(g)}`);
+		return w;
+	};
+	/** The selected annotations, including changes proposed to a controlled host. */
+	const selected = () => store.selection.get().map((id) => store._getProposed(id) ?? store.get(id)).filter((a) => a !== void 0);
+	const sources = [
+		store.list,
+		store.selection,
+		...groups.values(),
+		...deps.active ? [deps.active] : []
+	];
+	/** One value per prop over `items`, `'mixed'` where they differ. */
+	const styleOf = (items) => {
+		const out = {};
+		for (const a of items) {
+			const props = fromAnnotation(a);
+			for (const [key, value] of Object.entries(props)) if (!(key in out)) out[key] = value;
+			else if (out[key] !== "mixed" && !sameValue(out[key], value)) out[key] = "mixed";
+		}
+		return out;
+	};
+	const propsOf = (items) => {
+		const out = /* @__PURE__ */ new Set();
+		for (const a of items) for (const key of supportedProps(a.type)) out.add(key);
+		return out;
+	};
+	/** The selection, when it is non-empty and wholly in `group`. */
+	const selectedIn = (group) => {
+		const items = selected();
+		return items.length > 0 && items.every((a) => styleGroupsOf(a).includes(group)) ? items : null;
+	};
+	const current = computed(sources, () => {
+		const g = activeGroup();
+		if (!g) return styleOf(selected());
+		const items = selectedIn(g);
+		return items ? styleOf(items) : { ...groupStore(g).get() };
+	}, (a, b) => sameRecord(a, b));
+	const supported = computed(sources, () => {
+		const g = activeGroup();
+		if (!g) return propsOf(selected());
+		const items = selectedIn(g);
+		return items ? /* @__PURE__ */ new Set([...groupProps(g), ...propsOf(items)]) : groupProps(g);
+	}, sameSet);
+	const scopes = /* @__PURE__ */ new Map();
+	function scoped(group) {
+		const known = scopes.get(group);
+		if (known) return known;
+		groupStore(group);
+		const scope = {
+			group,
+			current: computed(sources, () => {
+				const items = selectedIn(group);
+				return items ? styleOf(items) : { ...groupStore(group).get() };
+			}, (a, b) => sameRecord(a, b)),
+			supported: computed(sources, () => {
+				const items = selectedIn(group);
+				return items ? propsOf(items) : groupProps(group);
+			}, sameSet),
+			set: (patch) => set(patch, {
+				group,
+				apply: selectedIn(group) !== null
+			})
+		};
+		scopes.set(group, scope);
+		return scope;
+	}
+	function set(patch, opts = {}) {
+		const items = selected();
+		const active = opts.group ?? activeGroup();
+		const keys = Object.keys(patch).filter((k) => patch[k] !== void 0);
+		const targets = /* @__PURE__ */ new Map();
+		if (active) targets.set(active, new Set(keys));
+		else for (const a of items) for (const key of keys) {
+			if (!supportedProps(a.type).has(key)) continue;
+			const g = styleGroupOf(a, key);
+			if (!g) continue;
+			const own = targets.get(g) ?? /* @__PURE__ */ new Set();
+			own.add(key);
+			targets.set(g, own);
+		}
+		for (const [g, own] of targets) {
+			const allowed = groupProps(g);
+			const next = { ...groupStore(g).get() };
+			let changed = false;
+			for (const key of own) {
+				if (!allowed.has(key)) continue;
+				next[key] = patch[key];
+				changed = true;
+			}
+			if (changed) groupStore(g).set(next);
+		}
+		if (!(opts.apply ?? (active === void 0 || selectedIn(active) !== null))) return;
+		const edits = items.filter((a) => !a.locked).map((a) => ({
+			id: a.id,
+			fields: refit(a, toFields(a.type, patch))
+		})).filter((e) => Object.keys(e.fields).length > 0);
+		if (edits.length === 0) return;
+		history.batch(() => {
+			for (const e of edits) store.update(e.id, e.fields);
+		});
+	}
+	/**
+	* `fields` with a callout's `rect` and `fringe` refit when they change its border width, so
+	* the bounds keep covering the leader, its ending and the outline.
+	*/
+	function refit(a, fields) {
+		if (!("width" in fields) || !hasCallout(a)) return fields;
+		const next = {
+			...a,
+			...fields
+		};
+		return {
+			...fields,
+			...withBox(next, freeTextBox(a))
+		};
+	}
+	/** `value`'s keys that hold something. */
+	const defined = (value) => Object.fromEntries(Object.entries(value ?? {}).filter(([, v]) => v !== void 0));
+	function resolve(group, input) {
+		const fields = toFields(input.type, groupStore(group).get());
+		const out = { ...input };
+		for (const [key, value] of Object.entries(fields)) if (key === "defaultStyle") out[key] = {
+			...defined(value),
+			...defined(out[key])
+		};
+		else if (value !== void 0 && out[key] === void 0) out[key] = value;
+		return out;
+	}
+	return {
+		get: (g) => groupStore(g).get(),
+		readable: (g) => {
+			const w = groupStore(g);
+			return {
+				get: () => w.get(),
+				subscribe: (fn) => w.subscribe(fn)
+			};
+		},
+		current,
+		supported,
+		set,
+		resolve,
+		scoped
+	};
+}
+//#endregion
+//#region src/model/annotations/threads.ts
+function isThreadRoot(a) {
+	return a.type === "text" || isTextMarkup(a);
+}
+/**
+* True for a reply: an annotation whose `inReplyTo` names a thread root (a note or text markup)
+* in `list`. Replies show in the thread popover only, never on the page.
+*/
+function isReply(a, list) {
+	if (a.inReplyTo === void 0) return false;
+	const parent = list.find((x) => x.id === a.inReplyTo);
+	return parent !== void 0 && isThreadRoot(parent);
+}
+/** `list` less its replies (see `isReply`), in the same order. */
+function withoutReplies(list) {
+	const roots = new Set(list.filter(isThreadRoot).map((a) => a.id));
+	return list.filter((a) => a.inReplyTo === void 0 || !roots.has(a.inReplyTo));
+}
+/** Direct replies to `id`, in creation order. */
+function repliesTo(list, id) {
+	return list.filter((a) => a.inReplyTo === id).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+/**
+* The top of a thread: follows `inReplyTo` up through notes, stopping at text markup (which
+* roots a thread of its own), a missing parent, a parent that cannot root a thread, or a
+* cycle. Null when `start` is neither a note nor text markup.
+*/
+function threadRoot(list, start) {
+	if (!isThreadRoot(start)) return null;
+	const seen = /* @__PURE__ */ new Set([start.id]);
+	let current = start;
+	while (current.type === "text" && current.inReplyTo) {
+		const id = current.inReplyTo;
+		const parent = list.find((a) => a.id === id);
+		if (!parent || !isThreadRoot(parent) || seen.has(parent.id)) break;
+		seen.add(parent.id);
+		current = parent;
+	}
+	return current;
+}
+/** The root, then every reply below it, depth first, each level in creation order. */
+function threadOf(list, root) {
+	const out = [root];
+	const seen = /* @__PURE__ */ new Set([root.id]);
+	const visit = (id) => {
+		for (const r of repliesTo(list, id)) {
+			if (seen.has(r.id)) continue;
+			seen.add(r.id);
+			out.push(r);
+			visit(r.id);
+		}
+	};
+	visit(root.id);
+	return out;
+}
+/**
+* An unlocked root note with no text and no replies: nothing a reader would miss. Always
+* false for text markup, which is worth keeping without a comment.
+*/
+function isAbandonedNote(a, list) {
+	if (a.type !== "text" || a.locked || a.inReplyTo || a.contents?.trim()) return false;
+	return repliesTo(list, a.id).length === 0;
+}
+//#endregion
+//#region src/model/annotations/shape-geometry.ts
+/** The kinds the shape menu offers today, in menu order. Later kinds extend this. */
+const SHAPE_KINDS = [
+	"line",
+	"arrow",
+	"rectangle",
+	"roundedRectangle",
+	"ellipse",
+	"bubble",
+	"star",
+	"polygon",
+	"loupe",
+	"mask",
+	"ovalMask"
+];
+const DEFAULT_SHAPE_OPTIONS = {
+	kind: "rectangle",
+	points: 5,
+	sides: 6
+};
+const POINTER_ONLY = /* @__PURE__ */ new Set([
+	"loupe",
+	"mask",
+	"ovalMask"
+]);
+/**
+* True for kinds only a pointer creates: the loupe and the mask. `Enter` with the shape tool
+* does not place them.
+*/
+function isPointerOnlyKind(kind) {
+	return POINTER_ONLY.has(kind);
+}
+/** How strongly a new mask dims the page. */
+const DEFAULT_MASK_DIM = .5;
+/** Side of the shape a click or Enter places, in points. */
+const DEFAULT_SHAPE_SIZE = 72;
+/** Corner radius of a new rounded rectangle, in points. */
+const DEFAULT_CORNER_RADIUS = 8;
+/** How far below and left of its anchor a new speech bubble's tail tip sits, in points. */
+const BUBBLE_TAIL = 24;
+/** A new speech bubble's outline width, in points, before the style group's applies. */
+const BUBBLE_WIDTH = 1;
+const clean = (n) => n + 0;
+/** The box between two corners. */
+function rectOf(a, b) {
+	return {
+		x: Math.min(a.x, b.x),
+		y: Math.min(a.y, b.y),
+		width: Math.abs(b.x - a.x),
+		height: Math.abs(b.y - a.y)
+	};
+}
+/**
+* Vertices round a circle, the first at the top centre, clockwise on the page, stretched so their
+* bounds fill `rect`.
+*/
+function ring(rect, count, radius) {
+	const unit = Array.from({ length: count }, (_, i) => {
+		const angle = i * 2 * Math.PI / count;
+		const r = radius(i);
+		return {
+			x: r * Math.sin(angle),
+			y: r * Math.cos(angle)
+		};
+	});
+	const xs = unit.map((p) => p.x);
+	const ys = unit.map((p) => p.y);
+	const fit = (v, min, max, start, size) => clean(max > min ? start + (v - min) / (max - min) * size : start + size / 2);
+	const [minX, maxX, minY, maxY] = [
+		Math.min(...xs),
+		Math.max(...xs),
+		Math.min(...ys),
+		Math.max(...ys)
+	];
+	return unit.map((p) => ({
+		x: fit(p.x, minX, maxX, rect.x, rect.width),
+		y: fit(p.y, minY, maxY, rect.y, rect.height)
+	}));
+}
+/**
+* A star's `2 * points` vertices, outer and inner alternating, stretched to fill `rect`, the first
+* at the top centre.
+*/
+function starVertices(rect, points, innerRatio = .5) {
+	return ring(rect, Math.max(2, Math.round(points)) * 2, (i) => i % 2 === 0 ? 1 : innerRatio);
+}
+/** A regular polygon's vertices, stretched to fill `rect`, the first at the top centre. */
+function polygonVertices(rect, sides) {
+	return ring(rect, Math.max(3, Math.round(sides)), () => 1);
+}
+const LINE_KINDS = /* @__PURE__ */ new Set(["line", "arrow"]);
+/** True for kinds drawn between two endpoints rather than inside a box. */
+function isLineKind(kind) {
+	return LINE_KINDS.has(kind);
+}
+const H = Math.SQRT1_2;
+/** Unit steps every 45 degrees, counter-clockwise from +x (y up). */
+const EIGHT_WAYS = [
+	{
+		x: 1,
+		y: 0
+	},
+	{
+		x: H,
+		y: H
+	},
+	{
+		x: 0,
+		y: 1
+	},
+	{
+		x: -H,
+		y: H
+	},
+	{
+		x: -1,
+		y: 0
+	},
+	{
+		x: -H,
+		y: -H
+	},
+	{
+		x: 0,
+		y: -1
+	},
+	{
+		x: H,
+		y: -H
+	}
+];
+/**
+* Where the drag ends with Shift held: a square or circle for box kinds, the nearest 45 degree
+* angle for lines.
+*/
+function constrain(kind, start, end) {
+	const dx = end.x - start.x;
+	const dy = end.y - start.y;
+	if (isLineKind(kind)) {
+		const step = Math.round(Math.atan2(dy, dx) / (Math.PI / 4));
+		const u = EIGHT_WAYS[(step % 8 + 8) % 8];
+		const length = dx * u.x + dy * u.y;
+		return {
+			x: clean(start.x + length * u.x),
+			y: clean(start.y + length * u.y)
+		};
+	}
+	const size = Math.max(Math.abs(dx), Math.abs(dy));
+	return {
+		x: clean(start.x + (dx < 0 ? -size : size)),
+		y: clean(start.y + (dy < 0 ? -size : size))
+	};
+}
+/**
+* The two drag corners of the default-size shape centred on `at`. A line or arrow runs left to
+* right on the page as the file displays it: along user space turned anticlockwise by the
+* page's /Rotate `rotation`, which undoes the page's clockwise turn, as a signature is placed.
+*/
+function defaultEnds(kind, at, rotation = 0) {
+	const half = 36;
+	if (!isLineKind(kind)) return [{
+		x: at.x - half,
+		y: at.y - half
+	}, {
+		x: at.x + half,
+		y: at.y + half
+	}];
+	const rad = rotation * Math.PI / 180;
+	const dx = Math.round(Math.cos(rad)) * half;
+	const dy = Math.round(Math.sin(rad)) * half;
+	return [{
+		x: clean(at.x - dx),
+		y: clean(at.y - dy)
+	}, {
+		x: clean(at.x + dx),
+		y: clean(at.y + dy)
+	}];
+}
+/** The annotation a shape kind creates between two points, or `undefined` for a kind without a creator yet. */
+function shapeInput(kind, page, start, end, opts) {
+	const rect = rectOf(start, end);
+	switch (kind) {
+		case "line": return {
+			type: "line",
+			page,
+			start,
+			end
+		};
+		case "arrow": return {
+			type: "line",
+			page,
+			start,
+			end,
+			intent: "LineArrow"
+		};
+		case "rectangle": return {
+			type: "square",
+			page,
+			rect
+		};
+		case "roundedRectangle": return {
+			type: "square",
+			page,
+			rect,
+			cornerRadius: 8
+		};
+		case "ellipse": return {
+			type: "circle",
+			page,
+			rect
+		};
+		case "bubble": {
+			const edge = {
+				x: clean(rect.x + rect.width / 4),
+				y: clean(rect.y)
+			};
+			const callout = [{
+				x: clean(edge.x - BUBBLE_TAIL),
+				y: clean(edge.y - BUBBLE_TAIL)
+			}, edge];
+			return {
+				type: "freetext",
+				page,
+				contents: "",
+				intent: "FreeTextCallout",
+				cornerRadius: 8,
+				width: BUBBLE_WIDTH,
+				...withCalloutBounds(rect, callout, BUBBLE_WIDTH, void 0),
+				callout
+			};
+		}
+		case "star": return {
+			type: "polygon",
+			page,
+			vertices: starVertices(rect, opts.points)
+		};
+		case "polygon": return {
+			type: "polygon",
+			page,
+			vertices: polygonVertices(rect, opts.sides)
+		};
+		case "loupe": return {
+			type: "loupe",
+			page,
+			rect: rectOf(start, constrain(kind, start, end)),
+			magnification: 2
+		};
+		case "mask":
+		case "ovalMask": return {
+			type: "mask",
+			page,
+			rect,
+			shape: kind === "mask" ? "rect" : "ellipse",
+			dim: DEFAULT_MASK_DIM
+		};
+		default: return;
+	}
+}
+//#endregion
+//#region src/model/recognise.ts
+/** The score a fit needs before a stroke is tidied into its shape. */
+const RECOGNISE_THRESHOLD = .8;
+/** Samples either side of a point that its turn is measured over. */
+const W = 3;
+/** Turns, over `2 * W` samples, that make a corner: outward, and back against the loop. */
+const CONVEX_TURN = 40 * Math.PI / 180;
+const CONCAVE_TURN = 15 * Math.PI / 180;
+/** Resampled points along the box diagonal. */
+const DENSITY = 50;
+/** A run of path is straight when its chord is at least this share of its length. */
+const STRAIGHT = .95;
+/** Corners whose neighbours this straight run through them (a turn under about 23 degrees) go. */
+const MERGE_STRAIGHT = .98;
+/** The ends of a closed stroke are within this share of the box diagonal. */
+const CLOSE_GAP = .25;
+/** Weights of a line's largest and mean straying from its chord, over its length. */
+const LINE_MAX = 2;
+const LINE_MEAN = 2;
+/** Weight of a polygon side's mean straying from its chord, over its length. */
+const SIDE_MEAN = 3;
+const dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+const clamp01 = (n) => Math.min(Math.max(n, 0), 1);
+const round = (n) => Math.round(n * 100) / 100 + 0;
+const pt = (p) => ({
+	x: round(p.x),
+	y: round(p.y)
+});
+function boxOf(points) {
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	for (const p of points) {
+		minX = Math.min(minX, p.x);
+		minY = Math.min(minY, p.y);
+		maxX = Math.max(maxX, p.x);
+		maxY = Math.max(maxY, p.y);
+	}
+	return {
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
+}
+const diagonal = (r) => Math.hypot(r.width, r.height);
+function lengthOf(points) {
+	let total = 0;
+	for (let i = 1; i < points.length; i++) total += dist(points[i - 1], points[i]);
+	return total;
+}
+/** Points every `spacing` along the path, the first and last included. */
+function resample(points, spacing) {
+	const out = [points[0]];
+	let carried = 0;
+	let prev = points[0];
+	for (let i = 1; i < points.length; i++) {
+		const next = points[i];
+		let d = dist(prev, next);
+		while (carried + d >= spacing) {
+			const t = (spacing - carried) / d;
+			const q = {
+				x: prev.x + t * (next.x - prev.x),
+				y: prev.y + t * (next.y - prev.y)
+			};
+			out.push(q);
+			prev = q;
+			d = dist(prev, next);
+			carried = 0;
+		}
+		carried += d;
+		prev = next;
+	}
+	const last = points[points.length - 1];
+	if (dist(out[out.length - 1], last) > spacing / 2) out.push(last);
+	else out[out.length - 1] = last;
+	return out;
+}
+/** Distance from `p` to the segment `a`–`b`. */
+function toSegment(p, a, b) {
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	const len2 = dx * dx + dy * dy;
+	const t = len2 === 0 ? 0 : clamp01(((p.x - a.x) * dx + (p.y - a.y) * dy) / len2);
+	return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
+}
+/** Path lengths from the first point: `cum[i]` is the length up to point `i`. */
+function cumulative(points) {
+	const cum = [0];
+	for (let i = 1; i < points.length; i++) cum.push(cum[i - 1] + dist(points[i - 1], points[i]));
+	return cum;
+}
+/**
+* Corner indices of the loop `r` (its last point joins its first), in order round it. A corner
+* is where the path turns sharply over a few samples: outward by more than `CONVEX_TURN`, or
+* back against the loop's own direction (a star's inner corner) by more than `CONCAVE_TURN`.
+*/
+function cornersOf(r) {
+	const n = r.length;
+	if (n < 8) return [];
+	const at = (i) => r[(i % n + n) % n];
+	const direction = Math.sign(winding(r, centroid(r))) || 1;
+	const turns = r.map((p, i) => {
+		const a = at(i - W);
+		const b = at(i + W);
+		const turn = Math.atan2(b.y - p.y, b.x - p.x) - Math.atan2(p.y - a.y, p.x - a.x);
+		return direction * (turn > Math.PI ? turn - 2 * Math.PI : turn < -Math.PI ? turn + 2 * Math.PI : turn);
+	});
+	/** 1 for an outward corner, -1 for an inward one, 0 for none. */
+	const kind = (i) => turns[i] > CONVEX_TURN ? 1 : turns[i] < -CONCAVE_TURN ? -1 : 0;
+	const start = turns.findIndex((_, i) => kind(i) === 0);
+	if (start < 0) return [];
+	const corners = [];
+	let best;
+	for (let k = 0; k <= n; k++) {
+		const i = (start + k) % n;
+		const c = k < n ? kind(i) : 0;
+		if (best !== void 0 && c !== kind(best)) {
+			corners.push(best);
+			best = void 0;
+		}
+		if (c !== 0 && (best === void 0 || Math.abs(turns[i]) > Math.abs(turns[best]))) best = i;
+	}
+	corners.sort((a, b) => a - b);
+	for (let k = 0; corners.length > 1 && k < corners.length;) {
+		const next = (k + 1) % corners.length;
+		if ((corners[next] - corners[k] + n) % n > 6) k++;
+		else corners.splice(Math.abs(turns[corners[k]]) < Math.abs(turns[corners[next]]) ? k : next, 1);
+	}
+	return mergeStraight(r, corners);
+}
+/** Drops corners whose neighbours run straight through them, the straightest first. */
+function mergeStraight(r, corners) {
+	const cum = cumulative(r);
+	const total = cum[cum.length - 1] + dist(r[r.length - 1], r[0]);
+	const arc = (a, b) => b > a ? cum[b] - cum[a] : total - cum[a] + cum[b];
+	const out = [...corners];
+	while (out.length > 3) {
+		let drop = -1;
+		let straightest = MERGE_STRAIGHT;
+		for (let k = 0; k < out.length; k++) {
+			const p = out[(k - 1 + out.length) % out.length];
+			const q = out[(k + 1) % out.length];
+			const a = arc(p, q);
+			const ratio = a === 0 ? 1 : dist(r[p], r[q]) / a;
+			if (ratio > straightest) {
+				straightest = ratio;
+				drop = k;
+			}
+		}
+		if (drop < 0) break;
+		out.splice(drop, 1);
+	}
+	return out;
+}
+/** Times the path winds round `c`, signed. */
+function winding(points, c) {
+	let total = 0;
+	for (let i = 0; i < points.length; i++) {
+		const a = points[i];
+		const b = points[(i + 1) % points.length];
+		let d = Math.atan2(b.y - c.y, b.x - c.x) - Math.atan2(a.y - c.y, a.x - c.x);
+		if (d > Math.PI) d -= 2 * Math.PI;
+		if (d < -Math.PI) d += 2 * Math.PI;
+		total += d;
+	}
+	return total / (2 * Math.PI);
+}
+/** Largest and mean distance of `points` from the line through `a` and `b`, over `|ab|`. */
+function deviation(points, a, b) {
+	const len = dist(a, b);
+	if (len === 0 || points.length === 0) return {
+		max: Infinity,
+		mean: Infinity
+	};
+	let max = 0;
+	let sum = 0;
+	for (const p of points) {
+		const d = Math.abs((b.x - a.x) * (a.y - p.y) - (a.x - p.x) * (b.y - a.y)) / len;
+		max = Math.max(max, d);
+		sum += d;
+	}
+	return {
+		max: max / len,
+		mean: sum / points.length / len
+	};
+}
+/** How straight a run from `a` to `b` is: 1 on the chord, falling as the path strays from it. */
+function straightness(points, a, b) {
+	const dev = deviation(points, a, b);
+	const bend = 1 - dist(a, b) / lengthOf(points);
+	return clamp01(1 - LINE_MAX * dev.max - LINE_MEAN * dev.mean - 2 * bend);
+}
+function fitLine(r) {
+	const a = r[0];
+	const b = r[r.length - 1];
+	if (dist(a, b) / lengthOf(r) < .8) return void 0;
+	return {
+		shape: {
+			kind: "line",
+			start: pt(a),
+			end: pt(b)
+		},
+		score: straightness(r, a, b)
+	};
+}
+/** An arrow whose head is drawn at the end of `r`: a straight shaft, then a short fold back. */
+function fitArrow(r) {
+	const from = r.map((p) => dist(p, r[0]));
+	const far = Math.max(...from);
+	let tipAt = from.findIndex((d) => d >= .97 * far);
+	while (tipAt + 1 < r.length && from[tipAt + 1] > from[tipAt]) tipAt++;
+	const shaft = r.slice(0, tipAt + 1);
+	const head = r.slice(tipAt + 1);
+	const tail = r[0];
+	const tip = r[tipAt];
+	const shaftLength = lengthOf(shaft);
+	const headLength = lengthOf([tip, ...head]);
+	if (shaftLength < .6 * (shaftLength + headLength) || headLength < .06 * shaftLength) return void 0;
+	const along = {
+		x: (tip.x - tail.x) / shaftLength,
+		y: (tip.y - tail.y) / shaftLength
+	};
+	const chord = dist(tail, tip);
+	if (chord / shaftLength < STRAIGHT) return void 0;
+	let off = 0;
+	for (const p of head) {
+		if (dist(p, tip) > .4 * chord) return void 0;
+		if ((p.x - tip.x) * along.x + (p.y - tip.y) * along.y > .08 * chord) return void 0;
+		off = Math.max(off, Math.abs((p.x - tip.x) * along.y - (p.y - tip.y) * along.x));
+	}
+	if (off < .04 * chord) return void 0;
+	return {
+		shape: {
+			kind: "arrow",
+			start: pt(tail),
+			end: pt(tip)
+		},
+		score: straightness(shaft, tail, tip)
+	};
+}
+/**
+* The stroke as a loop, evenly spaced all the way round (the gap between its ends bridged), an
+* overshoot past its start trimmed; undefined when the stroke is open.
+*/
+function loopOf(r, size, spacing) {
+	const n = r.length;
+	if (n < 8) return void 0;
+	let end = n - 1;
+	for (let i = Math.floor(n / 2); i < n; i++) if (dist(r[i], r[0]) < dist(r[end], r[0])) end = i;
+	if (dist(r[end], r[0]) > CLOSE_GAP * size || n - 1 - end > .25 * n) return void 0;
+	const loop = resample([...r.slice(0, end + 1), r[0]], spacing);
+	loop.pop();
+	return loop;
+}
+function fitEllipse(loop, box) {
+	const rx = box.width / 2;
+	const ry = box.height / 2;
+	if (rx === 0 || ry === 0) return void 0;
+	const cx = box.x + rx;
+	const cy = box.y + ry;
+	let sum = 0;
+	for (const p of loop) sum += Math.abs(Math.hypot((p.x - cx) / rx, (p.y - cy) / ry) - 1);
+	const mean = sum / loop.length;
+	return {
+		shape: {
+			kind: "ellipse",
+			rect: {
+				x: round(box.x),
+				y: round(box.y),
+				width: round(box.width),
+				height: round(box.height)
+			}
+		},
+		score: clamp01(1 - 3 * mean)
+	};
+}
+/** How closely the loop follows the polygon through `vertices`: 1 on it, falling with distance. */
+function polygonFit(loop, vertices, size) {
+	let sum = 0;
+	for (const p of loop) {
+		let best = Infinity;
+		for (let i = 0; i < vertices.length; i++) best = Math.min(best, toSegment(p, vertices[i], vertices[(i + 1) % vertices.length]));
+		sum += best;
+	}
+	return clamp01(1 - 12 * sum / loop.length / size);
+}
+/** Within `tolerance` radians of horizontal (0) or vertical (1); else -1. */
+function axisOf(a, b, tolerance) {
+	const angle = Math.abs(Math.atan2(b.y - a.y, b.x - a.x)) % Math.PI;
+	const fromH = Math.min(angle, Math.PI - angle);
+	const fromV = Math.abs(angle - Math.PI / 2);
+	if (fromH <= tolerance) return {
+		axis: 0,
+		off: fromH
+	};
+	if (fromV <= tolerance) return {
+		axis: 1,
+		off: fromV
+	};
+	return {
+		axis: -1,
+		off: Math.PI / 4
+	};
+}
+function fitRectangle(vertices, fit) {
+	if (vertices.length !== 4) return void 0;
+	const tolerance = 20 * Math.PI / 180;
+	let worst = 0;
+	for (let i = 0; i < 4; i++) {
+		const side = axisOf(vertices[i], vertices[(i + 1) % 4], tolerance);
+		if (side.axis < 0 || side.axis !== (axisOf(vertices[0], vertices[1], tolerance).axis + i) % 2) return void 0;
+		worst = Math.max(worst, side.off);
+	}
+	const xs = vertices.map((v) => v.x).sort((a, b) => a - b);
+	const ys = vertices.map((v) => v.y).sort((a, b) => a - b);
+	const left = (xs[0] + xs[1]) / 2;
+	const right = (xs[2] + xs[3]) / 2;
+	const bottom = (ys[0] + ys[1]) / 2;
+	const top = (ys[2] + ys[3]) / 2;
+	return {
+		shape: {
+			kind: "rectangle",
+			rect: {
+				x: round(left),
+				y: round(bottom),
+				width: round(right - left),
+				height: round(top - bottom)
+			}
+		},
+		score: clamp01(fit - worst / tolerance / 10)
+	};
+}
+/** The shape tool's star of `points` tips round `c`, tips at `radius`, the first at the top. */
+function regularStar(c, points, radius) {
+	return starVertices({
+		x: c.x - radius,
+		y: c.y - radius,
+		width: 2 * radius,
+		height: 2 * radius
+	}, points).map(pt);
+}
+const centroid = (points) => ({
+	x: points.reduce((s, p) => s + p.x, 0) / points.length,
+	y: points.reduce((s, p) => s + p.y, 0) / points.length
+});
+/** An outline star: an even number of corners alternating far from and near the centre. */
+function fitStar(vertices, fit) {
+	const k = vertices.length;
+	if (k % 2 !== 0 || k < 8 || k > 16) return void 0;
+	const c = centroid(vertices);
+	const radii = vertices.map((v) => dist(v, c));
+	const even = radii.filter((_, i) => i % 2 === 0);
+	const odd = radii.filter((_, i) => i % 2 === 1);
+	const [outer, inner] = Math.min(...even) > Math.max(...odd) ? [even, odd] : [odd, even];
+	if (Math.min(...outer) <= Math.max(...inner)) return void 0;
+	const mean = (xs) => xs.reduce((s, x) => s + x, 0) / xs.length;
+	if (mean(inner) / mean(outer) > .75) return void 0;
+	const spread = (Math.max(...outer) - Math.min(...outer)) / mean(outer);
+	return {
+		shape: {
+			kind: "star",
+			vertices: regularStar(c, k / 2, mean(outer))
+		},
+		score: clamp01(fit - Math.max(0, spread - .2))
+	};
+}
+/** A pentagram: five straight strokes that wind twice round the centre. */
+function fitPentagram(vertices, loop, size) {
+	if (vertices.length !== 5) return void 0;
+	const c = centroid(vertices);
+	const turns = Math.abs(winding(loop, c));
+	if (turns < 1.6 || turns > 2.4) return void 0;
+	const radii = vertices.map((v) => dist(v, c));
+	const mean = radii.reduce((s, x) => s + x, 0) / radii.length;
+	const spread = (Math.max(...radii) - Math.min(...radii)) / mean;
+	return {
+		shape: {
+			kind: "star",
+			vertices: regularStar(c, 5, mean)
+		},
+		score: clamp01(polygonFit(loop, vertices, size) - Math.max(0, spread - .2))
+	};
+}
+/** True when two sides of the polygon through `v` cross. */
+function crosses(v) {
+	const k = v.length;
+	const side = (a, b, c) => Math.sign((b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x));
+	for (let i = 0; i < k; i++) for (let j = i + 2; j < k; j++) {
+		if (i === 0 && j === k - 1) continue;
+		const [a, b, c, d] = [
+			v[i],
+			v[(i + 1) % k],
+			v[j],
+			v[(j + 1) % k]
+		];
+		if (side(a, b, c) * side(a, b, d) < 0 && side(c, d, a) * side(c, d, b) < 0) return true;
+	}
+	return false;
+}
+/** How straight the loop runs between consecutive corners: the worst side's score. */
+function sidesFit(loop, corners) {
+	let worst = 1;
+	for (let k = 0; k < corners.length; k++) {
+		const from = corners[k];
+		const to = corners[(k + 1) % corners.length];
+		const side = to > from ? loop.slice(from, to + 1) : [...loop.slice(from), ...loop.slice(0, to + 1)];
+		const a = side[0];
+		const b = side[side.length - 1];
+		const bend = 1 - dist(a, b) / lengthOf(side);
+		worst = Math.min(worst, clamp01(1 - SIDE_MEAN * deviation(side, a, b).mean - 2 * bend));
+	}
+	return worst;
+}
+function fitClosed(loop, size) {
+	const box = boxOf(loop);
+	const fits = [];
+	const corners = cornersOf(loop);
+	const vertices = corners.map((i) => loop[i]);
+	const pentagram = fitPentagram(vertices, loop, size);
+	if (pentagram) fits.push(pentagram);
+	const turns = Math.abs(winding(loop, {
+		x: box.x + box.width / 2,
+		y: box.y + box.height / 2
+	}));
+	if (turns < .8 || turns > 1.25) return fits;
+	const ellipse = fitEllipse(loop, box);
+	if (ellipse) fits.push(ellipse);
+	if (vertices.length < 3 || crosses(vertices)) return fits;
+	const fit = polygonFit(loop, vertices, size);
+	const rectangle = fitRectangle(vertices, fit);
+	if (rectangle) fits.push(rectangle);
+	else if (vertices.length <= 8) fits.push({
+		shape: {
+			kind: "polygon",
+			vertices: vertices.map(pt)
+		},
+		score: Math.min(fit, sidesFit(loop, corners))
+	});
+	const star = fitStar(vertices, fit);
+	if (star) fits.push(star);
+	return fits;
+}
+/**
+* The standard shape a single freehand stroke (user space points, in drawing order) is closest
+* to, and how well it fits, from 0 to 1. Tidy the stroke only when the score reaches
+* `RECOGNISE_THRESHOLD`. Undefined when no shape fits at all.
+*/
+function recogniseStroke(points) {
+	const clean = points.filter((p, i) => Number.isFinite(p.x) && Number.isFinite(p.y) && (i === 0 || p.x !== points[i - 1].x || p.y !== points[i - 1].y));
+	if (clean.length < 2) return void 0;
+	const size = diagonal(boxOf(clean));
+	if (size === 0) return void 0;
+	const spacing = Math.max(size / DENSITY, lengthOf(clean) / 1e3);
+	const r = resample(clean, spacing);
+	if (r.length < 2) return void 0;
+	const fits = [];
+	const line = fitLine(r);
+	if (line) fits.push(line);
+	const loop = loopOf(r, size, spacing);
+	if (loop) fits.push(...fitClosed(loop, size));
+	else for (const f of [fitArrow(r), fitArrow([...r].reverse())]) if (f) fits.push(f);
+	let best;
+	for (const f of fits) if (!best || f.score > best.score) best = f;
+	return best && {
+		shape: best.shape,
+		score: round(best.score)
+	};
+}
+//#endregion
+//#region src/model/signatures.ts
+/** How wide a placed signature is, in points. */
+const DEFAULT_SIGNATURE_WIDTH = 150;
+/** A placed ink signature's stroke width, in points. */
+const SIGNATURE_INK_WIDTH = 2;
+const Aspect = z.number().positive().finite();
+const TemplateSchema = z.discriminatedUnion("kind", [z.object({
+	id: z.string().min(1),
+	kind: z.literal("ink"),
+	inklist: z.array(z.array(PointSchema).min(1)).min(1),
+	pressure: z.array(z.array(z.number().min(0).max(1))).optional(),
+	aspect: Aspect
+}), z.object({
+	id: z.string().min(1),
+	kind: z.literal("image"),
+	imagedata: z.string().regex(IMAGE_DATA_URL),
+	aspect: Aspect
+})]).refine((t) => t.kind !== "ink" || !t.pressure || t.pressure.length === t.inklist.length && t.pressure.every((p, i) => p.length === t.inklist[i]?.length), {
+	message: "pressure must have the same shape as inklist",
+	path: ["pressure"]
+});
+/** The items that are valid templates; the rest are skipped. */
+function validTemplates(items) {
+	return items.flatMap((item) => {
+		const t = TemplateSchema.safeParse(item);
+		return t.success ? [t.data] : [];
+	});
+}
+const copy = (t) => JSON.parse(JSON.stringify(t));
+function upsert(list, t) {
+	const i = list.findIndex((x) => x.id === t.id);
+	return i < 0 ? [...list, copy(t)] : list.map((x, j) => j === i ? copy(t) : x);
+}
+/** Templates in memory, gone on reload. The default when a host passes no store. */
+function createMemorySignatureStore(initial = []) {
+	let items = initial.map(copy);
+	return {
+		list: () => Promise.resolve(items.map(copy)),
+		save(t) {
+			items = upsert(items, t);
+			return Promise.resolve();
+		},
+		remove(id) {
+			items = items.filter((x) => x.id !== id);
+			return Promise.resolve();
+		}
+	};
+}
+/**
+* Templates in `localStorage` under `key`, as a JSON array. Where storage is blocked (it refuses
+* even a tiny test write, as in some private windows) the templates stay in memory for the
+* page's life, so signing still works. Where storage works, or is full but holds a saved list,
+* and has no room for a change, the change is undone and `save` or `remove` rejects, so the host can say so. Stored entries it
+* cannot read, such as a later version's templates, are left out of `list` and kept on write.
+*/
+function createLocalSignatureStore(key) {
+	/** Usable storage, or undefined when it is missing or blocked. */
+	const storage = (() => {
+		try {
+			const s = globalThis.localStorage ?? void 0;
+			if (!s) return void 0;
+			const probe = `${key}:probe`;
+			try {
+				s.setItem(probe, "1");
+				s.removeItem(probe);
+			} catch {
+				return s.getItem(key) === null ? void 0 : s;
+			}
+			return s;
+		} catch {
+			return;
+		}
+	})();
+	/** The stored list; undefined when storage cannot be read. */
+	const read = () => {
+		if (!storage) return void 0;
+		try {
+			const raw = storage.getItem(key);
+			if (raw === null) return {
+				items: [],
+				unread: []
+			};
+			const parsed = JSON.parse(raw);
+			if (!Array.isArray(parsed)) return {
+				items: [],
+				unread: []
+			};
+			return {
+				items: validTemplates(parsed),
+				unread: parsed.filter((x) => validTemplates([x]).length === 0)
+			};
+		} catch (e) {
+			return e instanceof SyntaxError ? {
+				items: [],
+				unread: []
+			} : void 0;
+		}
+	};
+	let { items, unread } = read() ?? {
+		items: [],
+		unread: []
+	};
+	/** Picks up what another tab wrote. */
+	const sync = () => {
+		const stored = read();
+		if (stored) ({items, unread} = stored);
+	};
+	/** The id of an entry that may not be a template, if it has one. */
+	const idOf = (x) => typeof x === "object" && x !== null ? x.id : void 0;
+	/**
+	* Writes `next`, then adopts it; leaves everything as it was when storage refuses. Entries
+	* it cannot read go back after the templates, less any whose id a template now has.
+	*/
+	const commit = (next) => {
+		const ids = new Set(next.map((t) => t.id));
+		const kept = unread.filter((x) => idOf(x) === void 0 || !ids.has(idOf(x)));
+		if (storage) try {
+			storage.setItem(key, JSON.stringify([...next, ...kept]));
+		} catch (cause) {
+			return Promise.reject(new Error("The signature could not be saved: browser storage is full", { cause }));
+		}
+		items = next;
+		unread = kept;
+		return Promise.resolve();
+	};
+	return {
+		list() {
+			sync();
+			return Promise.resolve(items.map(copy));
+		},
+		save(t) {
+			sync();
+			return commit(upsert(items, t));
+		},
+		remove(id) {
+			sync();
+			return commit(items.filter((x) => x.id !== id));
+		}
+	};
+}
+/**
+* Fits strokes into a unit box, for an ink template. Points come in any y-up space; they go
+* out between 0 and 1 on both axes, and `aspect` is the box's width over its height. A flat
+* side is given 1% of the long side (a dot, a square), so the aspect stays finite, and the
+* strokes are centred across it.
+*/
+function normaliseInk(inklist) {
+	const all = inklist.flat();
+	const xs = all.map((p) => p.x);
+	const ys = all.map((p) => p.y);
+	const minX = Math.min(...xs);
+	const minY = Math.min(...ys);
+	const w = Math.max(...xs) - minX;
+	const h = Math.max(...ys) - minY;
+	const long = Math.max(w, h);
+	const boxW = long === 0 ? 1 : Math.max(w, long * .01);
+	const boxH = long === 0 ? 1 : Math.max(h, long * .01);
+	const map = (p) => ({
+		x: (p.x - minX + (boxW - w) / 2) / boxW,
+		y: (p.y - minY + (boxH - h) / 2) / boxH
+	});
+	return {
+		inklist: inklist.map((path) => path.map(map)),
+		aspect: boxW / boxH
+	};
+}
+/**
+* An ink template from strokes in any y-up space, with a new id. Throws a RangeError for no
+* strokes, an empty stroke, or pressure that does not have one value per point.
+*/
+function createInkTemplate(inklist, pressure) {
+	if (inklist.length === 0 || inklist.some((path) => path.length === 0)) throw new RangeError("A signature needs at least one stroke, and no empty strokes");
+	if (pressure && (pressure.length !== inklist.length || pressure.some((p, i) => p.length !== inklist[i].length))) throw new RangeError("pressure must have the same shape as inklist");
+	const fitted = normaliseInk(inklist);
+	return {
+		id: v7(),
+		kind: "ink",
+		inklist: fitted.inklist,
+		...pressure ? { pressure: pressure.map((p) => [...p]) } : {},
+		aspect: fitted.aspect
+	};
+}
+/** An image template, with a new id. Throws a TypeError unless `imagedata` is a PNG or JPEG data URL. */
+function createImageTemplate(imagedata, aspect) {
+	if (!IMAGE_DATA_URL.test(imagedata)) throw new TypeError("A signature image must be a PNG or JPEG data URL");
+	if (!(aspect > 0 && Number.isFinite(aspect))) throw new RangeError(`aspect must be positive, got ${aspect}`);
+	return {
+		id: v7(),
+		kind: "image",
+		imagedata,
+		aspect
+	};
+}
+/**
+* The annotation that places `t` on `page`, `width` points wide on screen and centred on
+* `centre` (user space). `rotation` is the page's /Rotate (clockwise): the signature is turned
+* back by as much, so it reads upright on the page as the file displays it. A viewer's view
+* rotation is left out; it turns the signature with the page like any annotation. Ink becomes `ink` with `subject: 'Signature'`, its strokes inset by half their
+* width; an image becomes a `stamp` with `subject: 'Signature'`.
+*/
+function placeSignature(t, page, centre, width = 150, rotation = 0) {
+	const height = width / t.aspect;
+	const sideways = rotation === 90 || rotation === 270;
+	const rw = sideways ? height : width;
+	const rh = sideways ? width : height;
+	const rect = {
+		x: centre.x - rw / 2,
+		y: centre.y - rh / 2,
+		width: rw,
+		height: rh
+	};
+	if (t.kind === "image") return {
+		type: "stamp",
+		page,
+		subject: "Signature",
+		imagedata: t.imagedata,
+		rect,
+		...rotation === 0 ? {} : { rotation }
+	};
+	const innerW = Math.max(width - 2, 0);
+	const innerH = Math.max(height - 2, 0);
+	const rad = rotation * Math.PI / 180;
+	const cos = Math.round(Math.cos(rad));
+	const sin = Math.round(Math.sin(rad));
+	const place = (p) => {
+		const u = (p.x - .5) * innerW;
+		const v = (p.y - .5) * innerH;
+		return {
+			x: centre.x + u * cos - v * sin,
+			y: centre.y + u * sin + v * cos
+		};
+	};
+	return {
+		type: "ink",
+		page,
+		subject: "Signature",
+		inklist: t.inklist.map((path) => path.map(place)),
+		...t.pressure ? { pressure: t.pressure.map((p) => [...p]) } : {},
+		width: 2,
+		rect
+	};
+}
+function createSignatureLibrary(store) {
+	const templates = writable([]);
+	const removeError = writable(void 0);
+	/**
+	* The newest load that succeeded writes, so a slow one cannot undo a later save, and a later
+	* one that fails does not throw away a slow success.
+	*/
+	let loads = 0;
+	let applied = 0;
+	const refresh = async () => {
+		const n = ++loads;
+		try {
+			const list = validTemplates(await store.list());
+			if (n > applied) {
+				applied = n;
+				templates.set(list);
+			}
+		} catch {}
+	};
+	return {
+		store,
+		templates: readonly(templates),
+		get: (id) => templates.get().find((t) => t.id === id),
+		refresh,
+		async save(t) {
+			await store.save(t);
+			await refresh();
+		},
+		async remove(id) {
+			removeError.set(void 0);
+			try {
+				await store.remove(id);
+			} catch (e) {
+				removeError.set("The signature could not be removed. Try again.");
+				throw e;
+			}
+			await refresh();
+		},
+		removeError: readonly(removeError),
+		clearRemoveError: () => removeError.set(void 0)
+	};
+}
+//#endregion
+export { importAnnotations as $, readonly as $t, styleGroupOf as A, RectSchema as At, isTextMarkup as B, withCalloutBounds as Bt, repliesTo as C, NoteIconSchema as Ct, STYLE_GROUPS as D, PolygonSchema as Dt, withoutReplies as E, PolySchema as Et, typesInGroup as F, TextMarkupSchema as Ft, resizedRect as G, isKnown as Gt, movedEndpoint as H, LINE_ENDINGS as Ht, hasCallout as I, FringeSchema as It, withBox as J, cssVariableDefaults as Jt, scaled as K, pdfNameSet as Kt, hasCornerHandles as L, calloutStroke as Lt, styleGroupsOf as M, ShapeSchema as Mt, supportedProps as N, SquareSchema as Nt, createToolStyle as O, PolylineSchema as Ot, toFields as P, StampSchema as Pt, exportAnnotations as Q, derived as Qt, hasRectGeometry as R, freeTextBox as Rt, isThreadRoot as S, MaskSchema as St, threadRoot as T, PointSchema as Tt, movedTip as U, NOTE_ICONS as Ut, keepsAspect as V, INTENTS as Vt, resizedBox as W, PDF_NAME$1 as Wt, createAnnotationStore as X, staticDefaults as Xt, openDocument as Y, normalizeColor as Yt, deriveRect as Z, mergeLineRects as Zt, defaultEnds as _, isInkError as _n, IMAGE_DATA_URL as _t, createLocalSignatureStore as a, pointsFromFlat as an, pdfColorToHex as at, isAbandonedNote as b, LineSchema as bt, normaliseInk as c, rectContainsPoint as cn, AnnotationSchema as ct, recogniseStroke as d, rectsIntersect as dn, FreeTextSchema as dt, writable as en, createHistory as et, DEFAULT_CORNER_RADIUS as f, translateQuad as fn, FreeTextStyleSchema as ft, constrain as g, InkError as gn, GLOSS_VERSION$1 as gt, SHAPE_KINDS as h, Emitter as hn, GLOSS_SCHEMA_ID as ht, createInkTemplate as i, multiplyMatrix as in, importedId as it, styleGroupOfType as j, RedactSchema as jt, fromAnnotation as k, QuadSchema as kt, placeSignature as l, rectFromPoints as ln, CircleSchema as lt, DEFAULT_SHAPE_SIZE as m, unionRects as mn, GLOSS_MEDIA_TYPE as mt, SIGNATURE_INK_WIDTH as n, approxEqual as nn, SUPPORTED_SUBTYPES as nt, createMemorySignatureStore as o, quadFromRect as on, summarise as ot, DEFAULT_SHAPE_OPTIONS as p, translateRect as pn, GLOSS_FORMAT$1 as pt, translated as q, parsePdfDate as qt, createImageTemplate as r, invertMatrix as rn, importEmbeddedPage as rt, createSignatureLibrary as s, quadsFromFlat as sn, AnnotationDocumentSchema as st, DEFAULT_SIGNATURE_WIDTH as t, applyMatrix as tn, isProduction as tt, RECOGNISE_THRESHOLD as u, rectFromQuad as un, ExportedAnnotationSchema as ut, isPointerOnlyKind as v, InkSchema as vt, threadOf as w, NoteSchema as wt, isReply as x, LoupeSchema as xt, shapeInput as y, LineEndingSchema as yt, isBubble as z, isStandardCallout as zt };
+
+//# sourceMappingURL=signatures-CMapTKrC.mjs.map