@inkbar/core 0.5.0 → 0.6.0

package/dist/dom.mjs

@@ -1,4 +1,4 @@
-import { $t as readonly, B as isTextMarkup, Bt as withCalloutBounds, E as withoutReplies, G as resizedRect, Gt as isKnown, H as movedEndpoint, Ht as LINE_ENDINGS, I as hasCallout, J as withBox, Jt as cssVariableDefaults, K as scaled, L as hasCornerHandles, Lt as calloutStroke, O as createToolStyle, R as hasRectGeometry, Rt as freeTextBox, S as isThreadRoot, T as threadRoot, U as movedTip, V as keepsAspect, W as resizedBox, Y as openDocument, Z as deriveRect, Zt as mergeLineRects, _ as defaultEnds, _n as isInkError, b as isAbandonedNote, d as recogniseStroke, dn as rectsIntersect, en as writable, f as DEFAULT_CORNER_RADIUS, g as constrain, gn as InkError, h as SHAPE_KINDS, i as createInkTemplate, l as placeSignature, ln as rectFromPoints, m as DEFAULT_SHAPE_SIZE, o as createMemorySignatureStore, p as DEFAULT_SHAPE_OPTIONS, q as translated, r as createImageTemplate, rn as invertMatrix, s as createSignatureLibrary, tn as applyMatrix, tt as isProduction, v as isPointerOnlyKind, w as threadOf, y as shapeInput, z as isBubble, zt as isStandardCallout } from "./signatures-CMapTKrC.mjs";
+import { $t as derived, B as isTextMarkup, Bt as withCalloutBounds, E as withoutReplies, G as resizedRect, Gt as isKnown, H as movedEndpoint, Ht as LINE_ENDINGS, I as hasCallout, J as withBox, Jt as cssVariableDefaults, K as scaled, L as hasCornerHandles, Lt as calloutStroke, O as createToolStyle, Qt as createRecordStore, R as hasRectGeometry, Rt as freeTextBox, S as isThreadRoot, T as threadRoot, U as movedTip, V as keepsAspect, W as resizedBox, Y as openDocument, Z as deriveRect, Zt as mergeLineRects, _ as defaultEnds, b as isAbandonedNote, bn as isInkError, d as recogniseStroke, dn as rectFromPoints, en as readonly, f as DEFAULT_CORNER_RADIUS, g as constrain, h as SHAPE_KINDS, i as createInkTemplate, in as invertMatrix, l as placeSignature, m as DEFAULT_SHAPE_SIZE, mn as rectsIntersect, nn as applyMatrix, o as createMemorySignatureStore, p as DEFAULT_SHAPE_OPTIONS, q as translated, r as createImageTemplate, s as createSignatureLibrary, tn as writable, tt as isProduction, v as isPointerOnlyKind, w as threadOf, y as shapeInput, yn as InkError, z as isBubble, zt as isStandardCallout } from "./signatures-D68fuLlt.mjs";
 import { ALargeSmall, AlignCenter, AlignJustify, AlignLeft, AlignRight, Bold, Check, ChevronDown, ChevronLeft, ChevronRight, Circle, CircleDashed, Hexagon, Highlighter, ICON_ATTRIBUTES, Italic, MessageCircle, MessageSquare, MessageSquareText, Minus, MoveUpRight, PenLine, PenTool, Plus, RectangleHorizontal, Redo2, Search, Signature, Slash, SpellCheck2, Square, SquareDashed, SquareDashedMousePointer, Star, Strikethrough, TextCursor, Trash2, Type, Underline, Undo2, ZoomIn, ZoomOut } from "@inkbar/icons";
 import { getStroke } from "perfect-freehand";
 //#region src/dom/transform.ts
@@ -500,7 +500,7 @@ function createViewport(opts) {
 			});
 			sync();
 		},
-		scrollToRect(page, rect) {
+		scrollToRect(page, rect, o) {
 			if (mode.get() === "single" && currentPage.get() !== page) {
 				currentPage.set(page);
 				relayout();
@@ -508,11 +508,13 @@ function createViewport(opts) {
 			const box = boxFor(page);
 			if (!box) return;
 			const css = transformFor(page).toCssRect(rect);
-			const o = origin();
-			const top = o.y + box.top + css.top;
-			if (top < container.scrollTop || top + css.height > container.scrollTop + container.clientHeight) container.scrollTop = Math.max(0, top - (container.clientHeight - css.height) / 2);
-			const left = o.x + box.left + css.left;
-			if (left < container.scrollLeft || left + css.width > container.scrollLeft + container.clientWidth) container.scrollLeft = Math.max(0, left - (container.clientWidth - css.width) / 2);
+			const at = origin();
+			const to = { behavior: o?.behavior ?? "auto" };
+			const top = at.y + box.top + css.top;
+			if (top < container.scrollTop || top + css.height > container.scrollTop + container.clientHeight) to.top = Math.max(0, top - (container.clientHeight - css.height) / 2);
+			const left = at.x + box.left + css.left;
+			if (left < container.scrollLeft || left + css.width > container.scrollLeft + container.clientWidth) to.left = Math.max(0, left - (container.clientWidth - css.width) / 2);
+			if (to.top !== void 0 || to.left !== void 0) container.scrollTo(to);
 			sync();
 		},
 		transformFor,
@@ -629,7 +631,7 @@ function watchDevicePixelRatio(view, current, onChange) {
 }
 //#endregion
 //#region src/dom/page-renderer.ts
-const isCancellation$1 = (error) => error?.name === "RenderingCancelledException";
+const isCancellation$2 = (error) => error?.name === "RenderingCancelledException";
 function createPageRenderer(opts) {
 	const { document: doc, page, host } = opts;
 	const view = host.ownerDocument.defaultView;
@@ -715,7 +717,7 @@ function createPageRenderer(opts) {
 			opts.onRendered?.();
 		} catch (error) {
 			if (canvas && canvas !== current) release(canvas);
-			if (!((destroyed || gen !== generation) && isCancellation$1(error)) && !destroyed) opts.onError?.(error);
+			if (!((destroyed || gen !== generation) && isCancellation$2(error)) && !destroyed) opts.onError?.(error);
 		} finally {
 			if (gen === generation) settle();
 		}
@@ -2018,7 +2020,7 @@ function insertText(field, text) {
 }
 //#endregion
 //#region src/pdfjs/render-region.ts
-const isCancellation = (error) => error?.name === "RenderingCancelledException";
+const isCancellation$1 = (error) => error?.name === "RenderingCancelledException";
 /**
 * Draws `userRect` of `page` (0-based) into `canvas` at `scale` device pixels per user-space
 * unit (times `/UserUnit`, as PDF.js applies it), turned by `rotation`: the page's /Rotate plus
@@ -2061,7 +2063,7 @@ async function renderRegion(doc, page, userRect, scale, canvas, signal, rotation
 	try {
 		await task.promise;
 	} catch (error) {
-		if (signal?.aborted && isCancellation(error)) throw signal.reason;
+		if (signal?.aborted && isCancellation$1(error)) throw signal.reason;
 		throw error;
 	} finally {
 		signal?.removeEventListener("abort", cancel);
@@ -2310,7 +2312,7 @@ function ariaLabel(a) {
 	return a.author ? `${named} by ${a.author}` : named;
 }
 /** Reading order in user space: top edge first (y grows upwards), then left edge. */
-function readingOrder(a, b) {
+function readingOrder$1(a, b) {
 	return b.rect.y + b.rect.height - (a.rect.y + a.rect.height) || a.rect.x - b.rect.x;
 }
 /** A decoration's data key: lower-case kebab, as written after `data-`. */
@@ -2727,7 +2729,7 @@ function createOverlay(opts) {
 	}
 	function render() {
 		if (destroyed) return;
-		const current = withoutReplies(store.list.get()).filter((a) => a.page === page).sort(readingOrder);
+		const current = withoutReplies(store.list.get()).filter((a) => a.page === page).sort(readingOrder$1);
 		const ids = new Set(current.map((a) => a.id));
 		const active = doc.activeElement;
 		let focusId = [...elements].find(([, n]) => n === active)?.[0];
@@ -2818,8 +2820,1218 @@ function createOverlay(opts) {
 	};
 }
 //#endregion
+//#region src/dom/plugins/api/command.ts
+const DEFAULT_ERROR_STATUS = "Something went wrong.";
+/** A failure that is the run being cancelled, not a bug: not logged, no error status. */
+function isCancellation(error) {
+	if (isInkError(error) && error.code === "DocumentDestroyed") return true;
+	return error instanceof Error && error.name === "AbortError";
+}
+function createCommand(ctx, id, label, run, opts = {}) {
+	const status = writable("");
+	let controller = null;
+	ctx.onDocument(() => () => {
+		controller?.abort();
+		status.set("");
+	});
+	return ctx.commands.add({
+		id,
+		label,
+		...opts.icon && { icon: opts.icon },
+		...opts.enabled && { enabled: opts.enabled },
+		status: readonly(status),
+		async run() {
+			const doc = ctx.document.get();
+			if (!doc) return;
+			const own = new AbortController();
+			controller = own;
+			status.set("");
+			try {
+				const result = await run({
+					doc,
+					signal: own.signal
+				});
+				if (!own.signal.aborted) status.set(result ?? "");
+			} catch (error) {
+				if (own.signal.aborted || isCancellation(error)) return;
+				console.error(error);
+				status.set(opts.errorStatus ?? DEFAULT_ERROR_STATUS);
+			} finally {
+				if (controller === own) controller = null;
+			}
+		}
+	});
+}
+//#endregion
+//#region src/dom/annotation-element.ts
+/** The overlay element drawn for annotation `id` under `root`, if it is in the DOM. */
+function annotationElementFor(root, id) {
+	return root.querySelector(`[data-annotation="${CSS.escape(id)}"]`);
+}
+/**
+* Resolves the overlay element for `id` and keeps resolving while `root`'s subtree changes:
+* the overlay creates and removes these elements outside any framework (a page mounts as it
+* scrolls into view), so a popover anchored to one has to follow. Calls `onChange` once now
+* and again whenever the answer changes. The returned function stops observing.
+*/
+function observeAnnotationElement(root, id, onChange) {
+	let last;
+	const resolve = () => {
+		const found = annotationElementFor(root, id);
+		if (found === last) return;
+		last = found;
+		onChange(found);
+	};
+	resolve();
+	const observer = new MutationObserver(resolve);
+	observer.observe(root, {
+		childList: true,
+		subtree: true
+	});
+	return () => observer.disconnect();
+}
+//#endregion
+//#region src/dom/popover-focus.ts
+/**
+* A press that will activate an annotation is not a dismissal: the popover follows the
+* activation. Mirrors the overlay's rule: a press on the annotation element or on its drawn
+* shape activates; a press on a custom element's own content belongs to that content.
+*/
+function shouldKeepOpenOnAnnotation(target) {
+	if (!(target instanceof Element)) return false;
+	const annotation = target.closest("[data-annotation]");
+	if (!annotation) return false;
+	return target === annotation || !annotation.hasAttribute("data-custom");
+}
+function createFocusReturn(opts) {
+	let fallbacks = [];
+	/** Set by `beforeRemove`: the close comes from removing the anchor's annotation. */
+	let removing = false;
+	return {
+		beforeRemove(anchor, prefer) {
+			fallbacks = [];
+			removing = true;
+			const siblings = anchor?.parentElement ? [...anchor.parentElement.children].filter((el) => el instanceof HTMLElement && el.hasAttribute("data-annotation")) : [];
+			const i = anchor ? siblings.indexOf(anchor) : -1;
+			if (i >= 0) {
+				const after = siblings.slice(i + 1);
+				const preferred = prefer ? after.filter((el) => el.matches(prefer)) : [];
+				fallbacks.push(...preferred, ...after, ...siblings.slice(0, i).reverse());
+			}
+		},
+		onCloseAutoFocus(event, anchor) {
+			event.preventDefault();
+			const plan = fallbacks;
+			const removed = removing;
+			fallbacks = [];
+			removing = false;
+			const root = opts.root();
+			if (!root) return;
+			const activated = opts.activated();
+			if (activated !== null && annotationElementFor(root, activated)) return;
+			const active = root.ownerDocument.activeElement;
+			if (active && active !== root && root.contains(active)) return;
+			const scroll = root.querySelector("[data-ink-scroll]");
+			(removed ? [...plan, scroll] : [
+				anchor,
+				...plan,
+				scroll
+			]).find((el) => el?.isConnected)?.focus({ preventScroll: true });
+		}
+	};
+}
+//#endregion
+//#region src/dom/viewer/dom.ts
+/** `document.createElement` with attributes and children. */
+function h(tag, attrs = {}, ...children) {
+	const el = document.createElement(tag);
+	for (const [name, value] of Object.entries(attrs)) el.setAttribute(name, value);
+	el.append(...children);
+	return el;
+}
+function button$1(label, onClick) {
+	const b = h("button", { type: "button" }, label);
+	b.addEventListener("click", onClick);
+	return b;
+}
+//#endregion
+//#region src/dom/viewer/popover.ts
+/** Space between the anchor and the panel, and between the panel and the window edge. */
+const GAP = 6;
+const MARGIN = 8;
+const TABBABLE$1 = "button, input, select, textarea, a[href], [tabindex]";
+/**
+* Positions `panel` (fixed) below the `anchor` rectangle, or above it when only that fits,
+* kept inside the window. For panels anchored to something other than an annotation.
+*/
+function placePanel(panel, anchor) {
+	const { innerWidth: vw, innerHeight: vh } = window;
+	panel.style.position = "fixed";
+	panel.style.left = "0px";
+	panel.style.top = "0px";
+	const w = panel.offsetWidth;
+	const ht = panel.offsetHeight;
+	let top = anchor.bottom + GAP;
+	if (top + ht > vh - MARGIN && anchor.top - GAP - ht >= MARGIN) top = anchor.top - GAP - ht;
+	top = Math.max(MARGIN, Math.min(top, vh - ht - MARGIN));
+	const left = Math.max(MARGIN, Math.min(anchor.left, vw - w - MARGIN));
+	panel.style.left = `${left}px`;
+	panel.style.top = `${top}px`;
+}
+/**
+* Calls `onChange` with `el` while it is under `root` and null while it is not: once now, then
+* whenever that changes. Returns a function that stops observing.
+*/
+function observeElement(root, el, onChange) {
+	let last;
+	const resolve = () => {
+		const found = root.contains(el) ? el : null;
+		if (found === last) return;
+		last = found;
+		onChange(found);
+	};
+	resolve();
+	const observer = new MutationObserver(resolve);
+	observer.observe(root, {
+		childList: true,
+		subtree: true
+	});
+	return () => observer.disconnect();
+}
+/**
+* Creates a non-modal `role="dialog"` panel on `<body>`, marked `data-ink-popover` so the theme
+* gives it its tokens, that an app anchors to an annotation with `show(id)` (for instance on
+* `viewer.activated`), or to any element in the viewer with `showAt(el)`. The panel follows the annotation's element as pages mount and unmount:
+* it hides while the element is gone and comes back with it. Tab loops inside the panel, and
+* Escape or a press outside calls `onDismiss`. Call `destroy` when done.
+*/
+function createPopover(opts) {
+	const { root, focusReturn } = opts;
+	const panel = h("div", {
+		...opts.attrs,
+		role: "dialog",
+		"data-ink-popover": "",
+		hidden: ""
+	});
+	document.body.append(panel);
+	/** What the panel is anchored to: an annotation id, or an element from `showAt`. */
+	let anchored = null;
+	let anchor = null;
+	let stopObserving = () => void 0;
+	/** The element that had focus in the panel when the anchor went away. */
+	let stranded = null;
+	const place = () => {
+		if (!anchor || panel.hidden) return;
+		placePanel(panel, anchor.getBoundingClientRect());
+	};
+	const resizes = new ResizeObserver(place);
+	resizes.observe(panel);
+	const onAnchor = (el, closing = false) => {
+		if (anchor) resizes.unobserve(anchor);
+		anchor = el;
+		if (!el) {
+			const active = document.activeElement;
+			if (!closing && !panel.hidden && active instanceof HTMLElement && panel.contains(active)) {
+				const scroll = root.querySelector("[data-ink-scroll]");
+				if (scroll) {
+					stranded = active;
+					scroll.focus({ preventScroll: true });
+				}
+			}
+			panel.hidden = true;
+			return;
+		}
+		resizes.observe(el);
+		const wasHidden = panel.hidden;
+		panel.hidden = false;
+		place();
+		if (wasHidden && stranded) {
+			const back = stranded;
+			stranded = null;
+			const scroll = root.querySelector("[data-ink-scroll]");
+			if (panel.contains(back) && document.activeElement === scroll) back.focus({ preventScroll: true });
+		}
+	};
+	const onKey = (e) => {
+		if (e.key !== "Escape" || panel.hidden || e.defaultPrevented) return;
+		const target = e.target;
+		if (!(target instanceof Node) || !(panel.contains(target) || root.contains(target))) return;
+		e.preventDefault();
+		opts.onDismiss();
+	};
+	const onPress = (e) => {
+		if (panel.hidden || panel.contains(e.target)) return;
+		if (shouldKeepOpenOnAnnotation(e.target)) return;
+		opts.onDismiss();
+	};
+	const onTab = (e) => {
+		if (e.key !== "Tab" || e.altKey || e.ctrlKey || e.metaKey) return;
+		const tabbable = [...panel.querySelectorAll(TABBABLE$1)].filter((el) => !el.disabled && el.tabIndex >= 0);
+		const first = tabbable[0];
+		const last = tabbable.at(-1);
+		if (!first || !last) return;
+		const active = document.activeElement;
+		if (e.shiftKey ? active !== first : active !== last) return;
+		e.preventDefault();
+		(e.shiftKey ? last : first).focus();
+	};
+	panel.addEventListener("keydown", onTab);
+	document.addEventListener("keydown", onKey);
+	document.addEventListener("pointerdown", onPress, true);
+	document.addEventListener("scroll", place, true);
+	window.addEventListener("resize", place);
+	return {
+		panel,
+		get anchor() {
+			return anchor;
+		},
+		show(id) {
+			if (id === anchored) return;
+			stopObserving();
+			anchored = id;
+			stopObserving = observeAnnotationElement(root, id, onAnchor);
+		},
+		showAt(el) {
+			if (el === anchored) return;
+			stopObserving();
+			anchored = el;
+			stopObserving = observeElement(root, el, onAnchor);
+		},
+		hide() {
+			if (anchored === null) return;
+			stopObserving();
+			stopObserving = () => void 0;
+			const element = typeof anchored === "string" ? null : anchored;
+			anchored = null;
+			const back = anchor;
+			stranded = null;
+			onAnchor(null, true);
+			queueMicrotask(() => {
+				if (anchored !== null || !panel.isConnected) return;
+				if (element?.isConnected) {
+					const active = document.activeElement;
+					if (!(active && active !== root && root.contains(active))) element.focus({ preventScroll: true });
+					return;
+				}
+				focusReturn.onCloseAutoFocus(new Event("closeautofocus", { cancelable: true }), back);
+			});
+		},
+		destroy() {
+			stopObserving();
+			resizes.disconnect();
+			document.removeEventListener("keydown", onKey);
+			document.removeEventListener("pointerdown", onPress, true);
+			panel.removeEventListener("keydown", onTab);
+			document.removeEventListener("scroll", place, true);
+			window.removeEventListener("resize", place);
+			panel.remove();
+		}
+	};
+}
+//#endregion
+//#region src/dom/plugins/api/card.ts
+function el(tag, className, ...children) {
+	const e = document.createElement(tag);
+	e.className = className;
+	e.append(...children);
+	return e;
+}
+function createCard(ctx, records, opts) {
+	/** Made on first open, in the viewer root the mark is in. */
+	let popover = null;
+	let root = null;
+	/** The record on show. */
+	let shown = null;
+	/** Set while an action runs: the action decides what happens after it. */
+	let acting = false;
+	/** The mark whose card is open: its `aria-expanded` is true. */
+	let expanded = null;
+	const expand = (mark) => {
+		expanded?.setAttribute("aria-expanded", "false");
+		expanded = mark;
+		mark?.setAttribute("aria-expanded", "true");
+	};
+	/** The shown record as it stands now, while it still has a mark. */
+	const current = () => {
+		const record = shown === null ? void 0 : records.find(shown);
+		return record && opts.marked(record) ? record : void 0;
+	};
+	const close = () => {
+		shown = null;
+		expand(null);
+		popover?.hide();
+	};
+	/** Runs `fn` as one undo step, then re-renders, or closes and moves focus on. */
+	const act = (fn) => {
+		if (!popover || !root || shown === null) return;
+		const marks = opts.marks(root);
+		const i = popover.anchor ? marks.indexOf(popover.anchor) : -1;
+		const after = i < 0 ? [] : [...marks.slice(i + 1), ...marks.slice(0, i).reverse()];
+		acting = true;
+		try {
+			ctx.history.batch(fn);
+		} finally {
+			acting = false;
+		}
+		const record = current();
+		if (record) return render(record);
+		after.find((m) => m.isConnected)?.focus({ preventScroll: true });
+		close();
+	};
+	/** Fills the panel from `record`, keeping focus on the same action. */
+	const render = (record) => {
+		const spec = opts.spec(record);
+		const panel = popover.panel;
+		const buttons = () => [...panel.querySelectorAll(".ink-card-actions > button")];
+		const focused = buttons().indexOf(document.activeElement);
+		panel.className = spec.className ? `ink-card ${spec.className}` : "ink-card";
+		panel.setAttribute("aria-label", spec.label ?? spec.title);
+		const parts = [el("p", "ink-card-title", spec.title)];
+		if (spec.meta !== void 0) {
+			const meta = el("p", "ink-card-meta", spec.meta);
+			if (spec.swatch !== void 0) {
+				const swatch = el("span", "ink-card-swatch");
+				swatch.style.background = spec.swatch;
+				meta.prepend(swatch);
+			}
+			parts.push(meta);
+		}
+		if (spec.body !== void 0) parts.push(el("p", "ink-card-body", spec.body));
+		const actions = el("div", "ink-card-actions");
+		for (const [label, fn] of Object.entries(spec.actions)) {
+			const button = el("button", "", label);
+			button.type = "button";
+			button.addEventListener("click", () => act(fn));
+			actions.append(button);
+		}
+		parts.push(actions);
+		panel.replaceChildren(...parts);
+		if (focused >= 0) {
+			const now = buttons();
+			(now[focused] ?? now[0])?.focus({ preventScroll: true });
+		}
+	};
+	ctx.onDocument(() => {
+		const stop = records.list.subscribe(() => {
+			if (acting || shown === null) return;
+			const record = current();
+			if (record) render(record);
+			else close();
+		});
+		return () => {
+			stop();
+			shown = null;
+			expand(null);
+			popover?.destroy();
+			popover = null;
+			root = null;
+		};
+	});
+	return {
+		open(record, mark) {
+			const viewer = mark.closest("[data-ink-root]");
+			if (!viewer) return;
+			if (viewer !== root) {
+				popover?.destroy();
+				root = viewer;
+				popover = createPopover({
+					root: viewer,
+					attrs: { class: "ink-card" },
+					focusReturn: createFocusReturn({
+						root: () => viewer,
+						activated: () => null
+					}),
+					onDismiss: close
+				});
+			}
+			shown = record.id;
+			render(record);
+			popover.showAt(mark);
+			expand(mark);
+			popover.panel.querySelector(".ink-card-actions > button")?.focus();
+		},
+		expanded: (mark) => mark === expanded
+	};
+}
+//#endregion
+//#region src/dom/plugins/api/marks.ts
+/** Events stopped on a mark, so the viewer's root never sees a press on it. */
+const STOPPED = [
+	"pointerdown",
+	"pointerup",
+	"mousedown",
+	"mouseup",
+	"click"
+];
+/** Attributes the plugin's `attrs` cannot set: core sets them, or they have options of their own. */
+const RESERVED = /* @__PURE__ */ new Set([
+	"style",
+	"class",
+	"type"
+]);
+function createMarks(ctx, records, opts) {
+	const applied = /* @__PURE__ */ new WeakMap();
+	const marked = (record) => opts.where?.(record) ?? true;
+	const spec = opts.card?.bind(opts);
+	const card = spec && createCard(ctx, records, {
+		spec,
+		marked,
+		marks: (root) => [...root.querySelectorAll(`.ink-plugin-layer[data-plugin="${ctx.id}"] > button`)].filter((mark) => applied.has(mark))
+	});
+	/** What activating a mark does. */
+	const activate = (record, mark) => {
+		card?.open(record, mark);
+		opts.onActivate?.(record, mark);
+	};
+	const create = (doc) => {
+		const mark = doc.createElement("button");
+		if (opts.className) mark.className = opts.className;
+		for (const type of STOPPED) mark.addEventListener(type, (e) => e.stopPropagation());
+		mark.addEventListener("click", () => {
+			const state = applied.get(mark);
+			if (state) activate(state.record, mark);
+		});
+		return mark;
+	};
+	/** Brings `mark` up to date with `record`, placed through `transform`. */
+	const apply = (mark, record, transform) => {
+		const prev = applied.get(mark);
+		const style = opts.style?.(record) ?? {};
+		const styleNames = Object.keys(style).map(toCssName);
+		const attrs = Object.fromEntries(Object.entries(opts.attrs?.(record) ?? {}).filter(([name]) => !RESERVED.has(name.toLowerCase())));
+		for (const name of prev?.style ?? []) if (!styleNames.includes(name)) mark.style.removeProperty(name);
+		for (const key of prev?.attrs ?? []) if (!(key in attrs)) mark.removeAttribute(key);
+		for (const [key, value] of Object.entries(style)) mark.style.setProperty(toCssName(key), value);
+		for (const [name, value] of Object.entries(attrs)) mark.setAttribute(name, value);
+		mark.type = "button";
+		mark.style.position = "absolute";
+		mark.dataset.record = record.id;
+		mark.dataset.plugin = ctx.id;
+		mark.setAttribute("aria-label", opts.label(record));
+		if (card) {
+			mark.setAttribute("aria-haspopup", "dialog");
+			mark.setAttribute("aria-expanded", String(card.expanded(mark)));
+		}
+		const r = transform.toCssRect(opts.rect(record));
+		mark.style.left = `${r.left}px`;
+		mark.style.top = `${r.top}px`;
+		mark.style.width = `${r.width}px`;
+		mark.style.height = `${r.height}px`;
+		applied.set(mark, {
+			record,
+			style: styleNames,
+			attrs: Object.keys(attrs)
+		});
+	};
+	/**
+	* Makes `el`'s marks match the page's records, in list order: marks that stay are moved,
+	* new ones inserted, the rest removed.
+	*/
+	const draw = (el, page, transform) => {
+		const list = records.list.get().filter((r) => r.page === page && marked(r));
+		const ids = new Set(list.map((r) => r.id));
+		const kept = /* @__PURE__ */ new Map();
+		for (const mark of [...el.children]) {
+			const id = mark.dataset.record;
+			if (id !== void 0 && ids.has(id) && !kept.has(id)) kept.set(id, mark);
+			else mark.remove();
+		}
+		let next = el.firstElementChild;
+		for (const record of list) {
+			const mark = kept.get(record.id) ?? create(el.ownerDocument);
+			apply(mark, record, transform);
+			if (mark === next) next = mark.nextElementSibling;
+			else el.insertBefore(mark, next);
+		}
+	};
+	let scrolling = false;
+	/** Ids that started to get a mark in the change under way, read once it settles. */
+	const fresh = /* @__PURE__ */ new Set();
+	/** Scrolls to the first fresh record still marked, so a batch of adds scrolls once. */
+	const reveal = () => {
+		const [first] = [...fresh].map((id) => records.find(id)).filter((r) => r !== void 0 && marked(r)).sort(readingOrder((r) => opts.rect(r)));
+		fresh.clear();
+		if (first) ctx.scrollTo(first.page, opts.rect(first), { behavior: reducedMotion() ? "instant" : "smooth" });
+	};
+	/** Notes a record that starts to get a mark; replaces (undo, redo, reset) never count. */
+	const watch = (change) => {
+		const record = change.kind === "add" ? change.record : change.kind === "update" && !marked(change.before) ? change.after : void 0;
+		if (!record || !marked(record)) return;
+		if (fresh.size === 0) queueMicrotask(reveal);
+		fresh.add(record.id);
+	};
+	const layer = ctx.layer({ render: draw });
+	ctx.onDocument(() => {
+		const stopDraw = records.list.subscribe(() => layer.invalidate());
+		const stopWatch = records.store()?.on("change", (change) => {
+			if (scrolling) watch(change);
+		});
+		return () => {
+			stopDraw();
+			stopWatch?.();
+			fresh.clear();
+		};
+	});
+	const handle = {
+		refresh: () => layer.invalidate(),
+		scrollToFirst() {
+			scrolling = true;
+			return handle;
+		}
+	};
+	return handle;
+}
+/** Page first, then top to bottom and left to right, by each record's rect in user space. */
+function readingOrder(rect) {
+	return (a, b) => {
+		const ra = rect(a);
+		const rb = rect(b);
+		return a.page - b.page || rb.y + rb.height - (ra.y + ra.height) || ra.x - rb.x;
+	};
+}
+function reducedMotion() {
+	return globalThis.matchMedia?.("(prefers-reduced-motion: reduce)").matches ?? false;
+}
+/** `borderColor` → `border-color`, as `setProperty` takes it; `--custom` names stay as given. */
+function toCssName(key) {
+	return key.startsWith("--") ? key : key.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+}
+//#endregion
+//#region src/dom/plugins/api/links.ts
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Links `type` annotations to records; registers one `onAnnotationEdit` listener. */
+function createLink(deps, type, spec) {
+	const linkOf = (a) => {
+		if (a.type !== type) return void 0;
+		const own = a.custom?.[deps.plugin];
+		const id = isObject(own) ? own[deps.name] : void 0;
+		return typeof id === "string" ? id : void 0;
+	};
+	deps.onAnnotationEdit((edit) => {
+		if (edit.kind === "add") return;
+		const annotation = edit.kind === "remove" ? edit.annotation : edit.after;
+		const id = linkOf(annotation);
+		const record = id === void 0 ? void 0 : deps.find(id);
+		if (!record) return;
+		if (edit.kind === "remove") spec.onRemoved?.(record, annotation);
+		else spec.onChanged?.(record, annotation);
+	});
+	return {
+		add(record) {
+			const doc = deps.document();
+			if (!doc) return void 0;
+			const { color, custom, ...fields } = spec.from(record);
+			const own = custom?.[deps.plugin];
+			return doc.annotations.add({
+				...fields,
+				type,
+				color: color ?? doc.annotations.defaults.color(type),
+				custom: {
+					...custom,
+					[deps.plugin]: {
+						...isObject(own) ? own : {},
+						[deps.name]: record.id
+					}
+				}
+			});
+		},
+		of(record) {
+			const doc = deps.document();
+			return doc ? doc.annotations.list.get().filter((a) => linkOf(a) === record.id) : [];
+		}
+	};
+}
+//#endregion
+//#region src/dom/plugins/api/records.ts
+const EMPTY$1 = Object.freeze([]);
+/** The list of whichever store `source` holds, `[]` for none; emits on swaps and changes. */
+function listOf(source) {
+	const read = (store) => store?.list.get() ?? EMPTY$1;
+	return {
+		get: () => read(source.get()),
+		subscribe(fn) {
+			let last = read(source.get());
+			let stopList;
+			const emit = (next) => {
+				if (Object.is(next, last) || next.length === 0 && last.length === 0) return;
+				last = next;
+				fn(next);
+			};
+			const follow = (store) => {
+				stopList?.();
+				stopList = store?.list.subscribe(emit);
+				emit(read(store));
+			};
+			follow(source.get());
+			const stopSource = source.subscribe(follow);
+			return () => {
+				stopSource();
+				stopList?.();
+			};
+		}
+	};
+}
+function matches(record, match) {
+	return Object.entries(match).every(([k, v]) => record[k] === v);
+}
+/**
+* Builds a handle over `source`, a plugin store from `ctx.store`. Every call reads the store
+* `source` holds then.
+*/
+function createRecords(deps, source, base = source) {
+	const current = () => source.get();
+	const all = () => current()?.list.get() ?? EMPTY$1;
+	return {
+		list: listOf(source),
+		all,
+		find: (id) => current()?.get(id),
+		has: (id) => current()?.get(id) !== void 0,
+		where: (match) => all().filter(typeof match === "function" ? match : (r) => matches(r, match)),
+		add: (record) => current()?.add(record),
+		addMissing(records) {
+			const store = current();
+			if (!store) return [];
+			const added = [];
+			deps.batch(() => {
+				for (const record of records) if (!store.get(record.id)) added.push(store.add(record));
+			});
+			return added;
+		},
+		update: (id, patch) => current()?.update(id, patch),
+		remove: (id) => current()?.remove(id),
+		in(doc) {
+			const captured = deps.storesDocument() === doc ? base.get() : null;
+			return createRecords(deps, derived(base, (store) => store && store === captured ? store : null), base);
+		},
+		store: current,
+		annotates: (type, spec) => createLink({
+			plugin: deps.plugin,
+			name: deps.name,
+			onAnnotationEdit: (fn) => deps.onAnnotationEdit(fn),
+			document: () => current() ? deps.storesDocument() : null,
+			find: (id) => current()?.get(id)
+		}, type, spec)
+	};
+}
+//#endregion
+//#region src/dom/plugins/api/api.ts
+function createPluginApi(ctx, options) {
+	let storesDocument = null;
+	ctx.onDocument((doc) => {
+		storesDocument = doc;
+		return () => {
+			storesDocument = null;
+		};
+	});
+	const batch = (fn) => ctx.history.batch(fn);
+	return {
+		...ctx,
+		records(name, opts) {
+			const source = ctx.store(name, opts ?? options.records?.[name]);
+			return createRecords({
+				batch,
+				storesDocument: () => storesDocument,
+				plugin: ctx.id,
+				name,
+				onAnnotationEdit: (fn) => ctx.onAnnotationEdit(fn)
+			}, source);
+		},
+		batch,
+		command: (id, label, run, opts) => createCommand(ctx, id, label, run, opts),
+		marks: (records, opts) => createMarks(ctx, records, opts)
+	};
+}
+//#endregion
+//#region src/dom/plugins/define.ts
+const PLUGIN_ID = /^[a-z][a-z0-9-]*$/;
+function checkId(id) {
+	if (!PLUGIN_ID.test(id)) throw new InkError("InvalidPluginId", `Plugin id ${JSON.stringify(id)} must be lower-case kebab`, { id });
+}
+function definePlugin(plugin, setup) {
+	if (typeof plugin !== "string") {
+		checkId(plugin.id);
+		return plugin;
+	}
+	const id = plugin;
+	checkId(id);
+	return (options = {}) => ({
+		id,
+		setup: (ctx) => setup?.(createPluginApi(ctx, options), options)
+	});
+}
+//#endregion
+//#region src/dom/plugins/commands.ts
+/**
+* The error for a command id no plugin registered, naming the ids that were. Bindings log it
+* rather than throw, and show the control as it is before the plugins are set up.
+*/
+function unknownCommand(id, registered) {
+	const known = registered.length > 0 ? registered.join(", ") : "none";
+	return new InkError("UnknownCommand", `No plugin registered a command ${id} (registered: ${known})`, {
+		id,
+		registered
+	});
+}
+const EMPTY = {
+	get: () => "",
+	subscribe: () => () => {}
+};
+/**
+* A boolean readable computed from `sources`. Like `derived`, it subscribes to the sources only
+* while it has subscribers of its own; `watch` re-reads them, so a source can be swapped while
+* subscribed (a document's status when the document changes).
+*/
+function computed(compute, watch) {
+	const subs = /* @__PURE__ */ new Set();
+	let cached = false;
+	let stop;
+	const changed = () => {
+		const next = compute();
+		if (next === cached) return;
+		cached = next;
+		for (const sub of [...subs]) sub(next);
+	};
+	return {
+		get: () => stop ? cached : compute(),
+		subscribe(sub) {
+			if (!stop) {
+				cached = compute();
+				stop = watch(changed);
+			}
+			subs.add(sub);
+			return () => {
+				if (!subs.delete(sub) || subs.size > 0) return;
+				stop?.();
+				stop = void 0;
+			};
+		}
+	};
+}
+/** True while `document` holds a document whose status is ready. */
+function documentReady(document) {
+	return computed(() => document.get()?.status.get().state === "ready", (changed) => {
+		let stopStatus;
+		const follow = (doc) => {
+			stopStatus?.();
+			stopStatus = doc?.status.subscribe(changed);
+			changed();
+		};
+		const stopDocument = document.subscribe(follow);
+		follow(document.get());
+		return () => {
+			stopDocument();
+			stopStatus?.();
+		};
+	});
+}
+/**
+* Plugin commands by namespaced id. A command is busy from `run()` until the promise its spec
+* returned settles, and is disabled meanwhile, so a double click runs it once.
+*/
+function createCommandRegistry(opts) {
+	const commands = /* @__PURE__ */ new Map();
+	const ready = documentReady(opts.document);
+	return {
+		commands,
+		add(plugin, spec) {
+			const id = `${plugin}.${spec.id}`;
+			if (commands.has(id)) throw new InkError("DuplicateId", `A command with id ${id} already exists`, { id });
+			if (!spec.label.trim()) throw new InkError("InvalidCommandLabel", `Command ${id} needs a label`, { id });
+			const busy = writable(false);
+			const allowed = spec.enabled ?? ready;
+			const enabled = computed(() => allowed.get() && !busy.get(), (changed) => {
+				const stops = [allowed.subscribe(changed), busy.subscribe(changed)];
+				return () => {
+					for (const stop of stops) stop();
+				};
+			});
+			const command = {
+				id,
+				label: spec.label,
+				icon: spec.icon,
+				enabled,
+				busy: readonly(busy),
+				status: spec.status ?? EMPTY,
+				async run() {
+					if (!enabled.get()) return;
+					busy.set(true);
+					try {
+						await spec.run();
+					} catch (error) {
+						if (!(isInkError(error) && error.code === "DocumentDestroyed")) console.error(error);
+					} finally {
+						busy.set(false);
+					}
+				}
+			};
+			commands.set(id, command);
+			return command;
+		}
+	};
+}
+//#endregion
+//#region src/dom/plugins/layer.ts
+function createLayerRegistry() {
+	const layers = [];
+	const listeners = /* @__PURE__ */ new Set();
+	const emit = (event) => {
+		for (const listener of [...listeners]) listener(event);
+	};
+	return {
+		layers,
+		watchLayers(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		add(layer) {
+			layers.push(layer);
+			emit({
+				type: "add",
+				layer
+			});
+			return { invalidate: (page) => emit({
+				type: "invalidate",
+				layer,
+				page
+			}) };
+		}
+	};
+}
+/** Runs a plugin's drawing; a throw is logged so one plugin cannot break the page. */
+function guard$1(fn) {
+	try {
+		fn();
+	} catch (error) {
+		console.error(error);
+	}
+}
+const CHILD_RULE = ":where(.ink-plugin-layer > *) { pointer-events: auto; }";
+/** One sheet per window: a constructed sheet can only be adopted in its own window. */
+const childSheets = /* @__PURE__ */ new WeakMap();
+/**
+* Puts the children's `pointer-events: auto` rule in the document or shadow root `el` lives
+* in: an adopted sheet, again if the host has since replaced its adopted sheets, or one
+* `<style>` element where adopted sheets are missing. A layer not yet connected gets it on a
+* later draw, which calls this again.
+*/
+function adoptChildRule(el) {
+	if (!el.isConnected) return;
+	const root = el.getRootNode();
+	const doc = el.ownerDocument;
+	const win = doc.defaultView;
+	if (!root.adoptedStyleSheets || !win) {
+		const parent = root === doc ? doc.head ?? doc.documentElement : root;
+		if ([...parent.children].some((c) => c.matches("style[data-ink-plugin-layer]"))) return;
+		const style = doc.createElement("style");
+		style.dataset.inkPluginLayer = "";
+		style.textContent = CHILD_RULE;
+		parent.append(style);
+		return;
+	}
+	let sheet = childSheets.get(win);
+	if (!sheet) {
+		sheet = new win.CSSStyleSheet();
+		sheet.replaceSync(CHILD_RULE);
+		childSheets.set(win, sheet);
+	}
+	if (!root.adoptedStyleSheets.includes(sheet)) root.adoptedStyleSheets = [...root.adoptedStyleSheets, sheet];
+}
+/**
+* Mounts `source`'s layers on the pages the engine mounts, and follows it: a layer added later
+* is drawn on every mounted page, and an invalidate redraws its page, or all of them.
+*
+* @internal For bindings, which mount plugin layers; plugin authors add a layer with
+* `ctx.layer`.
+*/
+function createPluginLayers(source) {
+	const pages = /* @__PURE__ */ new Map();
+	const draw = (layer, el, page, t) => {
+		adoptChildRule(el);
+		guard$1(() => layer.render(el, page, t));
+	};
+	const add = (layer, page, state) => {
+		const el = state.host.ownerDocument.createElement("div");
+		el.className = "ink-plugin-layer";
+		el.dataset.plugin = layer.plugin;
+		el.style.cssText = "position:absolute;inset:0;pointer-events:none;";
+		state.host.append(el);
+		state.elements.set(layer, el);
+		draw(layer, el, page, state.transform);
+	};
+	return {
+		mount(page, host, transform) {
+			const state = {
+				host,
+				transform,
+				elements: /* @__PURE__ */ new Map()
+			};
+			pages.set(page, state);
+			for (const layer of source.layers) add(layer, page, state);
+			return {
+				update(next) {
+					state.transform = next;
+					for (const [layer, el] of state.elements) draw(layer, el, page, next);
+				},
+				destroy() {
+					if (pages.get(page) === state) pages.delete(page);
+					for (const [layer, el] of state.elements) {
+						if (layer.destroy) guard$1(() => layer.destroy?.(el, page));
+						el.remove();
+					}
+					state.elements.clear();
+				}
+			};
+		},
+		destroy: source.watchLayers((event) => {
+			if (event.type === "add") {
+				for (const [page, state] of pages) add(event.layer, page, state);
+				return;
+			}
+			const redraw = (page, state) => {
+				const el = state.elements.get(event.layer);
+				if (el) draw(event.layer, el, page, state.transform);
+			};
+			if (event.page === void 0) for (const [page, state] of pages) redraw(page, state);
+			else {
+				const state = pages.get(event.page);
+				if (state) redraw(event.page, state);
+			}
+		})
+	};
+}
+//#endregion
+//#region src/dom/plugins/host.ts
+/**
+* `value` seen with `extra` laid over it, read-only. Everything else is read from and written to
+* `value` itself, and its methods are bound to it, so a method always runs on the original
+* (a class instance keeps its `#private` fields, and `this.id` is the plugin's own id).
+*/
+function withProps(value, extra) {
+	const bound = /* @__PURE__ */ new Map();
+	const own = (key) => Object.hasOwn(extra, key);
+	return new Proxy(Object.create(null), {
+		get(_, key) {
+			if (own(key)) return extra[key];
+			const v = Reflect.get(value, key, value);
+			if (typeof v !== "function") return v;
+			let entry = bound.get(key);
+			if (entry?.fn !== v) {
+				entry = {
+					fn: v,
+					bound: v.bind(value)
+				};
+				bound.set(key, entry);
+			}
+			return entry.bound;
+		},
+		set: (_, key, v) => !own(key) && Reflect.set(value, key, v, value),
+		defineProperty(target, key, d) {
+			if (own(key) || !Reflect.defineProperty(value, key, d)) return false;
+			const defined = Reflect.getOwnPropertyDescriptor(value, key);
+			if (defined && !defined.configurable) Reflect.defineProperty(target, key, defined);
+			return true;
+		},
+		deleteProperty: (_, key) => !own(key) && Reflect.deleteProperty(value, key),
+		has: (_, key) => own(key) || Reflect.has(value, key),
+		ownKeys: () => [.../* @__PURE__ */ new Set([...Reflect.ownKeys(value), ...Reflect.ownKeys(extra)])],
+		getOwnPropertyDescriptor(target, key) {
+			const d = Reflect.getOwnPropertyDescriptor(own(key) ? extra : value, key);
+			const fixed = Reflect.getOwnPropertyDescriptor(target, key)?.configurable === false;
+			return d && {
+				...d,
+				configurable: !fixed
+			};
+		},
+		getPrototypeOf: () => Reflect.getPrototypeOf(value)
+	});
+}
+/** Runs a plugin callback; a throw is logged so one plugin cannot break the others. */
+function guard(fn) {
+	try {
+		return fn();
+	} catch (error) {
+		console.error(error);
+		return;
+	}
+}
+/**
+* @internal For bindings and `createViewer`, which place a viewer's plugins; plugin authors use
+* `definePlugin` and never call it.
+*/
+function createPluginHost(opts) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const plugin of opts.plugins) {
+		if (seen.has(plugin.id)) throw new InkError("DuplicatePlugin", `A plugin with id ${plugin.id} is registered twice`, { id: plugin.id });
+		seen.add(plugin.id);
+	}
+	const registry = createCommandRegistry({ document: opts.document });
+	const tools = [];
+	const decorators = [];
+	const layers = createLayerRegistry();
+	const requests = [];
+	const documentFns = [];
+	const editFns = [];
+	const setupCleanups = [];
+	const redecorators = /* @__PURE__ */ new Set();
+	let opened = null;
+	let destroyed = false;
+	/** Creates a requested store for the open document and has its history track it. */
+	const openStore = (request, state, history) => {
+		const store = createRecordStore(request.key, {
+			initial: request.opts.initial?.(state.doc) ?? [],
+			...request.opts.onChange && { onChange: request.opts.onChange }
+		});
+		state.stores.push(store);
+		state.detach.push(history.track(store));
+		request.current.set(store);
+	};
+	const runOnDocument = (fn, state) => {
+		const cleanup = guard(() => fn(state.doc));
+		if (typeof cleanup === "function") state.cleanups.push(cleanup);
+	};
+	const open = (doc) => {
+		const history = opts.history();
+		const state = {
+			doc,
+			stores: [],
+			detach: [],
+			cleanups: []
+		};
+		opened = state;
+		for (const request of requests) openStore(request, state, history);
+		for (const fn of editFns) state.detach.push(history.react(fn));
+		for (const fn of documentFns) runOnDocument(fn, state);
+	};
+	const close = () => {
+		const state = opened;
+		if (!state) return;
+		opened = null;
+		for (const detach of state.detach) detach();
+		for (const store of state.stores) store.destroy();
+		for (const request of requests) request.current.set(null);
+		for (const cleanup of state.cleanups.reverse()) guard(cleanup);
+	};
+	const contextFor = (plugin) => {
+		const storeNames = /* @__PURE__ */ new Set();
+		return {
+			id: plugin.id,
+			document: opts.document,
+			history: { batch: (fn) => opts.history().batch(fn) },
+			activated: opts.activated,
+			setActivated: (id) => opts.setActivated(id),
+			root: opts.root,
+			commands: { add: (spec) => registry.add(plugin.id, spec) },
+			tools: { add(tool) {
+				const id = `${plugin.id}.${tool.id}`;
+				if (tools.some((t) => t.id === id)) throw new InkError("DuplicateId", `A tool with id ${id} already exists`, { id });
+				tools.push(withProps(tool, { id }));
+			} },
+			decorate(fn) {
+				decorators.push(fn);
+			},
+			redecorate() {
+				for (const listener of [...redecorators]) listener();
+			},
+			store(name, storeOpts = {}) {
+				const key = `${plugin.id}.${name}`;
+				if (storeNames.has(name)) throw new InkError("DuplicateId", `A store with key ${key} already exists`, { key });
+				storeNames.add(name);
+				const request = {
+					key,
+					opts: storeOpts,
+					current: writable(null)
+				};
+				requests.push(request);
+				if (opened) openStore(request, opened, opts.history());
+				return readonly(request.current);
+			},
+			onDocument(fn) {
+				documentFns.push(fn);
+				if (opened) runOnDocument(fn, opened);
+			},
+			onAnnotationEdit(fn) {
+				editFns.push(fn);
+				if (opened) opened.detach.push(opts.history().react(fn));
+			},
+			layer(spec) {
+				return layers.add(withProps(spec, { plugin: plugin.id }));
+			},
+			scrollTo(page, rect, scrollOpts) {
+				opts.viewport?.()?.scrollToRect(page, rect, scrollOpts);
+			}
+		};
+	};
+	for (const plugin of opts.plugins) {
+		let cleanup;
+		try {
+			cleanup = plugin.setup(contextFor(plugin));
+		} catch (error) {
+			for (const done of setupCleanups.reverse()) guard(done);
+			throw error;
+		}
+		if (typeof cleanup === "function") setupCleanups.push(cleanup);
+	}
+	const current = opts.document.get();
+	if (current) open(current);
+	const stopDocument = opts.document.subscribe((doc) => {
+		close();
+		if (doc) open(doc);
+	});
+	return {
+		commands: registry.commands,
+		command: (id) => registry.commands.get(id),
+		tools,
+		decorate(annotation) {
+			const all = [opts.decorate?.(), ...decorators];
+			let merged;
+			for (const fn of all) {
+				const d = fn && guard(() => fn(annotation));
+				if (!d) continue;
+				merged ??= {};
+				if (d.data) merged = {
+					...merged,
+					data: {
+						...d.data,
+						...merged.data
+					}
+				};
+				if (d.classes) merged = {
+					...merged,
+					classes: [...merged.classes ?? [], ...d.classes]
+				};
+				if (merged.description === void 0 && d.description !== void 0) merged = {
+					...merged,
+					description: d.description
+				};
+			}
+			return merged;
+		},
+		layers: layers.layers,
+		watchLayers: (listener) => layers.watchLayers(listener),
+		watchRedecorate(listener) {
+			const run = () => listener();
+			redecorators.add(run);
+			return () => {
+				redecorators.delete(run);
+			};
+		},
+		destroy() {
+			if (destroyed) return;
+			destroyed = true;
+			stopDocument();
+			close();
+			for (const cleanup of setupCleanups.reverse()) guard(cleanup);
+		}
+	};
+}
+//#endregion
 //#region src/dom/page-mount.ts
-/** Canvas, text layer and annotation overlay for one page, stacked in that order. */
+/**
+* Canvas, text layer, annotation overlay and any plugin layers for one page, stacked in that
+* order.
+*/
 function createPageMount(opts) {
 	const { document, page, host, transform } = opts;
 	const callbacks = (layer) => ({
@@ -2852,6 +4064,7 @@ function createPageMount(opts) {
 		...opts.isCustom ? { isCustom: (a) => opts.isCustom?.(a) === true } : {},
 		...opts.decorate ? { decorate: opts.decorate } : {}
 	});
+	const layers = opts.layers?.mount(page, host, transform);
 	return {
 		renderer,
 		textLayer,
@@ -2860,8 +4073,10 @@ function createPageMount(opts) {
 			renderer.update(next);
 			textLayer.update(next);
 			overlay.update(next);
+			layers?.update(next);
 		},
 		destroy() {
+			layers?.destroy();
 			overlay.destroy();
 			textLayer.destroy();
 			renderer.destroy();
@@ -3611,6 +4826,8 @@ function onScrollBar(e, root) {
 function inCustomContent(target) {
 	if (!(target instanceof Element)) return false;
 	if (target.closest("[data-ink-editor]")) return true;
+	const layer = target.closest(".ink-plugin-layer");
+	if (layer && layer !== target) return true;
 	const el = target.closest("[data-annotation]");
 	return el !== null && el !== target && el.hasAttribute("data-custom") && target.closest("[data-handle]") === null;
 }
@@ -5381,7 +6598,7 @@ function handleTabKeys(e, tablist) {
 	tabs[next].focus({ preventScroll: true });
 	tabs[next].click();
 }
-const TABBABLE$1 = [
+const TABBABLE = [
 	"a[href]",
 	"button:not(:disabled)",
 	"input:not(:disabled):not([type=\"hidden\"])",
@@ -5395,7 +6612,7 @@ const TABBABLE$1 = [
 */
 function trapTab(e, container) {
 	if (e.key !== "Tab" || e.defaultPrevented) return;
-	const stops = [...container.querySelectorAll(TABBABLE$1)].filter((el) => !el.matches(":disabled") && el.getClientRects().length > 0);
+	const stops = [...container.querySelectorAll(TABBABLE)].filter((el) => !el.matches(":disabled") && el.getClientRects().length > 0);
 	if (stops.length === 0) {
 		e.preventDefault();
 		return;
@@ -5412,239 +6629,6 @@ function trapTab(e, container) {
 	}
 }
 //#endregion
-//#region src/dom/annotation-element.ts
-/** The overlay element drawn for annotation `id` under `root`, if it is in the DOM. */
-function annotationElementFor(root, id) {
-	return root.querySelector(`[data-annotation="${CSS.escape(id)}"]`);
-}
-/**
-* Resolves the overlay element for `id` and keeps resolving while `root`'s subtree changes:
-* the overlay creates and removes these elements outside any framework (a page mounts as it
-* scrolls into view), so a popover anchored to one has to follow. Calls `onChange` once now
-* and again whenever the answer changes. The returned function stops observing.
-*/
-function observeAnnotationElement(root, id, onChange) {
-	let last;
-	const resolve = () => {
-		const found = annotationElementFor(root, id);
-		if (found === last) return;
-		last = found;
-		onChange(found);
-	};
-	resolve();
-	const observer = new MutationObserver(resolve);
-	observer.observe(root, {
-		childList: true,
-		subtree: true
-	});
-	return () => observer.disconnect();
-}
-//#endregion
-//#region src/dom/popover-focus.ts
-/**
-* A press that will activate an annotation is not a dismissal: the popover follows the
-* activation. Mirrors the overlay's rule: a press on the annotation element or on its drawn
-* shape activates; a press on a custom element's own content belongs to that content.
-*/
-function shouldKeepOpenOnAnnotation(target) {
-	if (!(target instanceof Element)) return false;
-	const annotation = target.closest("[data-annotation]");
-	if (!annotation) return false;
-	return target === annotation || !annotation.hasAttribute("data-custom");
-}
-function createFocusReturn(opts) {
-	let fallbacks = [];
-	/** Set by `beforeRemove`: the close comes from removing the anchor's annotation. */
-	let removing = false;
-	return {
-		beforeRemove(anchor, prefer) {
-			fallbacks = [];
-			removing = true;
-			const siblings = anchor?.parentElement ? [...anchor.parentElement.children].filter((el) => el instanceof HTMLElement && el.hasAttribute("data-annotation")) : [];
-			const i = anchor ? siblings.indexOf(anchor) : -1;
-			if (i >= 0) {
-				const after = siblings.slice(i + 1);
-				const preferred = prefer ? after.filter((el) => el.matches(prefer)) : [];
-				fallbacks.push(...preferred, ...after, ...siblings.slice(0, i).reverse());
-			}
-		},
-		onCloseAutoFocus(event, anchor) {
-			event.preventDefault();
-			const plan = fallbacks;
-			const removed = removing;
-			fallbacks = [];
-			removing = false;
-			const root = opts.root();
-			if (!root) return;
-			const activated = opts.activated();
-			if (activated !== null && annotationElementFor(root, activated)) return;
-			const active = root.ownerDocument.activeElement;
-			if (active && active !== root && root.contains(active)) return;
-			const scroll = root.querySelector("[data-ink-scroll]");
-			(removed ? [...plan, scroll] : [
-				anchor,
-				...plan,
-				scroll
-			]).find((el) => el?.isConnected)?.focus({ preventScroll: true });
-		}
-	};
-}
-//#endregion
-//#region src/dom/viewer/dom.ts
-/** `document.createElement` with attributes and children. */
-function h(tag, attrs = {}, ...children) {
-	const el = document.createElement(tag);
-	for (const [name, value] of Object.entries(attrs)) el.setAttribute(name, value);
-	el.append(...children);
-	return el;
-}
-function button$1(label, onClick) {
-	const b = h("button", { type: "button" }, label);
-	b.addEventListener("click", onClick);
-	return b;
-}
-//#endregion
-//#region src/dom/viewer/popover.ts
-/** Space between the anchor and the panel, and between the panel and the window edge. */
-const GAP = 6;
-const MARGIN = 8;
-const TABBABLE = "button, input, select, textarea, a[href], [tabindex]";
-/**
-* Positions `panel` (fixed) below the `anchor` rectangle, or above it when only that fits,
-* kept inside the window. For panels anchored to something other than an annotation.
-*/
-function placePanel(panel, anchor) {
-	const { innerWidth: vw, innerHeight: vh } = window;
-	panel.style.position = "fixed";
-	panel.style.left = "0px";
-	panel.style.top = "0px";
-	const w = panel.offsetWidth;
-	const ht = panel.offsetHeight;
-	let top = anchor.bottom + GAP;
-	if (top + ht > vh - MARGIN && anchor.top - GAP - ht >= MARGIN) top = anchor.top - GAP - ht;
-	top = Math.max(MARGIN, Math.min(top, vh - ht - MARGIN));
-	const left = Math.max(MARGIN, Math.min(anchor.left, vw - w - MARGIN));
-	panel.style.left = `${left}px`;
-	panel.style.top = `${top}px`;
-}
-/**
-* Creates a non-modal `role="dialog"` panel on `<body>`, marked `data-ink-popover` so the theme
-* gives it its tokens, that an app anchors to an annotation with `show(id)` (for instance on
-* `viewer.activated`). The panel follows the annotation's element as pages mount and unmount:
-* it hides while the element is gone and comes back with it. Tab loops inside the panel, and
-* Escape or a press outside calls `onDismiss`. Call `destroy` when done.
-*/
-function createPopover(opts) {
-	const { root, focusReturn } = opts;
-	const panel = h("div", {
-		...opts.attrs,
-		role: "dialog",
-		"data-ink-popover": "",
-		hidden: ""
-	});
-	document.body.append(panel);
-	let anchoredId = null;
-	let anchor = null;
-	let stopObserving = () => void 0;
-	/** The element that had focus in the panel when the anchor went away. */
-	let stranded = null;
-	const place = () => {
-		if (!anchor || panel.hidden) return;
-		placePanel(panel, anchor.getBoundingClientRect());
-	};
-	const resizes = new ResizeObserver(place);
-	resizes.observe(panel);
-	const onAnchor = (el, closing = false) => {
-		if (anchor) resizes.unobserve(anchor);
-		anchor = el;
-		if (!el) {
-			const active = document.activeElement;
-			if (!closing && !panel.hidden && active instanceof HTMLElement && panel.contains(active)) {
-				const scroll = root.querySelector("[data-ink-scroll]");
-				if (scroll) {
-					stranded = active;
-					scroll.focus({ preventScroll: true });
-				}
-			}
-			panel.hidden = true;
-			return;
-		}
-		resizes.observe(el);
-		const wasHidden = panel.hidden;
-		panel.hidden = false;
-		place();
-		if (wasHidden && stranded) {
-			const back = stranded;
-			stranded = null;
-			const scroll = root.querySelector("[data-ink-scroll]");
-			if (panel.contains(back) && document.activeElement === scroll) back.focus({ preventScroll: true });
-		}
-	};
-	const onKey = (e) => {
-		if (e.key !== "Escape" || panel.hidden || e.defaultPrevented) return;
-		const target = e.target;
-		if (!(target instanceof Node) || !(panel.contains(target) || root.contains(target))) return;
-		e.preventDefault();
-		opts.onDismiss();
-	};
-	const onPress = (e) => {
-		if (panel.hidden || panel.contains(e.target)) return;
-		if (shouldKeepOpenOnAnnotation(e.target)) return;
-		opts.onDismiss();
-	};
-	const onTab = (e) => {
-		if (e.key !== "Tab" || e.altKey || e.ctrlKey || e.metaKey) return;
-		const tabbable = [...panel.querySelectorAll(TABBABLE)].filter((el) => !el.disabled && el.tabIndex >= 0);
-		const first = tabbable[0];
-		const last = tabbable.at(-1);
-		if (!first || !last) return;
-		const active = document.activeElement;
-		if (e.shiftKey ? active !== first : active !== last) return;
-		e.preventDefault();
-		(e.shiftKey ? last : first).focus();
-	};
-	panel.addEventListener("keydown", onTab);
-	document.addEventListener("keydown", onKey);
-	document.addEventListener("pointerdown", onPress, true);
-	document.addEventListener("scroll", place, true);
-	window.addEventListener("resize", place);
-	return {
-		panel,
-		get anchor() {
-			return anchor;
-		},
-		show(id) {
-			if (id === anchoredId) return;
-			stopObserving();
-			anchoredId = id;
-			stopObserving = observeAnnotationElement(root, id, onAnchor);
-		},
-		hide() {
-			if (anchoredId === null) return;
-			stopObserving();
-			stopObserving = () => void 0;
-			anchoredId = null;
-			const back = anchor;
-			stranded = null;
-			onAnchor(null, true);
-			queueMicrotask(() => {
-				if (anchoredId !== null || !panel.isConnected) return;
-				focusReturn.onCloseAutoFocus(new Event("closeautofocus", { cancelable: true }), back);
-			});
-		},
-		destroy() {
-			stopObserving();
-			resizes.disconnect();
-			document.removeEventListener("keydown", onKey);
-			document.removeEventListener("pointerdown", onPress, true);
-			panel.removeEventListener("keydown", onTab);
-			document.removeEventListener("scroll", place, true);
-			window.removeEventListener("resize", place);
-			panel.remove();
-		}
-	};
-}
-//#endregion
 //#region src/dom/viewer-engine.ts
 function mountViewer(opts) {
 	const { container: el, document: doc } = opts;
@@ -5657,7 +6641,15 @@ function mountViewer(opts) {
 	let stopKeys = () => void 0;
 	let stopActive = () => void 0;
 	let destroyed = false;
-	const hostTools = opts.tools ?? [];
+	const plugins = opts.plugins;
+	const hostTools = [...opts.tools ?? [], ...plugins?.tools ?? []];
+	/** Plugin layers follow the host for the engine's life, across rebuilds. */
+	const layers = plugins && createPluginLayers(plugins);
+	const decorate = plugins ? (a) => plugins.decorate(a) : (a) => opts.decorateAnnotation?.(a);
+	/** A plugin's `ctx.redecorate()` reaches every page this engine has mounted. */
+	const stopRedecorate = plugins?.watchRedecorate(() => {
+		for (const mount of pages.values()) mount.overlay.redecorate();
+	});
 	/** Option values outlive rebuilds: every controller shares this registry. */
 	const toolOptions = opts.toolOptions ?? createToolOptions();
 	/** Without a host style, the engine's own follows the active tool across rebuilds. */
@@ -5686,7 +6678,8 @@ function mountViewer(opts) {
 			store: doc.annotations,
 			onActivate: (id) => opts.onActivate?.(id),
 			isCustom: () => isCustom,
-			decorate: (a) => opts.decorateAnnotation?.(a),
+			decorate,
+			...layers ? { layers } : {},
 			onError: (cause, layer) => {
 				failed.add(layer);
 				if (error) return;
@@ -5871,6 +6864,8 @@ function mountViewer(opts) {
 			if (destroyed) return;
 			destroyed = true;
 			teardown();
+			layers?.destroy();
+			stopRedecorate?.();
 		}
 	};
 }
@@ -6043,8 +7038,14 @@ function createThreadForm(n, actions) {
 }
 //#endregion
 //#region src/dom/viewer/create-viewer.ts
+const noop = () => void 0;
+const passThrough = {
+	batch: (fn) => fn(),
+	track: () => noop,
+	react: () => noop
+};
 function createViewer(el, opts) {
-	const { source: initial, assets, password, defaults, history, threads: withThreads = true, onReady, onError, onActivate, onBuild, onPageMount, onPageUnmount, onPageError, toolStyle: _toolStyle, toolOptions: _toolOptions, signatureLibrary: _signatureLibrary, signatures: signatureStore, ...view } = opts;
+	const { source: initial, assets, password, defaults, history, plugins, threads: withThreads = true, onReady, onError, onActivate, onBuild, onPageMount, onPageUnmount, onPageError, toolStyle: _toolStyle, toolOptions: _toolOptions, signatureLibrary: _signatureLibrary, signatures: signatureStore, ...view } = opts;
 	/** One library for the viewer's life, so templates and the menu outlive each document. */
 	const signatures = createSignatureLibrary(signatureStore ?? createMemorySignatureStore());
 	/** Tool options persist for the viewer's life; the tool style is per document. */
@@ -6056,6 +7057,7 @@ function createViewer(el, opts) {
 	const tools = writable(null);
 	/** The activated annotation: the note thread opens from it. */
 	const activated = writable(null);
+	const rootEl = writable(null);
 	const root = h("div", {
 		"data-ink-root": "",
 		"data-state": "idle"
@@ -6074,6 +7076,24 @@ function createViewer(el, opts) {
 	}, scroll);
 	root.append(viewportRoot);
 	el.append(root);
+	rootEl.set(scroll);
+	/**
+	* One host for the viewer's life. It reads the history when a document opens, and `current`
+	* is set before it notifies, so that is the new document's. With no document open, a
+	* command's `batch` just runs its function.
+	*/
+	const host = createPluginHost({
+		plugins: plugins ?? [],
+		document: readonly(current),
+		history: () => current.get()?.history ?? passThrough,
+		activated: readonly(activated),
+		setActivated: (id) => {
+			if (id === null || current.get()?.annotations.get(id)) activated.set(id);
+		},
+		root: readonly(rootEl),
+		decorate: () => view.decorateAnnotation,
+		viewport: () => viewport.get()
+	});
 	const focusReturn = createFocusReturn({
 		root: () => root,
 		activated: () => activated.get()
@@ -6123,6 +7143,7 @@ function createViewer(el, opts) {
 		};
 		const mounted = mountViewer({
 			...view,
+			plugins: host,
 			container: scroll,
 			document: doc,
 			toolOptions,
@@ -6219,7 +7240,7 @@ function createViewer(el, opts) {
 		});
 	}
 	open(initial);
-	return {
+	const viewer = {
 		element: root,
 		status: readonly(status),
 		document: readonly(current),
@@ -6227,18 +7248,33 @@ function createViewer(el, opts) {
 		viewport: readonly(viewport),
 		tools: readonly(tools),
 		activated: readonly(activated),
-		setActivated(id) {
+		setActivated: (id) => {
 			if (id === null || current.get()?.annotations.get(id)) activated.set(id);
 		},
+		commands: { get: (id) => host.command(id) },
 		open,
 		destroy() {
 			if (destroyed) return;
 			destroyed = true;
 			loads++;
 			close();
+			host.destroy();
 			root.remove();
 		}
 	};
+	toolsByViewer.set(viewer, [...view.tools ?? [], ...host.tools]);
+	commandIdsByViewer.set(viewer, () => [...host.commands.keys()]);
+	return viewer;
+}
+const toolsByViewer = /* @__PURE__ */ new WeakMap();
+/** The host tools a viewer was given (its own and its plugins'), for the controls' labels and icons. */
+function hostToolsOf(viewer) {
+	return toolsByViewer.get(viewer) ?? [];
+}
+const commandIdsByViewer = /* @__PURE__ */ new WeakMap();
+/** The ids of the commands a viewer's plugins registered, for the error on an unknown one. */
+function hostCommandIdsOf(viewer) {
+	return commandIdsByViewer.get(viewer)?.() ?? [];
 }
 //#endregion
 //#region src/dom/viewer/controls.ts
@@ -6350,15 +7386,16 @@ function historyButton(viewer, action) {
 	return b;
 }
 /**
-* Sets the tool; pressed while it is the active one. A host tool's button has no icon (append
-* your own) and is named by `label`, else by the tool id.
+* Sets the tool; pressed while it is the active one. A host or plugin tool's button takes the
+* tool's own `label` and `icon`; `opts.label` wins, and without either it is named by the tool id.
 */
 function createToolButton(viewer, tool, opts = {}) {
-	const b = button(opts.label ?? TOOL_LABELS[tool] ?? tool, {
+	const own = hostToolsOf(viewer).find((t) => t.id === tool);
+	const b = button(opts.label ?? TOOL_LABELS[tool] ?? own?.label ?? tool, {
 		class: "ink-tool-button",
 		"data-ink-tool-button": "",
 		"data-tool": tool
-	}, TOOL_ICONS[tool]);
+	}, TOOL_ICONS[tool] ?? own?.icon);
 	const show = (active) => {
 		const on = active === tool;
 		b.dataset.state = on ? "on" : "off";
@@ -6368,6 +7405,48 @@ function createToolButton(viewer, tool, opts = {}) {
 	follow(viewer.tools, b, (tools, watch) => watch(tools.active, show), () => show(null));
 	return b;
 }
+/**
+* A plugin command as a button with its status text beside it. The button is named by the
+* command's label and disabled while the command is, except while it runs: then it keeps focus,
+* with `aria-busy` and `aria-disabled`, and a press does nothing. The status is a live region. A command without an icon shows its label as the button's text. For an id no
+* plugin registered it logs `InkError('UnknownCommand')` to the console and returns the same
+* markup disabled, `aria-hidden` and unnamed.
+*/
+function createCommandButton(viewer, id) {
+	const command = viewer.commands.get(id);
+	const status = h("span", {
+		class: "ink-command-status",
+		role: "status"
+	});
+	if (!command) {
+		console.error(unknownCommand(id, hostCommandIdsOf(viewer)));
+		const pending = h("button", {
+			type: "button",
+			"data-command": id,
+			"aria-hidden": "true"
+		});
+		pending.disabled = true;
+		return h("div", { class: "ink-command" }, pending, status);
+	}
+	const b = button(command.label, { "data-command": id }, command.icon);
+	if (!command.icon) b.textContent = command.label;
+	b.addEventListener("click", () => void command.run());
+	const sync = () => {
+		const busy = command.busy.get();
+		b.disabled = !command.enabled.get() && !busy;
+		b.setAttribute("aria-busy", String(busy));
+		if (busy) b.setAttribute("aria-disabled", "true");
+		else b.removeAttribute("aria-disabled");
+	};
+	command.enabled.subscribe(sync);
+	command.busy.subscribe(sync);
+	sync();
+	command.status.subscribe((text) => {
+		status.textContent = text;
+	});
+	status.textContent = command.status.get();
+	return h("div", { class: "ink-command" }, b, status);
+}
 function createZoomIn(viewer) {
 	const b = button("Zoom in", {
 		class: "ink-zoom-in",
@@ -8110,6 +9189,6 @@ function createSignatureMenu(viewer, opts = {}) {
 	return root;
 }
 //#endregion
-export { ARROWHEAD_CHOICES, ARROWHEAD_ENDING, COLOR_COLUMNS, COLOR_LABELS, DASH_PATTERN, DEFAULT_CORNER_RADIUS, DEFAULT_FREETEXT_WIDTH, DEFAULT_HIGHLIGHT_OPTIONS, DEFAULT_SHAPE_SIZE, FONT_FAMILIES, LINE_WEIGHTS, MARKUP_ICONS, MARKUP_KINDS, MARKUP_LABELS, PALETTE, SHAPE_COLUMNS, SHAPE_ICONS, SHAPE_KINDS, SHAPE_LABELS, SIGNATURE_FONTS, SIGNATURE_IMAGE_MAX_LENGTH, SIGNATURE_IMAGE_MAX_SIDE, SIGNATURE_IMAGE_TYPES, SIGNATURE_LABELS, SIGNATURE_TABS, TOOL_LABELS, ZOOM_LEVELS, annotationElementFor, arrowheadChoice, attachViewportKeys, builtinTools, clampFontSize, colorMenuModel, computeCssLayout, createColorMenu, createFocusReturn, createHighlightMenu, createIcon, createImageSignature, createLineStyleMenu, createMenu, createNextPage, createOverlay, createPageCount, createPageInput, createPageMount, createPageRenderer, createPageTransform, createPopover, createPrevPage, createRedo, createShapeMenu, createSignatureDialog, createSignatureDraft, createSignatureMenu, createSignaturePad, createSignaturePreview, createTextLayer, createTextStyleMenu, createToolButton, createToolController, createToolOptions, createToolbar, createToolbarSeparator, createTypedSignature, createUndo, createViewer, createViewport, createZoomIn, createZoomOut, createZoomSelect, cssRectsToUserRects, cssVariableDefaults, editFreeText, fitZoomCss, focusInitialMenuItem, fontFamilyValue, freetextTool, getSelectionQuads, handleMenuKeys, handleRadioKeys, handleTabKeys, highlightMenuModel, highlightTool, hitFor, lineStyleMenuModel, menuItems, mostVisiblePageCss, mountViewer, normalizeRotation, noteTool, observeAnnotationElement, placePanel, redactAreaTool, renderAnnotationContent, renderTypedSignature, selectTextTool, selectTool, shapeMenuModel, shapeTool, shouldKeepOpenOnAnnotation, signatureMenuModel, signaturePreview, signatureTool, textStyleMenuModel, threadDeleteLabel, threadPopoverLabel, trackToolStyle, trapTab, visibleRangeCss, withHostTools };
+export { ARROWHEAD_CHOICES, ARROWHEAD_ENDING, COLOR_COLUMNS, COLOR_LABELS, DASH_PATTERN, DEFAULT_CORNER_RADIUS, DEFAULT_FREETEXT_WIDTH, DEFAULT_HIGHLIGHT_OPTIONS, DEFAULT_SHAPE_SIZE, FONT_FAMILIES, LINE_WEIGHTS, MARKUP_ICONS, MARKUP_KINDS, MARKUP_LABELS, PALETTE, SHAPE_COLUMNS, SHAPE_ICONS, SHAPE_KINDS, SHAPE_LABELS, SIGNATURE_FONTS, SIGNATURE_IMAGE_MAX_LENGTH, SIGNATURE_IMAGE_MAX_SIDE, SIGNATURE_IMAGE_TYPES, SIGNATURE_LABELS, SIGNATURE_TABS, TOOL_LABELS, ZOOM_LEVELS, annotationElementFor, arrowheadChoice, attachViewportKeys, builtinTools, clampFontSize, colorMenuModel, computeCssLayout, createColorMenu, createCommandButton, createFocusReturn, createHighlightMenu, createIcon, createImageSignature, createLineStyleMenu, createMenu, createNextPage, createOverlay, createPageCount, createPageInput, createPageMount, createPageRenderer, createPageTransform, createPluginHost, createPluginLayers, createPopover, createPrevPage, createRedo, createShapeMenu, createSignatureDialog, createSignatureDraft, createSignatureMenu, createSignaturePad, createSignaturePreview, createTextLayer, createTextStyleMenu, createToolButton, createToolController, createToolOptions, createToolbar, createToolbarSeparator, createTypedSignature, createUndo, createViewer, createViewport, createZoomIn, createZoomOut, createZoomSelect, cssRectsToUserRects, cssVariableDefaults, definePlugin, editFreeText, fitZoomCss, focusInitialMenuItem, fontFamilyValue, freetextTool, getSelectionQuads, handleMenuKeys, handleRadioKeys, handleTabKeys, highlightMenuModel, highlightTool, hitFor, lineStyleMenuModel, menuItems, mostVisiblePageCss, mountViewer, normalizeRotation, noteTool, observeAnnotationElement, placePanel, redactAreaTool, renderAnnotationContent, renderTypedSignature, selectTextTool, selectTool, shapeMenuModel, shapeTool, shouldKeepOpenOnAnnotation, signatureMenuModel, signaturePreview, signatureTool, textStyleMenuModel, threadDeleteLabel, threadPopoverLabel, trackToolStyle, trapTab, unknownCommand, visibleRangeCss, withHostTools };
 
 //# sourceMappingURL=dom.mjs.map