@inkbar/react 0.0.0-stage → 0.2.0

package/dist/index.mjs

@@ -0,0 +1,1358 @@
+"use client";
+import { createContext, createElement, useCallback, useContext, useEffect, useImperativeHandle, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { InkError, acceptSuggestion, confidenceBucket, createSnapshotHistory, isAbandonedNote, openDocument, repliesTo, threadOf, threadRoot } from "@inkbar/core";
+import { TOOL_LABELS, ZOOM_LEVELS, createFocusReturn, cssVariableDefaults, mountViewer, observeAnnotationElement, shouldKeepOpenOnAnnotation } from "@inkbar/core/dom";
+import { Popover, Select, Slot, Toolbar } from "radix-ui";
+import { createPortal, flushSync } from "react-dom";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Check, ChevronDown, ChevronLeft, ChevronRight, Hand, Highlighter, ICON_ATTRIBUTES, MessageSquare, MousePointer2, Redo2, Square, Undo2, ZoomIn, ZoomOut } from "@inkbar/icons";
+//#region src/context.ts
+const InkContextObject = createContext(null);
+/**
+* The context for hooks: throws a readable error when called outside a component rendered
+* inside `InkRoot`.
+*/
+function useInkContext(consumer) {
+	const ctx = useContext(InkContextObject);
+	if (!ctx) throw new Error(`[inkbar] ${consumer} must be called in a component inside <InkRoot>.`);
+	return ctx;
+}
+//#endregion
+//#region src/use-readable.ts
+const noop = () => void 0;
+/**
+* Mirrors a core `Readable` into React. A missing readable yields `fallback`, which must be a
+* stable reference (a module constant): `useSyncExternalStore` compares snapshots by identity
+* and loops on a fresh value. On the server the fallback is rendered.
+*/
+function useReadable(readable, fallback) {
+	const subscribe = useCallback((onChange) => readable ? readable.subscribe(() => onChange()) : noop, [readable]);
+	const get = useCallback(() => readable ? readable.get() : fallback, [readable, fallback]);
+	const server = useCallback(() => fallback, [fallback]);
+	return useSyncExternalStore(subscribe, get, server);
+}
+//#endregion
+//#region src/hooks/useDocument.ts
+const NO_PAGES = [];
+function useDocument() {
+	const { document, status } = useInkContext("useDocument()");
+	return useMemo(() => ({
+		document,
+		status,
+		isReady: status.state === "ready",
+		error: status.state === "error" ? status.error : null,
+		pages: document?.pages ?? NO_PAGES,
+		info: document?.info ?? null,
+		exportAnnotations: () => document?.exportAnnotations("json"),
+		importAnnotations: (data, opts) => document?.importAnnotations(data, opts)
+	}), [document, status]);
+}
+//#endregion
+//#region src/hooks/useAnnotations.ts
+function useAnnotations() {
+	const { annotations, selection, document } = useInkContext("useAnnotations()");
+	const store = document?.annotations;
+	const selected = useMemo(() => selection.map((id) => annotations.find((a) => a.id === id)).filter((a) => !!a), [annotations, selection]);
+	const actions = useMemo(() => ({
+		add: (input) => store?.add(input),
+		update: (id, patch) => store?.update(id, patch),
+		remove: (id) => store?.remove(id) ?? false,
+		select: (ids) => store?.select(ids),
+		/** Keeps a suggested redaction as the user's own, in the default redaction colour. */
+		accept: (id) => store ? acceptSuggestion(store, id) : void 0,
+		dismiss: (id) => store?.remove(id) ?? false
+	}), [store]);
+	return useMemo(() => ({
+		annotations,
+		selection,
+		selected,
+		byPage: (page) => annotations.filter((a) => a.page === page),
+		/** Replies in creation order for a note id. */
+		replies: (id) => repliesTo(annotations, id),
+		...actions
+	}), [
+		annotations,
+		selection,
+		selected,
+		actions
+	]);
+}
+//#endregion
+//#region src/hooks/useTool.ts
+function useTool() {
+	const { tool, setTool } = useInkContext("useTool()");
+	return useMemo(() => ({
+		tool,
+		setTool
+	}), [tool, setTool]);
+}
+//#endregion
+//#region src/hooks/useSelection.ts
+function useSelection() {
+	const { selection, document } = useInkContext("useSelection()");
+	const store = document?.annotations;
+	return useMemo(() => ({
+		selection,
+		select: (ids) => store?.select(ids),
+		clear: () => store?.select([])
+	}), [selection, store]);
+}
+//#endregion
+//#region src/hooks/useZoom.ts
+function useZoom() {
+	const { viewport } = useInkContext("useZoom()");
+	const zoom = useReadable(viewport?.zoom, "fit-width");
+	const scale = useReadable(viewport?.scale, 1);
+	return useMemo(() => ({
+		zoom,
+		scale,
+		setZoom: (z) => viewport?.setZoom(z),
+		zoomIn: () => viewport?.zoomBy(1.25),
+		zoomOut: () => viewport?.zoomBy(.8)
+	}), [
+		viewport,
+		zoom,
+		scale
+	]);
+}
+//#endregion
+//#region src/hooks/usePage.ts
+function usePage() {
+	const { viewport, document } = useInkContext("usePage()");
+	const current = useReadable(viewport?.currentPage, 0);
+	return useMemo(() => ({
+		/** 0-based. */
+		current,
+		count: document?.pages.length ?? 0,
+		goTo: (index) => viewport?.scrollToPage(index),
+		next: () => viewport?.scrollToPage(viewport.currentPage.get() + 1),
+		previous: () => viewport?.scrollToPage(viewport.currentPage.get() - 1),
+		scrollToAnnotation(id) {
+			const a = document?.annotations.get(id);
+			if (a) viewport?.scrollToRect(a.page, a.rect);
+		}
+	}), [
+		viewport,
+		document,
+		current
+	]);
+}
+//#endregion
+//#region src/hooks/useHistory.ts
+/**
+* Undo and redo. Uncontrolled documents use the core history; controlled hosts that pass
+* `history` to InkRoot get a snapshot stack over their own list, applied through
+* `onAnnotationsChange`.
+*/
+function useHistory() {
+	return useInkContext("useHistory()").history;
+}
+//#endregion
+//#region src/hooks/useEmbedded.ts
+const NONE = [];
+function useEmbedded() {
+	const summary = useInkContext("useEmbedded()").document?.embedded ?? NONE;
+	return useMemo(() => ({
+		summary,
+		total: summary.reduce((n, s) => n + s.count, 0),
+		hasAny: summary.length > 0
+	}), [summary]);
+}
+//#endregion
+//#region src/use-latest.ts
+/**
+* A ref that always holds the latest render's value, for callbacks that outlive a render
+* (core's `onChange`, effects keyed on something else). Updated in a layout effect, so it is
+* current before the parent's own layout and passive effects and before any callback fired
+* after commit; declare it before the effects that read it.
+*/
+function useLatest(value) {
+	const ref = useRef(value);
+	useLayoutEffect(() => {
+		ref.current = value;
+	});
+	return ref;
+}
+//#endregion
+//#region src/components/InkRoot.tsx
+const IDLE = { state: "idle" };
+const NO_ANNOTATIONS = [];
+const NO_IDS = [];
+/** Signed URLs change; the key does not. Bytes and Blobs are their own identity. */
+function identity(src) {
+	if (src === null) return null;
+	if (typeof src === "string") return src;
+	if ("key" in src) return src.key;
+	return src;
+}
+function isDevelopment() {
+	try {
+		return process.env.NODE_ENV !== "production";
+	} catch {
+		return false;
+	}
+}
+function setTestHook(el, doc) {
+	if (el && isDevelopment()) el.__inkDocument = doc;
+}
+function InkRoot({ src, assets, password, defaults, annotations, onAnnotationsChange, onChange, tool, onToolChange, page, onPageChange, zoom, onZoomChange, history, asChild = false, onReady, onError, onActivate, children, ref, ...rest }) {
+	const rootElRef = useRef(null);
+	const [rootEl, setRootElState] = useState(null);
+	const setRootEl = useCallback((el) => {
+		rootElRef.current = el;
+		setRootElState(el);
+	}, []);
+	const documentRef = useRef(null);
+	const [document, setDocument] = useState(null);
+	/** Overrides the document's status while opening, and when opening itself failed. */
+	const [override, setOverride] = useState(null);
+	const [internalTool, setInternalTool] = useState(tool ?? "view");
+	const [activated, setActivatedState] = useState(null);
+	const [viewport, setViewportState] = useState(null);
+	const [tools, setToolsState] = useState(null);
+	const documentStatus = useReadable(document?.status, IDLE);
+	const status = override ?? documentStatus;
+	const annotationList = useReadable(document?.annotations.list, NO_ANNOTATIONS);
+	const selection = useReadable(document?.annotations.selection, NO_IDS);
+	const controlledProp = annotations !== void 0;
+	const controlled = document ? document.annotations.mode === "controlled" : controlledProp;
+	const historyEnabled = controlled && history === true;
+	const latest = useLatest({
+		src,
+		assets,
+		defaults,
+		annotations,
+		controlled: controlledProp,
+		history,
+		historyEnabled,
+		onAnnotationsChange,
+		onChange,
+		onReady,
+		onError,
+		onActivate,
+		onToolChange,
+		onPageChange,
+		onZoomChange
+	});
+	const snapshotHistory = useMemo(() => createSnapshotHistory({
+		apply: (list) => documentRef.current?.annotations.replaceAll(list, "history"),
+		enabled: () => latest.current.historyEnabled
+	}), [latest]);
+	useEffect(() => {
+		snapshotHistory.observe(annotations);
+	}, [annotations, snapshotHistory]);
+	const srcIdentity = identity(src);
+	useEffect(() => {
+		let cancelled = false;
+		snapshotHistory.clear();
+		const source = latest.current.src;
+		if (source === null) {
+			setOverride(null);
+			return;
+		}
+		setOverride({ state: "loading" });
+		let opened = null;
+		const run = async () => {
+			try {
+				const doc = await openDocument(source, {
+					assets: latest.current.assets,
+					password,
+					defaults: latest.current.defaults ?? (rootElRef.current ? cssVariableDefaults(rootElRef.current) : void 0),
+					history: latest.current.controlled ? false : latest.current.history ?? true,
+					annotations: latest.current.controlled ? {
+						mode: "controlled",
+						initial: latest.current.annotations ?? [],
+						onChange: (next, change) => {
+							queueMicrotask(() => {
+								if (cancelled) return;
+								flushSync(() => {
+									latest.current.onAnnotationsChange?.(next);
+									latest.current.onChange?.(change);
+								});
+							});
+						}
+					} : { mode: "uncontrolled" }
+				});
+				if (cancelled) {
+					doc.destroy();
+					return;
+				}
+				opened = doc;
+				const current = latest.current.annotations;
+				if (doc.annotations.mode === "controlled" && current !== void 0) doc.annotations.setControlledValue(current);
+				documentRef.current = doc;
+				setDocument(doc);
+				setOverride(null);
+				setTestHook(rootElRef.current, doc);
+				const s = doc.status.get();
+				if (s.state === "ready") latest.current.onReady?.(doc);
+				else if (s.state === "error") latest.current.onError?.(s.error);
+			} catch (cause) {
+				if (cancelled) return;
+				const error = cause instanceof InkError ? cause : new InkError("InvalidPdf", cause instanceof Error ? cause.message : String(cause), {}, cause);
+				setOverride({
+					state: "error",
+					error
+				});
+				latest.current.onError?.(error);
+			}
+		};
+		Promise.resolve().then(() => {
+			if (!cancelled) return run();
+		});
+		return () => {
+			cancelled = true;
+			opened?.destroy();
+			documentRef.current = null;
+			setDocument(null);
+			setTestHook(rootElRef.current, void 0);
+		};
+	}, [
+		srcIdentity,
+		password,
+		snapshotHistory,
+		latest
+	]);
+	useLayoutEffect(() => {
+		if (annotations && document?.annotations.mode === "controlled") document.annotations.setControlledValue(annotations);
+	}, [annotations, document]);
+	useEffect(() => {
+		if (tool) setInternalTool(tool);
+	}, [tool]);
+	const setTool = useCallback((id) => {
+		setInternalTool(id);
+		latest.current.onToolChange?.(id);
+	}, [latest]);
+	const setActivated = useCallback((id) => {
+		setActivatedState(id);
+		if (id) latest.current.onActivate?.(id);
+	}, [latest]);
+	const reportZoom = useCallback((z) => latest.current.onZoomChange?.(z), [latest]);
+	const reportPage = useCallback((p) => latest.current.onPageChange?.(p), [latest]);
+	const setViewport = useCallback((vp, tc) => {
+		setViewportState(vp);
+		setToolsState(tc);
+	}, []);
+	const snapCanUndo = useReadable(snapshotHistory.canUndo, false);
+	const snapCanRedo = useReadable(snapshotHistory.canRedo, false);
+	const coreCanUndo = useReadable(document?.history.canUndo, false);
+	const coreCanRedo = useReadable(document?.history.canRedo, false);
+	const inkHistory = useMemo(() => ({
+		canUndo: controlled ? historyEnabled && snapCanUndo : coreCanUndo,
+		canRedo: controlled ? historyEnabled && snapCanRedo : coreCanRedo,
+		undo: () => controlled ? snapshotHistory.undo() : documentRef.current?.history.undo(),
+		redo: () => controlled ? snapshotHistory.redo() : documentRef.current?.history.redo(),
+		clear: () => controlled ? snapshotHistory.clear() : documentRef.current?.history.clear(),
+		batch: (fn) => {
+			if (controlled) snapshotHistory.batch(fn);
+			else if (documentRef.current) documentRef.current.history.batch(fn);
+			else fn();
+		}
+	}), [
+		controlled,
+		historyEnabled,
+		snapCanUndo,
+		snapCanRedo,
+		coreCanUndo,
+		coreCanRedo,
+		snapshotHistory
+	]);
+	useImperativeHandle(ref, () => ({
+		document,
+		status,
+		rootEl,
+		history: inkHistory
+	}), [
+		document,
+		status,
+		rootEl,
+		inkHistory
+	]);
+	const ctx = useMemo(() => ({
+		assets,
+		document,
+		status,
+		annotations: annotationList,
+		selection,
+		viewport,
+		tools,
+		tool: internalTool,
+		setTool,
+		zoomModel: zoom,
+		pageModel: page,
+		reportZoom,
+		reportPage,
+		activated,
+		setActivated,
+		history: inkHistory,
+		rootEl,
+		setViewport
+	}), [
+		assets,
+		document,
+		status,
+		annotationList,
+		selection,
+		viewport,
+		tools,
+		internalTool,
+		setTool,
+		zoom,
+		page,
+		reportZoom,
+		reportPage,
+		activated,
+		setActivated,
+		inkHistory,
+		rootEl,
+		setViewport
+	]);
+	const Comp = asChild ? Slot.Root : "div";
+	return /* @__PURE__ */ jsx(InkContextObject.Provider, {
+		value: ctx,
+		children: /* @__PURE__ */ jsx(Comp, {
+			ref: setRootEl,
+			"data-ink-root": "",
+			"data-state": status.state,
+			...rest,
+			children: typeof children === "function" ? children({
+				status,
+				document
+			}) : children
+		})
+	});
+}
+//#endregion
+//#region src/class-names.ts
+/** Joins class names, dropping empties. */
+function cx(...parts) {
+	const out = parts.filter(Boolean).join(" ");
+	return out === "" ? void 0 : out;
+}
+//#endregion
+//#region src/components/InkAnnotation.tsx
+function readState(el) {
+	const s = el.dataset.state;
+	return s === "idle" || s === "hover" || s === "selected" ? s : null;
+}
+function InkAnnotation({ annotation, element, children }) {
+	const ctx = useInkContext("InkAnnotation");
+	const [observed, setObserved] = useState(() => element ? readState(element) : null);
+	useEffect(() => {
+		if (!element) {
+			setObserved(null);
+			return;
+		}
+		setObserved(readState(element));
+		const observer = new MutationObserver(() => setObserved(readState(element)));
+		observer.observe(element, {
+			attributes: true,
+			attributeFilter: ["data-state"]
+		});
+		return () => observer.disconnect();
+	}, [element]);
+	const { id } = annotation;
+	const isSuggestion = annotation.type === "redact" && annotation.origin === "suggested";
+	const locked = annotation.locked === true;
+	const selected = ctx.selection.includes(id);
+	const store = ctx.document?.annotations;
+	const slotProps = useMemo(() => ({
+		annotation,
+		state: observed ?? (selected ? "selected" : "idle"),
+		locked,
+		select: () => store?.select([id]),
+		remove: () => void store?.remove(id),
+		accept: () => {
+			if (store && isSuggestion) acceptSuggestion(store, id);
+		},
+		dismiss: () => {
+			if (isSuggestion) store?.remove(id);
+		}
+	}), [
+		annotation,
+		observed,
+		selected,
+		locked,
+		store,
+		id,
+		isSuggestion
+	]);
+	return /* @__PURE__ */ jsx(Fragment, { children: children(slotProps) });
+}
+//#endregion
+//#region src/components/InkPage.tsx
+function sameTargets(a, b) {
+	return a.length === b.length && a.every((t, i) => t.annotation === b[i].annotation && t.el === b[i].el);
+}
+function InkPage({ page, host, mount, error, customAnnotations = false, renderAnnotation, renderPageError }) {
+	const doc = useInkContext("InkPage").document;
+	const [targets, setTargets] = useState([]);
+	useEffect(() => {
+		if (!doc || !customAnnotations) return;
+		const read = () => {
+			const next = doc.annotations.byPage(page).flatMap((annotation) => {
+				const el = mount.overlay.elementFor(annotation.id);
+				return el ? [{
+					annotation,
+					el
+				}] : [];
+			});
+			setTargets((prev) => sameTargets(prev, next) ? prev : next);
+		};
+		const stop = doc.annotations.list.subscribe(read);
+		read();
+		return () => {
+			stop();
+			setTargets([]);
+		};
+	}, [
+		doc,
+		page,
+		mount,
+		customAnnotations
+	]);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [error ? createPortal(/* @__PURE__ */ jsx("div", {
+		className: "ink-page-error",
+		"data-ink-page-error": "",
+		role: "alert",
+		children: renderPageError ? renderPageError({
+			error,
+			page
+		}) : /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsxs("p", { children: [
+			"Page ",
+			page + 1,
+			" could not be shown."
+		] }), /* @__PURE__ */ jsx("code", {
+			className: "ink-error-code",
+			children: error.code
+		})] })
+	}), host) : null, renderAnnotation ? targets.map((t) => createPortal(/* @__PURE__ */ jsx(InkAnnotation, {
+		annotation: t.annotation,
+		element: t.el,
+		children: renderAnnotation
+	}), t.el, t.annotation.id)) : null] });
+}
+//#endregion
+//#region src/components/InkViewport.tsx
+function InkViewport({ mode = "continuous", rotation = 0, gap = 16, buffer = 2, loading, empty, error, renderAnnotation, renderPageError, className, ...rest }) {
+	const ctx = useInkContext("InkViewport");
+	const scroll = useRef(null);
+	const custom = !!renderAnnotation;
+	const latest = useLatest({
+		ctx,
+		mode,
+		rotation,
+		gap,
+		buffer,
+		custom
+	});
+	const engine = useRef(null);
+	/** Page hosts, mounts and errors the engine reported; InkPage renders portals for them. */
+	const [pages, setPages] = useState([]);
+	/**
+	* Numbered before each build starts, so the pages a build mounts carry its own number. A
+	* rebuild gives each page a new host and mount, so pages from an earlier build must remount,
+	* not be reused.
+	*/
+	const buildCount = useRef(0);
+	/** The construction options the engine was last built with, so a rebuild runs only on a change. */
+	const builtWith = useRef(null);
+	/** The zoom and page last reported to the host. */
+	const lastReportedZoom = useRef(void 0);
+	const lastReportedPage = useRef(void 0);
+	useEffect(() => {
+		const { ctx: c, mode: m, rotation: r, gap: g, buffer: b, custom: cu } = latest.current;
+		const doc = c.document;
+		const el = scroll.current;
+		lastReportedZoom.current = void 0;
+		lastReportedPage.current = void 0;
+		if (!doc || !el || c.status.state !== "ready") return;
+		let first = true;
+		let stops = [];
+		buildCount.current += 1;
+		builtWith.current = {
+			gap: g,
+			buffer: b,
+			custom: cu
+		};
+		const e = mountViewer({
+			container: el,
+			document: doc,
+			zoom: c.zoomModel ?? "fit-width",
+			...c.pageModel === void 0 ? {} : { page: c.pageModel },
+			mode: m,
+			rotation: r,
+			gap: g,
+			buffer: b,
+			tool: c.tool,
+			customAnnotations: cu,
+			onActivate: (id) => latest.current.ctx.setActivated(id),
+			onBuild: (vp, tc) => {
+				latest.current.ctx.setViewport(vp, tc);
+				if (first) {
+					first = false;
+					lastReportedZoom.current = vp.zoom.get();
+					lastReportedPage.current = 0;
+				}
+				for (const stop of stops) stop();
+				const reportZoom = (z) => {
+					if (z === lastReportedZoom.current) return;
+					lastReportedZoom.current = z;
+					latest.current.ctx.reportZoom(z);
+				};
+				const reportPage = (p) => {
+					if (p === lastReportedPage.current) return;
+					lastReportedPage.current = p;
+					latest.current.ctx.reportPage(p);
+				};
+				stops = [vp.zoom.subscribe(reportZoom), vp.currentPage.subscribe(reportPage)];
+				reportZoom(vp.zoom.get());
+				reportPage(vp.currentPage.get());
+			},
+			onPageMount: (page, mount, host) => {
+				const build = buildCount.current;
+				const custom = builtWith.current?.custom ?? false;
+				setPages((prev) => [...prev, {
+					build,
+					page,
+					host,
+					mount,
+					error: null,
+					custom
+				}]);
+			},
+			onPageUnmount: (page) => setPages((prev) => prev.filter((p) => p.page !== page)),
+			onPageError: (page, err) => setPages((prev) => prev.map((p) => p.page === page ? {
+				...p,
+				error: err
+			} : p))
+		});
+		engine.current = e;
+		return () => {
+			for (const stop of stops) stop();
+			e.destroy();
+			engine.current = null;
+			builtWith.current = null;
+			c.setViewport(null, null);
+			setPages((prev) => prev.length === 0 ? prev : []);
+		};
+	}, [
+		ctx.document,
+		ctx.status.state,
+		latest
+	]);
+	useEffect(() => {
+		const built = builtWith.current;
+		if (!engine.current || !built) return;
+		if (built.gap === gap && built.buffer === buffer && built.custom === custom) return;
+		buildCount.current += 1;
+		builtWith.current = {
+			gap,
+			buffer,
+			custom
+		};
+		engine.current.rebuild({
+			gap,
+			buffer,
+			customAnnotations: custom
+		});
+	}, [
+		gap,
+		buffer,
+		custom
+	]);
+	useEffect(() => {
+		const vp = engine.current?.viewport;
+		const z = ctx.zoomModel;
+		if (vp && z !== void 0 && z !== vp.zoom.get()) vp.setZoom(z);
+	}, [ctx.zoomModel]);
+	useEffect(() => {
+		const vp = engine.current?.viewport;
+		const p = ctx.pageModel;
+		if (!vp || p === void 0 || p === lastReportedPage.current) return;
+		if (p !== vp.currentPage.get()) vp.scrollToPage(p);
+	}, [ctx.pageModel]);
+	useEffect(() => {
+		const tc = engine.current?.tools;
+		if (tc && tc.active.get() !== ctx.tool) tc.set(ctx.tool);
+	}, [ctx.tool]);
+	useEffect(() => {
+		const vp = engine.current?.viewport;
+		if (vp && vp.mode.get() !== mode) vp.setMode(mode);
+	}, [mode]);
+	useEffect(() => {
+		const vp = engine.current?.viewport;
+		if (vp && vp.rotation.get() !== rotation) vp.setRotation(rotation);
+	}, [rotation]);
+	const state = ctx.status.state;
+	const err = ctx.status.state === "error" ? ctx.status.error : null;
+	return /* @__PURE__ */ jsxs("div", {
+		...rest,
+		className: cx("ink-viewport-root", className),
+		"data-ink-viewport-root": "",
+		"data-state": state,
+		children: [
+			state === "loading" ? /* @__PURE__ */ jsx("div", {
+				className: "ink-status",
+				role: "status",
+				"aria-live": "polite",
+				children: loading === void 0 ? "Loading document…" : loading
+			}) : err ? /* @__PURE__ */ jsx("div", {
+				className: "ink-status ink-error",
+				role: "alert",
+				children: typeof error === "function" ? error({ error: err }) : error !== void 0 ? error : /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("p", {
+					className: "ink-error-title",
+					children: "This document could not be opened."
+				}), /* @__PURE__ */ jsx("p", { children: /* @__PURE__ */ jsx("code", {
+					className: "ink-error-code",
+					title: err.message,
+					children: err.code
+				}) })] })
+			}) : state === "idle" ? /* @__PURE__ */ jsx("div", {
+				className: "ink-status ink-empty",
+				children: empty
+			}) : null,
+			/* @__PURE__ */ jsx("div", {
+				ref: scroll,
+				className: "ink-scroll",
+				"data-ink-scroll": "",
+				tabIndex: 0,
+				role: "document",
+				"aria-label": "Document"
+			}),
+			pages.map((p) => /* @__PURE__ */ jsx(InkPage, {
+				page: p.page,
+				host: p.host,
+				mount: p.mount,
+				error: p.error,
+				customAnnotations: p.custom,
+				renderAnnotation,
+				renderPageError
+			}, `${p.build}:${p.page}`))
+		]
+	});
+}
+//#endregion
+//#region src/components/InkToolbar.tsx
+function InkToolbar({ label = "Document tools", asChild = false, className, children, ...rest }) {
+	return /* @__PURE__ */ jsx(Toolbar.Root, {
+		asChild,
+		orientation: "horizontal",
+		"aria-label": label,
+		"data-ink-toolbar": "",
+		className: cx("ink-toolbar", className),
+		...rest,
+		children
+	});
+}
+//#endregion
+//#region src/components/InkIcon.tsx
+/** `stroke-width` to `strokeWidth`: React names SVG attributes in camelCase. */
+const camel = (name) => name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+const SVG_ATTRIBUTES = Object.fromEntries(Object.entries(ICON_ATTRIBUTES).map(([k, v]) => [camel(k), v]));
+function InkIcon({ icon, size = 18 }) {
+	return /* @__PURE__ */ jsx("svg", {
+		...SVG_ATTRIBUTES,
+		width: size,
+		height: size,
+		className: "ink-icon",
+		"aria-hidden": "true",
+		children: icon.map(([tag, attrs], i) => createElement(tag, {
+			key: i,
+			...attrs
+		}))
+	});
+}
+//#endregion
+//#region src/components/InkToolButton.tsx
+const ICONS = {
+	view: Hand,
+	select: MousePointer2,
+	highlight: Highlighter,
+	"redact-area": Square,
+	note: MessageSquare
+};
+function InkToolButton({ tool, label, asChild = false, className, children, onClick, ...rest }) {
+	const { tool: current, setTool } = useTool();
+	const active = current === tool;
+	const name = label ?? TOOL_LABELS[tool];
+	return /* @__PURE__ */ jsx(Toolbar.Button, {
+		asChild,
+		className: cx("ink-tool-button", className),
+		"data-ink-tool-button": "",
+		"data-tool": tool,
+		"data-state": active ? "on" : "off",
+		"aria-pressed": active,
+		"aria-label": name,
+		title: name,
+		onClick: (e) => {
+			onClick?.(e);
+			if (!e.defaultPrevented) setTool(tool);
+		},
+		...rest,
+		children: typeof children === "function" ? children({
+			active,
+			label: name
+		}) : children ?? /* @__PURE__ */ jsx(InkIcon, { icon: ICONS[tool] })
+	});
+}
+//#endregion
+//#region src/components/InkToolbarSeparator.tsx
+/**
+* A divider between groups of controls in a horizontal toolbar. Not focusable. A plain div
+* rather than Radix's separator, which reads as horizontal inside a horizontal toolbar.
+*/
+function InkToolbarSeparator({ className, ...rest }) {
+	return /* @__PURE__ */ jsx("div", {
+		role: "separator",
+		"aria-orientation": "vertical",
+		className: cx("ink-toolbar-separator", className),
+		"data-ink-toolbar-separator": "",
+		...rest
+	});
+}
+//#endregion
+//#region src/components/InkUndo.tsx
+function InkUndo({ asChild = false, className, children, disabled, onClick, ...rest }) {
+	const { canUndo, undo } = useHistory();
+	return /* @__PURE__ */ jsx(Toolbar.Button, {
+		asChild,
+		className: cx("ink-undo", className),
+		"data-ink-undo": "",
+		"aria-label": "Undo",
+		title: "Undo",
+		...rest,
+		disabled: disabled === true || !canUndo,
+		onClick: (e) => {
+			onClick?.(e);
+			if (!e.defaultPrevented) undo();
+		},
+		children: children ?? /* @__PURE__ */ jsx(InkIcon, { icon: Undo2 })
+	});
+}
+//#endregion
+//#region src/components/InkRedo.tsx
+function InkRedo({ asChild = false, className, children, disabled, onClick, ...rest }) {
+	const { canRedo, redo } = useHistory();
+	return /* @__PURE__ */ jsx(Toolbar.Button, {
+		asChild,
+		className: cx("ink-redo", className),
+		"data-ink-redo": "",
+		"aria-label": "Redo",
+		title: "Redo",
+		...rest,
+		disabled: disabled === true || !canRedo,
+		onClick: (e) => {
+			onClick?.(e);
+			if (!e.defaultPrevented) redo();
+		},
+		children: children ?? /* @__PURE__ */ jsx(InkIcon, { icon: Redo2 })
+	});
+}
+//#endregion
+//#region src/components/InkZoomIn.tsx
+function InkZoomIn({ asChild = false, className, children, onClick, ...rest }) {
+	const { zoomIn } = useZoom();
+	return /* @__PURE__ */ jsx(Toolbar.Button, {
+		asChild,
+		className: cx("ink-zoom-in", className),
+		"data-ink-zoom-in": "",
+		"aria-label": "Zoom in",
+		title: "Zoom in",
+		...rest,
+		onClick: (e) => {
+			onClick?.(e);
+			if (!e.defaultPrevented) zoomIn();
+		},
+		children: children ?? /* @__PURE__ */ jsx(InkIcon, { icon: ZoomIn })
+	});
+}
+//#endregion
+//#region src/components/InkZoomOut.tsx
+function InkZoomOut({ asChild = false, className, children, onClick, ...rest }) {
+	const { zoomOut } = useZoom();
+	return /* @__PURE__ */ jsx(Toolbar.Button, {
+		asChild,
+		className: cx("ink-zoom-out", className),
+		"data-ink-zoom-out": "",
+		"aria-label": "Zoom out",
+		title: "Zoom out",
+		...rest,
+		onClick: (e) => {
+			onClick?.(e);
+			if (!e.defaultPrevented) zoomOut();
+		},
+		children: children ?? /* @__PURE__ */ jsx(InkIcon, { icon: ZoomOut })
+	});
+}
+//#endregion
+//#region src/components/InkZoomSelect.tsx
+const CUSTOM = "custom:";
+const level = (z) => ZOOM_LEVELS.find((l) => Math.abs(l - z) < .001);
+const percent = (z) => `${Math.round(z * 100)}%`;
+const FITS = [{
+	value: "fit-width",
+	label: "Fit width"
+}, {
+	value: "fit-page",
+	label: "Fit page"
+}];
+function Item({ value, label }) {
+	return /* @__PURE__ */ jsxs(Select.Item, {
+		value,
+		className: "ink-select-item",
+		"data-ink-select-item": "",
+		children: [/* @__PURE__ */ jsx(Select.ItemText, { children: label }), /* @__PURE__ */ jsx(Select.ItemIndicator, {
+			className: "ink-select-indicator",
+			children: /* @__PURE__ */ jsx(InkIcon, {
+				icon: Check,
+				size: 16
+			})
+		})]
+	});
+}
+function InkZoomSelect({ className, ...rest }) {
+	const { zoom, scale, setZoom } = useZoom();
+	/** A numeric zoom that is not one of the levels (zoom in and out multiply). */
+	const custom = typeof zoom === "number" && level(zoom) === void 0 ? zoom : null;
+	const value = typeof zoom !== "number" ? zoom : custom === null ? String(level(zoom)) : `${CUSTOM}${zoom}`;
+	/** The levels, with a custom zoom in its place among them. */
+	const levels = ZOOM_LEVELS.map((l) => ({
+		z: l,
+		value: String(l),
+		label: percent(l)
+	}));
+	if (custom !== null) levels.push({
+		z: custom,
+		value: `${CUSTOM}${custom}`,
+		label: percent(scale)
+	});
+	levels.sort((a, b) => a.z - b.z);
+	function onValueChange(v) {
+		if (v === value) return;
+		const next = v === "fit-width" || v === "fit-page" ? v : Number(v.replace(CUSTOM, ""));
+		setZoom(next);
+	}
+	return /* @__PURE__ */ jsxs(Select.Root, {
+		value,
+		onValueChange,
+		children: [/* @__PURE__ */ jsxs(Select.Trigger, {
+			className: cx("ink-zoom-select ink-select-trigger", className),
+			"data-ink-zoom-select": "",
+			"aria-label": "Zoom",
+			...rest,
+			children: [/* @__PURE__ */ jsx(Select.Value, { className: "ink-select-value" }), /* @__PURE__ */ jsx(Select.Icon, {
+				className: "ink-select-icon",
+				children: /* @__PURE__ */ jsx(InkIcon, {
+					icon: ChevronDown,
+					size: 16
+				})
+			})]
+		}), /* @__PURE__ */ jsx(Select.Portal, { children: /* @__PURE__ */ jsx(Select.Content, {
+			className: "ink-select-content",
+			"data-ink-select-content": "",
+			position: "popper",
+			side: "top",
+			sideOffset: 4,
+			children: /* @__PURE__ */ jsxs(Select.Viewport, { children: [
+				FITS.map((o) => /* @__PURE__ */ jsx(Item, {
+					value: o.value,
+					label: o.label
+				}, o.value)),
+				/* @__PURE__ */ jsx(Select.Separator, { className: "ink-select-separator" }),
+				levels.map((o) => /* @__PURE__ */ jsx(Item, {
+					value: o.value,
+					label: o.label
+				}, o.value))
+			] })
+		}) })]
+	});
+}
+//#endregion
+//#region src/components/InkPageInput.tsx
+function InkPageInput({ className, onKeyDown: onKeyDownProp, ...rest }) {
+	const { current, count, goTo } = usePage();
+	const [draft, setDraft] = useState(String(current + 1));
+	useEffect(() => {
+		setDraft(String(current + 1));
+	}, [current]);
+	const input = useRef(null);
+	const latest = useLatest({
+		current,
+		count,
+		goTo
+	});
+	/** 1-based in the input, 0-based in the viewport. Out of range resets to the current page. */
+	const commit = useCallback((value) => {
+		const { current: page, count: total, goTo: go } = latest.current;
+		const n = Number(value);
+		if (Number.isInteger(n) && n >= 1 && n <= total) {
+			if (n - 1 !== page) go(n - 1);
+		} else setDraft(String(page + 1));
+	}, [latest]);
+	useEffect(() => {
+		const el = input.current;
+		if (!el) return;
+		const onNativeChange = () => commit(el.value);
+		el.addEventListener("change", onNativeChange);
+		return () => el.removeEventListener("change", onNativeChange);
+	}, [commit]);
+	function onKeyDown(e) {
+		onKeyDownProp?.(e);
+		if (e.defaultPrevented || e.key !== "Enter") return;
+		e.preventDefault();
+		commit(draft);
+	}
+	return /* @__PURE__ */ jsx("input", {
+		ref: input,
+		className: cx("ink-page-input", className),
+		"data-ink-page-input": "",
+		type: "number",
+		inputMode: "numeric",
+		"aria-label": "Page",
+		min: 1,
+		max: count,
+		value: draft,
+		onChange: (e) => setDraft(e.target.value),
+		onKeyDown,
+		...rest
+	});
+}
+//#endregion
+//#region src/components/InkPageCount.tsx
+function InkPageCount({ className, ...rest }) {
+	const { count } = usePage();
+	return /* @__PURE__ */ jsx("span", {
+		className: cx("ink-page-count", className),
+		"data-ink-page-count": "",
+		"aria-live": "polite",
+		...rest,
+		children: `of ${count}`
+	});
+}
+//#endregion
+//#region src/components/InkPrevPage.tsx
+function InkPrevPage({ asChild = false, className, children, disabled, onClick, ...rest }) {
+	const { current, previous } = usePage();
+	return /* @__PURE__ */ jsx(Toolbar.Button, {
+		asChild,
+		className: cx("ink-prev-page", className),
+		"data-ink-prev-page": "",
+		"aria-label": "Previous page",
+		title: "Previous page",
+		disabled: disabled === true || current <= 0,
+		...rest,
+		onClick: (e) => {
+			onClick?.(e);
+			if (!e.defaultPrevented) previous();
+		},
+		children: children ?? /* @__PURE__ */ jsx(InkIcon, { icon: ChevronLeft })
+	});
+}
+//#endregion
+//#region src/components/InkNextPage.tsx
+function InkNextPage({ asChild = false, className, children, disabled, onClick, ...rest }) {
+	const { current, count, next } = usePage();
+	return /* @__PURE__ */ jsx(Toolbar.Button, {
+		asChild,
+		className: cx("ink-next-page", className),
+		"data-ink-next-page": "",
+		"aria-label": "Next page",
+		title: "Next page",
+		disabled: disabled === true || current >= count - 1,
+		...rest,
+		onClick: (e) => {
+			onClick?.(e);
+			if (!e.defaultPrevented) next();
+		},
+		children: children ?? /* @__PURE__ */ jsx(InkIcon, { icon: ChevronRight })
+	});
+}
+//#endregion
+//#region src/components/annotation-element.ts
+/**
+* The overlay element core draws for an annotation, for anchoring a popover to it. Core
+* creates and removes these elements outside React, so this follows the root's subtree while
+* an id is wanted.
+*/
+function useAnnotationElement(root, id) {
+	const [element, setElement] = useState(null);
+	useEffect(() => {
+		if (!root || !id) {
+			setElement(null);
+			return;
+		}
+		return observeAnnotationElement(root, id, setElement);
+	}, [root, id]);
+	return element;
+}
+//#endregion
+//#region src/components/popover-focus.ts
+/** Radix's `onInteractOutside` handler: a press that will activate an annotation keeps the popover open. */
+function keepOpenOnAnnotation(event) {
+	if (shouldKeepOpenOnAnnotation(event.detail.originalEvent.target)) event.preventDefault();
+}
+function useFocusReturn(ctx) {
+	const latest = useLatest(ctx);
+	return useMemo(() => createFocusReturn({
+		root: () => latest.current.rootEl,
+		activated: () => latest.current.activated
+	}), [latest]);
+}
+//#endregion
+//#region src/components/InkNotePopover.tsx
+function InkNotePopover({ children }) {
+	const ctx = useInkContext("InkNotePopover");
+	const { annotations, add, update, remove } = useAnnotations();
+	const note = useMemo(() => {
+		const a = ctx.activated ? annotations.find((x) => x.id === ctx.activated) : void 0;
+		return a?.type === "note" ? threadRoot(annotations, a) : null;
+	}, [annotations, ctx.activated]);
+	const anchor = useAnnotationElement(ctx.rootEl, note?.id ?? null);
+	const anchorRef = useMemo(() => ({ current: anchor }), [anchor]);
+	const focusReturn = useFocusReturn(ctx);
+	const open = note !== null && anchor !== null;
+	/** The root, then every reply below it, depth first, each level in creation order. */
+	const thread = useMemo(() => note ? threadOf(annotations, note) : [], [annotations, note]);
+	/** True while the default form writes the root note's own text rather than a reply. */
+	const editingRoot = note !== null && !note.locked && !note.contents?.trim();
+	/**
+	* Notes this popover wrote text or a reply for. In controlled mode the write is a proposal
+	* the host may not have applied yet, so the applied list still shows the note empty; these
+	* are never dropped as abandoned.
+	*/
+	const written = useRef(/* @__PURE__ */ new Set());
+	/** Notes this popover has already asked to remove, so a slow host is asked once. */
+	const dropped = useRef(/* @__PURE__ */ new Set());
+	const latest = useLatest({
+		annotations,
+		remove
+	});
+	function dropIfEmpty(id) {
+		if (dropped.current.has(id) || written.current.has(id) || !isAbandonedNote(latest.current.annotations, id)) return false;
+		dropped.current.add(id);
+		latest.current.remove(id);
+		return true;
+	}
+	const noteId = note?.id;
+	const previousId = useRef(void 0);
+	useEffect(() => {
+		const previous = previousId.current;
+		if (previous === noteId) return;
+		previousId.current = noteId;
+		if (previous !== void 0) dropIfEmpty(previous);
+	}, [noteId]);
+	function reply(text) {
+		const root = note;
+		const contents = text.trim();
+		if (!root || !contents) return;
+		written.current.add(root.id);
+		add({
+			type: "note",
+			page: root.page,
+			rect: root.rect,
+			contents,
+			inReplyTo: root.id
+		});
+	}
+	function isEmptyRoot(root) {
+		return !written.current.has(root.id) && !root.locked && !root.contents?.trim() && thread.length === 1;
+	}
+	function close() {
+		const root = note;
+		if (root && annotations.some((a) => a.id === root.id) && isEmptyRoot(root)) {
+			focusReturn.beforeRemove(anchor);
+			dropIfEmpty(root.id);
+		}
+		ctx.setActivated(null);
+	}
+	function updateContents(contents) {
+		if (!note || note.locked) return;
+		if (contents.trim()) written.current.add(note.id);
+		update(note.id, { contents });
+	}
+	/** Locked notes cannot be removed: removing one does nothing and keeps the popover. */
+	function removeThread() {
+		const root = note;
+		if (!root || root.locked) return;
+		focusReturn.beforeRemove(anchor);
+		dropped.current.add(root.id);
+		remove(root.id);
+		ctx.setActivated(null);
+	}
+	return /* @__PURE__ */ jsxs(Popover.Root, {
+		open,
+		onOpenChange: (next) => !next && close(),
+		children: [/* @__PURE__ */ jsx(Popover.Anchor, { virtualRef: anchorRef }), /* @__PURE__ */ jsx(Popover.Portal, { children: note && anchor ? /* @__PURE__ */ jsx(Popover.Content, {
+			className: "ink-note-popover",
+			"data-ink-note-popover": "",
+			side: "right",
+			sideOffset: 8,
+			collisionPadding: 8,
+			"aria-label": "Note thread",
+			onInteractOutside: keepOpenOnAnnotation,
+			onCloseAutoFocus: (e) => focusReturn.onCloseAutoFocus(e, anchor),
+			children: children ? children({
+				note,
+				replies: thread.slice(1),
+				reply,
+				update: updateContents,
+				remove: removeThread,
+				close
+			}) : /* @__PURE__ */ jsxs(Fragment, { children: [!editingRoot || thread.length > 1 ? /* @__PURE__ */ jsx("ol", {
+				className: "ink-thread",
+				"data-ink-thread": "",
+				children: thread.map((item) => /* @__PURE__ */ jsxs("li", {
+					className: "ink-thread-item",
+					"data-ink-thread-item": "",
+					"data-reply": item.inReplyTo ? "" : void 0,
+					children: [
+						/* @__PURE__ */ jsx("span", {
+							className: "ink-thread-author",
+							children: item.author ?? "Anonymous"
+						}),
+						/* @__PURE__ */ jsx("time", {
+							className: "ink-thread-time",
+							dateTime: item.createdAt,
+							children: new Date(item.createdAt).toLocaleString()
+						}),
+						/* @__PURE__ */ jsx("p", {
+							className: "ink-thread-text",
+							children: item.contents
+						})
+					]
+				}, item.id))
+			}) : null, /* @__PURE__ */ jsx(ThreadForm, {
+				editingRoot,
+				locked: !!note.locked,
+				onSubmit: (text) => editingRoot ? updateContents(text) : reply(text),
+				onRemove: removeThread,
+				onClose: close
+			}, note.id)] })
+		}) : null })]
+	});
+}
+/** The default form: the root note's own text while it is empty, replies after that. */
+function ThreadForm({ editingRoot, locked, onSubmit, onRemove, onClose }) {
+	const [draft, setDraft] = useState("");
+	function submit(e) {
+		e.preventDefault();
+		const text = draft.trim();
+		if (!text) return;
+		onSubmit(text);
+		setDraft("");
+	}
+	return /* @__PURE__ */ jsxs("form", {
+		className: "ink-thread-reply",
+		"data-ink-thread-reply": "",
+		onSubmit: submit,
+		children: [/* @__PURE__ */ jsx("textarea", {
+			"aria-label": editingRoot ? "Comment" : "Reply",
+			rows: 2,
+			placeholder: editingRoot ? "Comment" : "Reply",
+			value: draft,
+			onChange: (e) => setDraft(e.target.value)
+		}), /* @__PURE__ */ jsxs("div", {
+			className: "ink-thread-actions",
+			children: [
+				/* @__PURE__ */ jsx("button", {
+					type: "submit",
+					disabled: !draft.trim(),
+					children: editingRoot ? "Comment" : "Reply"
+				}),
+				!locked ? /* @__PURE__ */ jsx("button", {
+					type: "button",
+					onClick: onRemove,
+					children: "Delete"
+				}) : null,
+				/* @__PURE__ */ jsx("button", {
+					type: "button",
+					onClick: onClose,
+					children: "Close"
+				})
+			]
+		})]
+	});
+}
+//#endregion
+//#region src/components/InkSuggestionCard.tsx
+function InkSuggestionCard({ children }) {
+	const ctx = useInkContext("InkSuggestionCard");
+	const { annotations, selection, accept: acceptId, dismiss: dismissId, select } = useAnnotations();
+	function suggestion(id) {
+		const a = id ? annotations.find((x) => x.id === id) : void 0;
+		return a?.type === "redact" && a.origin === "suggested" ? a : null;
+	}
+	const target = suggestion(ctx.activated) ?? (selection.length === 1 ? suggestion(selection[0]) : null);
+	const anchor = useAnnotationElement(ctx.rootEl, target?.id ?? null);
+	const anchorRef = useMemo(() => ({ current: anchor }), [anchor]);
+	const focusReturn = useFocusReturn(ctx);
+	const open = target !== null && anchor !== null;
+	const bucket = target?.suggestion ? confidenceBucket(target.suggestion.confidence) : void 0;
+	function close() {
+		ctx.setActivated(null);
+		select([]);
+	}
+	function accept() {
+		if (target) acceptId(target.id);
+		close();
+	}
+	/** Locked annotations cannot be removed: dismissing one does nothing and keeps the card. */
+	function dismiss() {
+		if (!target || target.locked) return;
+		focusReturn.beforeRemove(anchor, "[data-origin=\"suggested\"]");
+		dismissId(target.id);
+		close();
+	}
+	return /* @__PURE__ */ jsxs(Popover.Root, {
+		open,
+		onOpenChange: (next) => !next && close(),
+		children: [/* @__PURE__ */ jsx(Popover.Anchor, { virtualRef: anchorRef }), /* @__PURE__ */ jsx(Popover.Portal, { children: target && anchor ? /* @__PURE__ */ jsx(Popover.Content, {
+			className: "ink-suggestion-card",
+			"data-ink-suggestion-card": "",
+			side: "bottom",
+			sideOffset: 6,
+			collisionPadding: 8,
+			"aria-label": "Suggested redaction",
+			onInteractOutside: keepOpenOnAnnotation,
+			onCloseAutoFocus: (e) => focusReturn.onCloseAutoFocus(e, anchor),
+			children: children ? children({
+				annotation: target,
+				suggestion: target.suggestion,
+				bucket,
+				accept,
+				dismiss,
+				close
+			}) : /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsxs("p", {
+					className: "ink-suggestion-reason",
+					children: [/* @__PURE__ */ jsx("strong", { children: target.suggestion?.reason ?? "Suggested redaction" }), bucket ? /* @__PURE__ */ jsxs("span", {
+						className: "ink-suggestion-confidence",
+						"data-confidence": bucket,
+						children: [bucket, " confidence"]
+					}) : null]
+				}),
+				target.suggestion?.explanation ? /* @__PURE__ */ jsx("p", {
+					className: "ink-suggestion-explanation",
+					children: target.suggestion.explanation
+				}) : null,
+				/* @__PURE__ */ jsxs("div", {
+					className: "ink-suggestion-actions",
+					children: [/* @__PURE__ */ jsx("button", {
+						type: "button",
+						onClick: accept,
+						children: "Accept"
+					}), !target.locked ? /* @__PURE__ */ jsx("button", {
+						type: "button",
+						onClick: dismiss,
+						children: "Dismiss"
+					}) : null]
+				})
+			] })
+		}) : null })]
+	});
+}
+//#endregion
+export { InkAnnotation, InkIcon, InkNextPage, InkNotePopover, InkPage, InkPageCount, InkPageInput, InkPrevPage, InkRedo, InkRoot, InkSuggestionCard, InkToolButton, InkToolbar, InkToolbarSeparator, InkUndo, InkViewport, InkZoomIn, InkZoomOut, InkZoomSelect, useAnnotations, useDocument, useEmbedded, useHistory, useInkContext, usePage, useReadable, useSelection, useTool, useZoom };
+
+//# sourceMappingURL=index.mjs.map