@inkbar/core 0.2.0 → 0.4.0

package/dist/threads-BtvtrAhL.mjs

@@ -1,1878 +0,0 @@
-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",
-	note: "#F2C230",
-	freeText: "#151820",
-	square: "#C0392B",
-	circle: "#C0392B",
-	line: "#151820",
-	polyline: "#151820",
-	polygon: "#151820",
-	ink: "#151820",
-	redact: "#C0392B"
-};
-/**
-* Suggested-redaction colours, strengthening with confidence: amber for low, orange for
-* medium, the redaction red for high.
-*/
-const SUGGESTION_COLORS = {
-	low: "#D4A017",
-	medium: "#E67E22",
-	high: "#C0392B"
-};
-const staticDefaults = {
-	color: (type) => COLORS[type],
-	fill: () => "#000000",
-	opacity: (type) => type === "highlight" ? .4 : 1,
-	suggestion: (bucket) => SUGGESTION_COLORS[bucket]
-};
-const VARIABLES = {
-	highlight: "--ink-highlight",
-	underline: "--ink-underline",
-	strikeout: "--ink-strikeout",
-	squiggly: "--ink-squiggly",
-	note: "--ink-note",
-	freeText: "--ink-free-text",
-	square: "--ink-shape",
-	circle: "--ink-shape",
-	line: "--ink-shape",
-	polyline: "--ink-shape",
-	polygon: "--ink-shape",
-	ink: "--ink-ink",
-	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),
-		suggestion: (bucket) => read(`--ink-suggestion-${bucket}`) ?? staticDefaults.suggestion(bucket)
-	};
-}
-/** 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/types.ts
-const ANNOTATION_FORMAT = "inkbar/annotations";
-const ANNOTATION_VERSION = 1;
-const Hex = z.string().regex(/^#[0-9a-fA-F]{6}$/, "expected #RRGGBB");
-const PointSchema = z.object({
-	x: z.number(),
-	y: z.number()
-});
-const RectSchema = z.object({
-	x: z.number(),
-	y: z.number(),
-	width: z.number().nonnegative(),
-	height: z.number().nonnegative()
-});
-const QuadSchema = z.object({
-	p1: PointSchema,
-	p2: PointSchema,
-	p3: PointSchema,
-	p4: PointSchema
-});
-const Base = z.object({
-	/** Client id, UUIDv7, assigned at creation and never reassigned. Embedded annotations use `pdf:<ref>`. */
-	id: z.string().min(1),
-	/** 0-based page index. */
-	page: z.number().int().nonnegative(),
-	/** Bounding box in PDF user space. */
-	rect: RectSchema,
-	/** Resolved #RRGGBB. Written into the PDF later, so it is always concrete. */
-	color: Hex,
-	opacity: z.number().min(0).max(1),
-	author: z.string().optional(),
-	contents: z.string().optional(),
-	/** Id of the parent note; replies form threads. */
-	inReplyTo: z.string().optional(),
-	createdAt: z.string(),
-	modifiedAt: z.string(),
-	/** Created in this session, or imported from the file. */
-	source: z.enum(["session", "pdf"]),
-	/** Embedded annotations are locked until the engine can rewrite the file. */
-	locked: z.boolean().optional(),
-	/** Host data. Preserved, never interpreted. */
-	custom: z.record(z.string(), z.unknown()).optional()
-});
-const TextMarkupSchema = Base.extend({
-	type: z.enum([
-		"highlight",
-		"underline",
-		"strikeout",
-		"squiggly"
-	]),
-	quads: z.array(QuadSchema).min(1)
-});
-const NoteSchema = Base.extend({
-	type: z.literal("note"),
-	icon: z.enum([
-		"comment",
-		"note",
-		"help",
-		"insert",
-		"key",
-		"paragraph"
-	]).default("comment")
-});
-const FreeTextSchema = Base.extend({
-	type: z.literal("freeText"),
-	text: z.string(),
-	fontSize: z.number().positive().default(12),
-	fontFamily: z.string().default("Helvetica"),
-	align: z.enum([
-		"left",
-		"center",
-		"right"
-	]).default("left"),
-	callout: z.array(PointSchema).min(2).max(3).optional()
-});
-const ShapeSchema = Base.extend({
-	type: z.enum(["square", "circle"]),
-	strokeWidth: z.number().nonnegative().default(1),
-	fill: Hex.optional()
-});
-const LineEndingSchema = z.enum([
-	"none",
-	"openArrow",
-	"closedArrow",
-	"square",
-	"circle",
-	"diamond",
-	"butt",
-	"slash"
-]);
-const LineSchema = Base.extend({
-	type: z.literal("line"),
-	start: PointSchema,
-	end: PointSchema,
-	strokeWidth: z.number().nonnegative().default(1),
-	endings: z.tuple([LineEndingSchema, LineEndingSchema]).optional()
-});
-const PolySchema = Base.extend({
-	type: z.enum(["polyline", "polygon"]),
-	vertices: z.array(PointSchema).min(2),
-	strokeWidth: z.number().nonnegative().default(1),
-	fill: Hex.optional()
-});
-const InkSchema = Base.extend({
-	type: z.literal("ink"),
-	paths: z.array(z.array(PointSchema).min(1)).min(1),
-	strokeWidth: z.number().nonnegative().default(2)
-});
-const SuggestionSchema = z.object({
-	jobId: z.string().optional(),
-	confidence: z.number().min(0).max(1),
-	reason: z.string().optional(),
-	explanation: z.string().optional(),
-	recommendation: z.enum([
-		"redact",
-		"review",
-		"keep"
-	]).optional()
-});
-const RedactSchema = Base.extend({
-	type: z.literal("redact"),
-	/** Present when the mark came from text; absent for an area mark. */
-	quads: z.array(QuadSchema).min(1).optional(),
-	origin: z.enum(["user", "suggested"]).default("user"),
-	suggestion: SuggestionSchema.optional(),
-	overlayText: z.string().optional(),
-	/** Colour the redaction will be filled with when applied. */
-	fill: Hex
-});
-const AnnotationSchema = z.discriminatedUnion("type", [
-	TextMarkupSchema,
-	NoteSchema,
-	FreeTextSchema,
-	ShapeSchema,
-	LineSchema,
-	PolySchema,
-	InkSchema,
-	RedactSchema
-]);
-const AnnotationDocumentSchema = z.object({
-	format: z.literal(ANNOTATION_FORMAT),
-	version: z.literal(1),
-	documentKey: z.string().optional(),
-	/** Validated item by item on import so unknown types can be preserved. */
-	annotations: z.array(z.unknown())
-});
-function confidenceBucket(confidence) {
-	if (confidence < .5) return "low";
-	if (confidence < .8) return "medium";
-	return "high";
-}
-//#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]
-	});
-}
-const ICONS = {
-	comment: "comment",
-	note: "note",
-	help: "help",
-	insert: "insert",
-	key: "key",
-	paragraph: "paragraph",
-	newparagraph: "paragraph"
-};
-const ENDINGS = {
-	none: "none",
-	openarrow: "openArrow",
-	closedarrow: "closedArrow",
-	square: "square",
-	circle: "circle",
-	diamond: "diamond",
-	butt: "butt",
-	slash: "slash",
-	rslash: "slash"
-};
-/**
-* 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}`;
-}
-function importEmbeddedPage(page, raw, importedAt) {
-	const counts = {};
-	const annotations = [];
-	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) annotations.push(converted);
-	}
-	return {
-		annotations,
-		counts
-	};
-}
-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 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) } : {},
-		createdAt: created,
-		modifiedAt: parsePdfDate(d.modificationDate, created),
-		source: "pdf",
-		locked: true
-	});
-	const fillOf = (c) => c && c.length >= 3 ? { fill: 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":
-			candidate = {
-				...base("note"),
-				type: "note",
-				icon: ICONS[(d.name ?? "comment").toLowerCase()] ?? "comment"
-			};
-			break;
-		case "FreeText": {
-			const da = d.defaultAppearanceData;
-			candidate = {
-				...base("freeText", pdfColorToHex(da?.fontColor, staticDefaults.color("freeText"))),
-				type: "freeText",
-				text: contents ?? "",
-				...da && da.fontSize > 0 ? { fontSize: da.fontSize } : {}
-			};
-			break;
-		}
-		case "Square":
-		case "Circle": {
-			const type = d.subtype.toLowerCase();
-			candidate = {
-				...base(type),
-				type,
-				strokeWidth: stroke,
-				...fillOf(d.interiorColor)
-			};
-			break;
-		}
-		case "Line": {
-			const l = d.lineCoordinates ?? [
-				d.rect[0],
-				d.rect[1],
-				d.rect[2],
-				d.rect[3]
-			];
-			const endings = d.lineEndings?.map((e) => ENDINGS[e.toLowerCase()] ?? "none");
-			candidate = {
-				...base("line"),
-				type: "line",
-				start: {
-					x: l[0],
-					y: l[1]
-				},
-				end: {
-					x: l[2],
-					y: l[3]
-				},
-				strokeWidth: stroke,
-				...endings && endings.length === 2 && endings.some((e) => e !== "none") ? { endings } : {}
-			};
-			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,
-				strokeWidth: stroke,
-				...fillOf(d.interiorColor)
-			};
-			break;
-		}
-		case "Ink": {
-			const paths = (d.inkLists ?? []).map((p) => pointsFromFlat(p)).filter((p) => p.length > 0);
-			if (paths.length === 0) return void 0;
-			candidate = {
-				...base("ink"),
-				type: "ink",
-				paths,
-				strokeWidth: stroke
-			};
-			break;
-		}
-		case "Redact":
-			candidate = {
-				...base("redact"),
-				type: "redact",
-				origin: "user",
-				fill: 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/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") {
-			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/json.ts
-const KNOWN_TYPES = new Set(AnnotationSchema.options.flatMap((o) => [...o.shape.type._zod.values]));
-/**
-* Session annotations plus any preserved foreign items. Embedded (`source: 'pdf'`) ones stay in
-* the file.
-*
-* 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.
-*
-* Without foreign items the result validates against this version's `schema.json`. With them it
-* validates only against the newer schema that produced them, since this version's schema
-* describes only the types it knows.
-*/
-function exportAnnotations(store, preserved = [], documentKey) {
-	const session = store.list.get().filter((a) => a.source === "session");
-	return {
-		format: ANNOTATION_FORMAT,
-		version: 1,
-		...documentKey === void 0 ? {} : { documentKey },
-		annotations: JSON.parse(JSON.stringify([...session, ...preserved]))
-	};
-}
-/**
-* Validates the envelope (throws a TypeError when it is not an inkbar/annotations 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 an ${ANNOTATION_FORMAT} v1 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((item, index) => {
-		const type = item?.type;
-		if (typeof type === "string" && !KNOWN_TYPES.has(type)) {
-			if (!isForeign(item)) result.errors.push({
-				index,
-				issues: [`type: unknown type "${type}" needs a string id and a numeric page to be preserved`]
-			});
-			else if (claim(item.id, index)) result.unknown.push(item);
-			return;
-		}
-		const parsed = AnnotationSchema.safeParse(item);
-		if (!parsed.success) {
-			result.errors.push({
-				index,
-				issues: parsed.error.issues.map((i) => `${i.path.join(".")}: ${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 isForeign(item) {
-	if (typeof item !== "object" || item === null || Array.isArray(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",
-	"paths",
-	"start",
-	"end",
-	"vertices",
-	"callout",
-	"contents"
-]);
-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.strokeWidth ?? 2) / 2;
-			const r = bounds(input.paths.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
-	};
-}
-/** 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 === "redact") {
-			if (input.fill === void 0) candidate.fill = opts.defaults.fill();
-			if (input.origin === "suggested" && input.suggestion && input.color === void 0) candidate.color = opts.defaults.suggestion(confidenceBucket(input.suggestion.confidence));
-		}
-		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;
-		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;
-			commit([...basis(), a], {
-				kind: "add",
-				annotation: a
-			});
-			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,
-				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"
-			});
-		},
-		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 = [];
-	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);
-		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 });
-	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);
-}
-//#endregion
-//#region src/model/annotations/suggestions.ts
-/**
-* Keeps a suggested redaction as the user's own: `origin` becomes `'user'` and the colour
-* goes from the confidence colour to the store's default redaction colour, so an accepted
-* mark looks like any other. The suggestion details stay on it. Returns the updated
-* annotation, or undefined (changing nothing) when `id` is not a suggested redaction or is
-* locked.
-*/
-function acceptSuggestion(store, id) {
-	const a = store._getProposed(id);
-	if (a?.type !== "redact" || a.origin !== "suggested" || a.locked) return void 0;
-	return store.update(id, {
-		origin: "user",
-		color: store.defaults.color("redact")
-	});
-}
-//#endregion
-//#region src/model/annotations/threads.ts
-/** 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 note's thread: follows `inReplyTo` up through notes, stopping at a missing
-* parent, a parent that is not a note, or a cycle.
-*/
-function threadRoot(list, start) {
-	const seen = /* @__PURE__ */ new Set([start.id]);
-	let current = start;
-	while (current.inReplyTo) {
-		const parent = list.find((a) => a.id === current.inReplyTo);
-		if (parent?.type !== "note" || 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. */
-function isAbandonedNote(list, id) {
-	const a = list.find((x) => x.id === id);
-	if (a?.type !== "note" || a.locked || a.inReplyTo || a.contents?.trim()) return false;
-	return repliesTo(list, id).length === 0;
-}
-//#endregion
-export { rectFromQuad as $, RectSchema as A, mergeLineRects as B, InkSchema as C, PointSchema as D, NoteSchema as E, confidenceBucket as F, approxEqual as G, readonly as H, parsePdfDate as I, pointsFromFlat as J, invertMatrix as K, cssVariableDefaults as L, ShapeSchema as M, SuggestionSchema as N, PolySchema as O, TextMarkupSchema as P, rectFromPoints as Q, normalizeColor as R, FreeTextSchema as S, LineSchema as T, writable as U, derived as V, applyMatrix as W, quadsFromFlat as X, quadFromRect as Y, rectContainsPoint as Z, summarise as _, acceptSuggestion as a, InkError as at, AnnotationDocumentSchema as b, deriveRect as c, createHistory as d, rectsIntersect as et, isProduction as f, pdfColorToHex as g, importedId as h, threadRoot as i, Emitter as it, RedactSchema as j, QuadSchema as k, exportAnnotations as l, importEmbeddedPage as m, repliesTo as n, translateRect as nt, openDocument as o, isInkError as ot, SUPPORTED_SUBTYPES as p, multiplyMatrix as q, threadOf as r, unionRects as rt, createAnnotationStore as s, isAbandonedNote as t, translateQuad as tt, importAnnotations as u, ANNOTATION_FORMAT as v, LineEndingSchema as w, AnnotationSchema as x, ANNOTATION_VERSION as y, staticDefaults as z };
-
-//# sourceMappingURL=threads-BtvtrAhL.mjs.map