@inkbar/core 0.5.0 → 0.7.0

package/dist/{signatures-CMapTKrC.mjs → signatures-Do_l2IlM.mjs}

@@ -96,6 +96,15 @@ function quadFromRect(r) {
 		}
 	};
 }
+/** One quad covering `r`, in the corner order of `quadFromRect`. */
+function quadsFromRect(r) {
+	return [quadFromRect(r)];
+}
+/** The bounding box of every corner of `quads`. */
+function rectFromQuads(quads) {
+	if (quads.length === 0) throw new RangeError("rectFromQuads needs at least one quad");
+	return unionRects(quads.map(rectFromQuad));
+}
 function unionRects(rects) {
 	if (rects.length === 0) throw new RangeError("unionRects needs at least one rect");
 	let x1 = Infinity;
@@ -251,6 +260,102 @@ function readonly(w) {
 	};
 }
 //#endregion
+//#region src/model/records.ts
+/**
+* A keyed list of plain records. Records are stored as frozen copies, so a change's `before` and `after` can be
+* kept as history entries without copying.
+*/
+function createRecordStore(key, opts = {}) {
+	const list = writable((opts.initial ?? []).map(frozen));
+	const emitter = new Emitter();
+	let destroyed = false;
+	function commit(next, change) {
+		if (destroyed) return;
+		list.set(next);
+		emitter.emit("change", change);
+		opts.onChange?.(next, change);
+	}
+	return {
+		key,
+		list: readonly(list),
+		get: (id) => list.get().find((r) => r.id === id),
+		add(record) {
+			if (list.get().some((r) => r.id === record.id)) throw new InkError("DuplicateId", `A record with id ${record.id} already exists`, {
+				key,
+				id: record.id
+			});
+			const stored = frozen(record);
+			commit([...list.get(), stored], {
+				kind: "add",
+				record: stored
+			});
+			return stored;
+		},
+		update(id, patch) {
+			const before = list.get().find((r) => r.id === id);
+			if (destroyed || !before) return void 0;
+			const after = Object.freeze({
+				...before,
+				...patch,
+				id: before.id
+			});
+			commit(list.get().map((r) => r.id === id ? after : r), {
+				kind: "update",
+				id,
+				before,
+				after
+			});
+			return after;
+		},
+		remove(id) {
+			const record = list.get().find((r) => r.id === id);
+			if (destroyed || !record) return void 0;
+			commit(list.get().filter((r) => r.id !== id), {
+				kind: "remove",
+				record
+			});
+			return record;
+		},
+		replaceAll(incoming, reason) {
+			const prev = new Map(list.get().map((r) => [r.id, r]));
+			const added = [];
+			const updated = [];
+			const next = incoming.map((r) => {
+				const old = prev.get(r.id);
+				if (!old) {
+					added.push(r.id);
+					return frozen(r);
+				}
+				if (shallowEqual(old, r)) return old;
+				updated.push(r.id);
+				return frozen(r);
+			});
+			const kept = new Set(next.map((r) => r.id));
+			commit(next, {
+				kind: "replace",
+				reason,
+				added,
+				updated,
+				removed: [...prev.keys()].filter((id) => !kept.has(id))
+			});
+		},
+		on: (event, fn) => emitter.on(event, fn),
+		destroy() {
+			destroyed = true;
+			emitter.clear();
+		}
+	};
+}
+/** Freezes a copy, so the caller's object stays theirs; an already frozen record is kept. */
+function frozen(record) {
+	return Object.isFrozen(record) ? record : Object.freeze({ ...record });
+}
+function shallowEqual(a, b) {
+	const ka = Object.keys(a);
+	const kb = Object.keys(b);
+	return ka.length === kb.length && ka.every((k) => Object.hasOwn(b, k) && a[k] === b[k]);
+}
+//#endregion
 //#region src/model/selection.ts
 const union = (a, b) => {
 	const x = Math.min(a.x, b.x);
@@ -305,6 +410,167 @@ function mergeLineRects(rects, tolerance = 2, gap) {
 	return runs.map(quadFromRect);
 }
 //#endregion
+//#region src/pdfjs/glyphs.ts
+const IDENTITY = [
+	1,
+	0,
+	0,
+	1,
+	0,
+	0
+];
+const FONT_IDENTITY = [
+	.001,
+	0,
+	0,
+	.001,
+	0,
+	0
+];
+/**
+* The glyphs a page draws, in content order, with where each starts and where its own width ends
+* in user space. The pen moves the way PDF.js's canvas renderer moves it (`showText` and
+* `showType3Text`): text matrix and moves, the current transformation matrix, font size and font
+* matrix, character and word spacing, horizontal scaling, and `TJ` kerning. Glyphs in vertical
+* fonts are left out. Annotation appearances are not read.
+*/
+async function pageGlyphs(page, pdfjs) {
+	const ops = pdfjs.OPS;
+	const list = await page.getOperatorList({ annotationMode: pdfjs.AnnotationMode.DISABLE });
+	const out = [];
+	let s = {
+		ctm: IDENTITY,
+		textMatrix: IDENTITY,
+		x: 0,
+		y: 0,
+		lineX: 0,
+		lineY: 0,
+		font: {},
+		fontSize: 0,
+		fontDirection: 1,
+		charSpacing: 0,
+		wordSpacing: 0,
+		hScale: 1,
+		leading: 0,
+		rise: 0
+	};
+	const saved = [];
+	const save = () => {
+		saved.push(s);
+		s = { ...s };
+	};
+	const restore = () => {
+		s = saved.pop() ?? s;
+	};
+	const setFont = (name, size) => {
+		let font = {};
+		try {
+			font = page.commonObjs.get(String(name)) ?? {};
+		} catch {}
+		const n = Number(size);
+		s.font = font;
+		s.fontDirection = n < 0 ? -1 : 1;
+		s.fontSize = Math.abs(n);
+	};
+	const moveText = (x, y) => {
+		s.x = s.lineX += x;
+		s.y = s.lineY += y;
+	};
+	const show = (glyphs) => {
+		const { font, fontSize, fontDirection, charSpacing, wordSpacing } = s;
+		if (fontSize === 0) return;
+		const fontMatrix = font.fontMatrix ?? FONT_IDENTITY;
+		const toUser = multiplyMatrix(s.textMatrix, s.ctm);
+		const at = (x) => applyMatrix(toUser, {
+			x: s.x + x,
+			y: s.y + s.rise
+		});
+		const hScale = s.hScale * fontDirection;
+		let x = 0;
+		for (const g of glyphs) {
+			if (typeof g === "number") {
+				x += -g * fontSize / 1e3;
+				continue;
+			}
+			if (!g) continue;
+			const spacing = charSpacing + (g.isSpace ? wordSpacing : 0);
+			const width = font.isType3Font ? (g.width * fontMatrix[0] + fontMatrix[4]) * fontSize : g.width * fontSize * fontMatrix[0];
+			if (!font.vertical) out.push({
+				text: g.unicode,
+				start: at(x * hScale),
+				end: at((x + width) * hScale)
+			});
+			x += width + spacing * (font.isType3Font ? 1 : fontDirection);
+		}
+		s.x += x * hScale;
+	};
+	for (let i = 0; i < list.fnArray.length; i++) {
+		const args = list.argsArray[i];
+		switch (list.fnArray[i]) {
+			case ops.save:
+				save();
+				break;
+			case ops.restore:
+				restore();
+				break;
+			case ops.paintFormXObjectBegin:
+				save();
+				if (args?.[0]) s.ctm = multiplyMatrix(args[0], s.ctm);
+				break;
+			case ops.paintFormXObjectEnd:
+				restore();
+				break;
+			case ops.transform:
+				s.ctm = multiplyMatrix(args, s.ctm);
+				break;
+			case ops.beginText:
+				s.textMatrix = IDENTITY;
+				s.x = s.lineX = s.y = s.lineY = 0;
+				break;
+			case ops.setTextMatrix:
+				s.textMatrix = args[0];
+				s.x = s.lineX = s.y = s.lineY = 0;
+				break;
+			case ops.moveText:
+				moveText(Number(args[0]), Number(args[1]));
+				break;
+			case ops.setLeadingMoveText:
+				s.leading = Number(args[1]);
+				moveText(Number(args[0]), Number(args[1]));
+				break;
+			case ops.setLeading:
+				s.leading = -Number(args[0]);
+				break;
+			case ops.nextLine:
+				moveText(0, s.leading);
+				break;
+			case ops.setFont:
+				setFont(args[0], args[1]);
+				break;
+			case ops.setGState:
+				for (const [key, value] of args[0]) if (key === "Font") {
+					const [name, size] = value;
+					setFont(name, size);
+				}
+				break;
+			case ops.setCharSpacing:
+				s.charSpacing = Number(args[0]);
+				break;
+			case ops.setWordSpacing:
+				s.wordSpacing = Number(args[0]);
+				break;
+			case ops.setHScale:
+				s.hScale = Number(args[0]) / 100;
+				break;
+			case ops.setTextRise:
+				s.rise = Number(args[0]);
+				break;
+			case ops.showText: show(args[0]);
+		}
+	}
+	return out;
+}
+//#endregion
 //#region src/pdfjs/load.ts
 const REQUIRED = [
 	"worker",
@@ -1792,6 +2058,7 @@ function isProduction() {
 }
 //#endregion
 //#region src/model/annotations/history.ts
+const noop = () => {};
 /**
 * Snapshot-based undo and redo over an uncontrolled store.
 *
@@ -1811,6 +2078,8 @@ function createHistory(store, opts = {}) {
 		batch(fn) {
 			fn();
 		},
+		track: () => noop,
+		react: () => noop,
 		destroy() {}
 	};
 	const limit = opts.limit ?? 200;
@@ -1818,14 +2087,84 @@ function createHistory(store, opts = {}) {
 	const redoStack = [];
 	let previous = store.list.get();
 	let replaying = false;
-	/** Open batch depth; while above zero, changes update `previous` but push no entry. */
+	/**
+	* Open step depth (batches, and an edit while its reactions run); while above zero, changes
+	* update the baselines but push no entry.
+	*/
 	let depth = 0;
-	/** The list when the outermost batch opened (or was restarted by a replace). */
-	let batchStart = null;
+	/** The lists when the outermost step opened (or were restarted by a replace). */
+	let start = null;
+	/** Each tracked store with its list as of the last change history saw. */
+	const tracked = /* @__PURE__ */ new Map();
+	const reactions = /* @__PURE__ */ new Set();
 	const sync = () => {
 		canUndo.set(undoStack.length > 0);
 		canRedo.set(redoStack.length > 0);
 	};
+	const push = (entry) => {
+		undoStack.push(entry);
+		if (undoStack.length > limit) undoStack.shift();
+		redoStack.length = 0;
+		sync();
+	};
+	/**
+	* Forgets `recordStore`'s records in every entry, so undo and redo leave it alone. An entry
+	* left with nothing to replay (no annotation change, no other store) is dropped.
+	*/
+	const dropEntries = (recordStore) => {
+		for (const stack of [undoStack, redoStack]) {
+			const kept = stack.filter((entry) => {
+				if (!entry.records.delete(recordStore)) return true;
+				const { before, after } = entry.annotations;
+				return entry.records.size > 0 || !sameList(before, after);
+			});
+			stack.splice(0, stack.length, ...kept);
+		}
+		sync();
+	};
+	const resetStacks = () => {
+		undoStack.length = 0;
+		redoStack.length = 0;
+		sync();
+	};
+	/** Opens the outermost step from `annotations` and every tracked store's baseline. */
+	const open = (annotations) => {
+		const records = /* @__PURE__ */ new Map();
+		for (const [s, t] of tracked) records.set(s, t.previous);
+		start = {
+			annotations,
+			records
+		};
+	};
+	/**
+	* Closes the outermost step: one entry for everything that changed since it opened. A step
+	* whose lists end where they began (the same objects in the same order) records nothing.
+	*/
+	const close = () => {
+		const from = start;
+		start = null;
+		if (!from) return;
+		const annotations = {
+			before: from.annotations,
+			after: store.list.get()
+		};
+		previous = annotations.after;
+		const records = /* @__PURE__ */ new Map();
+		for (const [s, t] of tracked) {
+			const before = from.records.get(s) ?? t.previous;
+			const after = s.list.get();
+			t.previous = after;
+			if (!sameList(before, after)) records.set(s, {
+				before,
+				after
+			});
+		}
+		if (records.size === 0 && sameList(annotations.before, annotations.after)) return;
+		push({
+			annotations,
+			records
+		});
+	};
 	let destroyed = false;
 	const unsubscribe = store.on("change", (change) => {
 		const current = store.list.get();
@@ -1838,39 +2177,40 @@ function createHistory(store, opts = {}) {
 				const f = change.fields.get(a.id);
 				return f && withEmbeddedFields(a, f) || a;
 			});
-			for (const entry of [...undoStack, ...redoStack]) {
-				entry.before = fill(entry.before);
-				entry.after = fill(entry.after);
+			for (const { annotations } of [...undoStack, ...redoStack]) {
+				annotations.before = fill(annotations.before);
+				annotations.after = fill(annotations.after);
 			}
-			if (batchStart) batchStart = fill(batchStart);
+			if (start) start.annotations = fill(start.annotations);
 			previous = current;
 			return;
 		}
 		if (change.kind === "replace") {
-			undoStack.length = 0;
-			redoStack.length = 0;
 			previous = current;
-			if (depth > 0) batchStart = current;
-			sync();
+			if (depth > 0) open(current);
+			resetStacks();
 			return;
 		}
 		if (depth > 0) {
 			previous = current;
+			for (const fn of [...reactions]) fn(change);
 			return;
 		}
-		undoStack.push({
-			before: previous,
-			after: current
-		});
-		if (undoStack.length > limit) undoStack.shift();
-		redoStack.length = 0;
-		previous = current;
-		sync();
+		open(previous);
+		depth++;
+		try {
+			for (const fn of [...reactions]) fn(change);
+		} finally {
+			if (--depth === 0 && !destroyed) close();
+		}
 	});
-	const apply = (list) => {
+	/** Replays a step's lists under the `replaying` guard, skipping stores no longer tracked. */
+	const apply = (entry, side) => {
 		replaying = true;
 		try {
-			store.replaceAll([...list], "history");
+			const { annotations } = entry;
+			if (!sameList(annotations.before, annotations.after)) store.replaceAll([...annotations[side]], "history");
+			for (const [s, snapshot] of entry.records) if (tracked.has(s)) s.replaceAll([...snapshot[side]], "history");
 		} finally {
 			replaying = false;
 		}
@@ -1882,14 +2222,14 @@ function createHistory(store, opts = {}) {
 			const entry = undoStack.pop();
 			if (destroyed || !entry) return;
 			redoStack.push(entry);
-			apply(entry.before);
+			apply(entry, "before");
 			sync();
 		},
 		redo() {
 			const entry = redoStack.pop();
 			if (destroyed || !entry) return;
 			undoStack.push(entry);
-			apply(entry.after);
+			apply(entry, "after");
 			sync();
 		},
 		batch(fn) {
@@ -1897,45 +2237,78 @@ function createHistory(store, opts = {}) {
 				fn();
 				return;
 			}
-			if (depth++ === 0) batchStart = store.list.get();
+			if (depth++ === 0) open(store.list.get());
 			try {
 				const result = fn();
 				if (result !== null && typeof result === "object" && typeof result.then === "function" && !isProduction()) console.warn("[inkbar] history.batch(fn): fn returned a promise. Changes after its first await are not part of the batch.");
 			} finally {
-				if (--depth === 0 && !destroyed) {
-					const before = batchStart;
-					batchStart = null;
-					const after = store.list.get();
-					if (before && !sameAnnotations(before, after)) {
-						undoStack.push({
-							before,
-							after
-						});
-						if (undoStack.length > limit) undoStack.shift();
-						redoStack.length = 0;
-						sync();
-					}
-				}
+				if (--depth === 0 && !destroyed) close();
 			}
 		},
+		track(recordStore) {
+			if (destroyed || tracked.has(recordStore)) return noop;
+			const unsubscribeStore = recordStore.on("change", (change) => {
+				const t = tracked.get(recordStore);
+				if (!t) return;
+				const before = t.previous;
+				const current = recordStore.list.get();
+				t.previous = current;
+				if (replaying || change.kind === "replace" && change.reason === "history") return;
+				if (change.kind === "replace") {
+					if (depth > 0 && start) start.records.set(recordStore, current);
+					dropEntries(recordStore);
+					return;
+				}
+				if (depth > 0) return;
+				push({
+					annotations: {
+						before: previous,
+						after: previous
+					},
+					records: /* @__PURE__ */ new Map([[recordStore, {
+						before,
+						after: current
+					}]])
+				});
+			});
+			tracked.set(recordStore, {
+				previous: recordStore.list.get(),
+				unsubscribe: unsubscribeStore
+			});
+			if (start) start.records.set(recordStore, recordStore.list.get());
+			return () => {
+				if (tracked.get(recordStore)?.unsubscribe !== unsubscribeStore) return;
+				unsubscribeStore();
+				tracked.delete(recordStore);
+				start?.records.delete(recordStore);
+			};
+		},
+		react(fn) {
+			if (destroyed) return noop;
+			const run = (edit) => fn(edit);
+			reactions.add(run);
+			return () => {
+				reactions.delete(run);
+			};
+		},
 		destroy() {
 			destroyed = true;
-			batchStart = null;
+			start = null;
 			unsubscribe();
-			undoStack.length = 0;
-			redoStack.length = 0;
-			sync();
+			for (const t of tracked.values()) t.unsubscribe();
+			tracked.clear();
+			reactions.clear();
+			resetStacks();
 		},
 		clear() {
-			undoStack.length = 0;
-			redoStack.length = 0;
 			previous = store.list.get();
-			sync();
+			for (const [s, t] of tracked) t.previous = s.list.get();
+			resetStacks();
 		}
 	};
 }
-/** The same annotation objects in the same order. */
-function sameAnnotations(a, b) {
+/** The same objects in the same order. */
+function sameList(a, b) {
 	return a === b || a.length === b.length && a.every((x, i) => x === b[i]);
 }
 //#endregion
@@ -2382,6 +2755,7 @@ function createAnnotationStore(opts) {
 		console.warn(`[inkbar] ControlledMutationIgnored: the host did not apply a ${entry.change.kind} for annotation ${entry.id}. In controlled mode, pass the list from onChange back into the store.`);
 	}
 	function commit(next, change) {
+		if (change.kind !== "replace") emitter.emit("edit", change);
 		if (controlled) {
 			if (change.kind !== "replace") {
 				const key = changeKey(change);
@@ -2480,6 +2854,7 @@ function createAnnotationStore(opts) {
 				after
 			};
 			if (controlled && before.source === "pdf") {
+				emitter.emit("edit", change);
 				list.set(swap(list.get()));
 				if (proposed) proposed = next;
 				emitter.emit("change", change);
@@ -2578,6 +2953,30 @@ function createAnnotationStore(opts) {
 	};
 }
 //#endregion
+//#region src/model/measure-char.ts
+/**
+* Measures characters on an offscreen canvas in the font family PDF.js reports for a run, the
+* same family its text layer measures with. Undefined where there is no canvas (Node), so text
+* items carry no advances there. Widths are cached per family and character.
+*/
+function canvasMeasureChar() {
+	if (typeof OffscreenCanvas === "undefined") return void 0;
+	const ctx = new OffscreenCanvas(1, 1).getContext("2d");
+	if (!ctx) return void 0;
+	const cache = /* @__PURE__ */ new Map();
+	return (char, family) => {
+		let widths = cache.get(family);
+		if (!widths) cache.set(family, widths = /* @__PURE__ */ new Map());
+		let w = widths.get(char);
+		if (w === void 0) {
+			ctx.font = `100px ${family}`;
+			w = ctx.measureText(char).width;
+			widths.set(char, w);
+		}
+		return w;
+	};
+}
+//#endregion
 //#region src/model/page-cache.ts
 function createPageCache(fetch) {
 	const cache = /* @__PURE__ */ new Map();
@@ -2618,6 +3017,235 @@ function pageInfoFromProxy(page, index) {
 function normaliseRotation(rotate) {
 	return (Math.round(rotate / 90) * 90 % 360 + 360) % 360;
 }
+/** How far off the baseline, as a fraction of the font size, an item can sit and still share the line. */
+const SAME_LINE = .5;
+const FOLD = {};
+for (const c of "‘’‚‛") FOLD[c] = "'";
+for (const c of "“”„‟") FOLD[c] = "\"";
+for (const c of "‐‑‒–—―") FOLD[c] = "-";
+/** A line ending in one of these joins to the next line's word: hyphen, U+2010, U+2011, soft hyphen. */
+const JOINING_HYPHENS = /* @__PURE__ */ new Set([
+	"-",
+	"‐",
+	"‑",
+	"­"
+]);
+const MARKS = /\p{M}/gu;
+const WHITESPACE = /^\s$/u;
+/** Sticky: set `lastIndex` to test the code point at that index without slicing. */
+const LETTER_AT = /\p{L}/uy;
+/** One code point to its normalised form: NFKD, marks stripped, quotes and dashes folded. */
+function fold(ch) {
+	const out = ch.normalize("NFKD").replace(MARKS, "");
+	let s = "";
+	for (const c of out) s += FOLD[c] ?? c;
+	return s;
+}
+function letterAt(s, i) {
+	LETTER_AT.lastIndex = i;
+	return LETTER_AT.test(s);
+}
+const isSpace = (ch) => ch !== void 0 && WHITESPACE.test(ch);
+function lineGap(prev, next) {
+	const dx = prev.quad.p4.x - prev.quad.p3.x;
+	const dy = prev.quad.p4.y - prev.quad.p3.y;
+	const len = Math.hypot(dx, dy);
+	const ux = len === 0 ? 1 : dx / len;
+	const uy = len === 0 ? 0 : dy / len;
+	const rtl = prev.dir === "rtl" && next.dir === "rtl";
+	const from = rtl ? next.quad.p4 : prev.quad.p4;
+	const to = rtl ? prev.quad.p3 : next.quad.p3;
+	const sx = to.x - from.x;
+	const sy = to.y - from.y;
+	const size = Math.max(prev.fontSize, next.fontSize);
+	return {
+		gap: sx * ux + sy * uy,
+		sameLine: Math.abs(sx * -uy + sy * ux) <= SAME_LINE * size
+	};
+}
+/**
+* Joins a page's items the way the page reads: in content order with nothing between them,
+* a space after an item that ends its line, and a space where two items on a line sit further
+* apart than `GAP_SPACE` of the font size. Neither adds a space next to whitespace already there.
+*/
+function searchableText(content) {
+	const chars = [];
+	const item = [];
+	const offset = [];
+	const eolSpace = /* @__PURE__ */ new Set();
+	let prev;
+	const space = (eol) => {
+		if (eol) eolSpace.add(chars.length);
+		chars.push(" ");
+		item.push(-1);
+		offset.push(-1);
+	};
+	content.items.forEach((it, i) => {
+		if (it.str === "") {
+			if (it.hasEOL && chars.length > 0 && !isSpace(chars[chars.length - 1])) space(true);
+			return;
+		}
+		if (prev && chars.length > 0 && !isSpace(chars[chars.length - 1])) {
+			const { gap, sameLine } = lineGap(prev, it);
+			const size = Math.max(prev.fontSize, it.fontSize);
+			if (!isSpace(it.str[0]) && (!sameLine || gap > .15 * size)) space(false);
+		}
+		for (let k = 0; k < it.str.length; k++) {
+			chars.push(it.str[k]);
+			item.push(i);
+			offset.push(k);
+		}
+		if (it.hasEOL && !isSpace(it.str[it.str.length - 1])) space(true);
+		prev = it;
+	});
+	const raw = chars.join("");
+	let norm = "";
+	const map = [];
+	for (let r = 0; r < raw.length;) {
+		const ch = String.fromCodePoint(raw.codePointAt(r));
+		if (JOINING_HYPHENS.has(ch) && eolSpace.has(r + 1) && letterAt(raw, r + 2)) {
+			r += 2;
+			continue;
+		}
+		for (const c of fold(ch)) {
+			const out = isSpace(c) ? " " : c;
+			if (out === " " && norm.endsWith(" ")) continue;
+			norm += out;
+			for (let u = 0; u < out.length; u++) map.push(r);
+		}
+		r += ch.length;
+	}
+	map.push(raw.length);
+	const normToRaw = Int32Array.from(map);
+	return {
+		page: content.page,
+		raw,
+		norm,
+		normToRaw,
+		rawToItem: Int32Array.from(item),
+		rawToOffset: Int32Array.from(offset),
+		content
+	};
+}
+/** Folds a query the way `norm` is folded; case is lowered here only when the match ignores it. */
+function normalizeQuery(query, matchCase) {
+	let out = "";
+	for (const ch of query) out += fold(ch);
+	out = out.replace(/\s+/gu, " ");
+	return matchCase ? out : out.toLowerCase();
+}
+/** Whether `query` folds to nothing but whitespace, which a search treats as no query at all. */
+function isBlankQuery(query) {
+	return normalizeQuery(query, true).trim() === "";
+}
+const WORD_BEFORE = /[\p{L}\p{N}_]$/u;
+const WORD_AFTER = /^[\p{L}\p{N}_]/u;
+const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** Match ranges `[start, end)` into `norm`, in order and without overlap. */
+function normRanges(norm, query, matchCase) {
+	const out = [];
+	if (typeof query === "string") {
+		if (isBlankQuery(query)) return out;
+		const needle = normalizeQuery(query, true);
+		const haystack = matchCase ? norm : norm.toLowerCase();
+		const target = matchCase ? needle : needle.toLowerCase();
+		if (haystack.length === norm.length && target.length === needle.length) {
+			for (let at = haystack.indexOf(target); at !== -1; at = haystack.indexOf(target, at + target.length)) out.push([at, at + target.length]);
+			return out;
+		}
+		return regexRanges(norm, new RegExp(escapeRegExp(needle), "giu"));
+	}
+	const flags = query.flags.replace(/[gy]/g, "") + "g";
+	return regexRanges(norm, new RegExp(query.source, flags));
+}
+function regexRanges(norm, re) {
+	const out = [];
+	const unicode = re.unicode || re.flags.includes("v");
+	for (let m = re.exec(norm); m; m = re.exec(norm)) {
+		if (m[0] !== "") {
+			out.push([m.index, m.index + m[0].length]);
+			continue;
+		}
+		re.lastIndex = m.index + (unicode && norm.codePointAt(m.index) > 65535 ? 2 : 1);
+	}
+	return out;
+}
+const lerp = (a, b, t) => ({
+	x: a.x + (b.x - a.x) * t,
+	y: a.y + (b.y - a.y) * t
+});
+/**
+* The part of an item's quad from character `a` to `b`, cut along its baseline at the item's
+* `advances`, or at an equal share per character when it has none. With advances it spans every
+* boundary from `a` to `b` and the end of every glyph in between, so glyphs the pen drew out of
+* order, or that kerning overlaps with the next one, stay inside it.
+*/
+function cutQuad(it, a, b) {
+	const q = it.quad;
+	const len = it.str.length;
+	const span = it.advances?.slice(a, b + 1);
+	const ends = it.glyphEnds?.slice(a, b) ?? [];
+	const t0 = span ? Math.min(...span) : a / len;
+	const t1 = span ? Math.max(...span, ...ends) : b / len;
+	return {
+		p1: lerp(q.p1, q.p2, t0),
+		p2: lerp(q.p1, q.p2, t1),
+		p3: lerp(q.p3, q.p4, t0),
+		p4: lerp(q.p3, q.p4, t1)
+	};
+}
+function quadsFor(st, start, end) {
+	const spans = /* @__PURE__ */ new Map();
+	for (let r = start; r < end; r++) {
+		const i = st.rawToItem[r];
+		if (i < 0) continue;
+		const k = st.rawToOffset[r];
+		const span = spans.get(i);
+		if (span) {
+			span[0] = Math.min(span[0], k);
+			span[1] = Math.max(span[1], k + 1);
+		} else spans.set(i, [k, k + 1]);
+	}
+	const quads = [];
+	let exact = true;
+	for (const [i, [a, b]] of spans) {
+		const it = st.content.items[i];
+		quads.push(cutQuad(it, a, b));
+		if (!it.glyphEnds) exact = false;
+	}
+	return {
+		quads,
+		exact
+	};
+}
+const collapse = (s) => s.replace(/\s+/gu, " ");
+/** Every hit for `query` on one page, in page order. */
+function matchPage(st, query, opts) {
+	const hits = [];
+	for (const [ns, ne] of normRanges(st.norm, query, opts.matchCase)) {
+		if (opts.wholeWord) {
+			if (WORD_BEFORE.test(st.norm.slice(Math.max(0, ns - 2), ns))) continue;
+			if (WORD_AFTER.test(st.norm.slice(ne, ne + 2))) continue;
+		}
+		const start = st.normToRaw[ns];
+		const last = st.normToRaw[ne - 1];
+		const end = last + (st.raw.codePointAt(last) > 65535 ? 2 : 1);
+		const { quads, exact } = quadsFor(st, start, end);
+		if (quads.length === 0) continue;
+		hits.push({
+			page: st.page,
+			start,
+			end,
+			text: st.raw.slice(start, end),
+			quads,
+			rect: rectFromQuads(quads),
+			exact,
+			before: collapse(st.raw.slice(Math.max(0, start - 40), start)),
+			after: collapse(st.raw.slice(end, end + 40))
+		});
+	}
+	return hits;
+}
 //#endregion
 //#region src/model/source.ts
 function resolveSource(src, fetchImpl = globalThis.fetch) {
@@ -2679,6 +3307,82 @@ async function fetchBytes(url, fetchImpl) {
 	}
 }
 //#endregion
+//#region src/model/glyph-advances.ts
+/** How many glyphs past the last match to look for the start of the next item first. */
+const LOOKAHEAD = 256;
+/** How far, as a fraction of the font size, a glyph may start from the item origin and still match. */
+const START_SLACK = .05;
+/** How far off the baseline, as a fraction of the font size, a glyph may sit (text rise). */
+const RISE_SLACK = 1;
+/**
+* Each item's character boundaries as fractions of its width (see `TextItem.advances`), from the
+* glyphs that drew it. PDF.js builds text items from the same glyphs in the same order. An item
+* matches a glyph sequence that spells its text and whose first glyph starts at the item's origin.
+* Boundaries are where the pen put each glyph, projected onto the item's baseline, so they hold
+* through moves, scaling and spacing inside an item, and may run past 1 when PDF.js reports a
+* width shorter than the glyphs it drew. An item that cannot be matched, or that runs right to
+* left or top to bottom, gets undefined.
+*/
+function glyphAdvances(runs, glyphs) {
+	let next = 0;
+	return runs.map((run) => {
+		if (run.dir !== "ltr" || run.str.trim() === "" || !(run.width > 0)) return void 0;
+		const tryFrom = (from, to) => {
+			for (let start = from; start < to; start++) {
+				const m = matchRun(run, glyphs, start);
+				if (m) return m;
+			}
+		};
+		const m = tryFrom(next, Math.min(glyphs.length, next + LOOKAHEAD)) ?? tryFrom(0, glyphs.length);
+		if (!m) return void 0;
+		next = m.next;
+		return m.bounds;
+	});
+}
+/** The text a glyph's text stands for in PDF.js text content, which expands ligatures. */
+function variants(text) {
+	const n = text.normalize("NFKC");
+	return n === text ? [text] : [text, n];
+}
+/** A glyph the item may leave out: a space, or a character that draws nothing. */
+const skippable = (text) => /^[\s\p{Cf}]*$/u.test(text);
+function matchRun(run, glyphs, start) {
+	const { str, origin, along, width, fontSize } = run;
+	const t = (p) => ((p.x - origin.x) * along.x + (p.y - origin.y) * along.y) / width;
+	const off = (p) => Math.abs((p.x - origin.x) * along.y - (p.y - origin.y) * along.x);
+	const first = glyphs[start];
+	if (!first || Math.abs(t(first.start) * width) > START_SLACK * fontSize || off(first.start) > RISE_SLACK * fontSize) return void 0;
+	const bounds = [];
+	const ends = [];
+	let end = 0;
+	let g = start;
+	while (bounds.length < str.length) {
+		const glyph = glyphs[g];
+		const at = bounds.length;
+		const text = glyph && variants(glyph.text).find((v) => v !== "" && str.startsWith(v, at));
+		if (glyph && text) {
+			const t0 = t(glyph.start);
+			end = t(glyph.end);
+			for (let k = 0; k < text.length; k++) {
+				bounds.push(t0 + (end - t0) * k / text.length);
+				ends.push(t0 + (end - t0) * (k + 1) / text.length);
+			}
+			g++;
+		} else if (at > 0 && /\s/u.test(str[at])) {
+			bounds.push(end);
+			ends.push(end);
+		} else if (at > 0 && glyph && skippable(glyph.text)) g++;
+		else return void 0;
+	}
+	return {
+		bounds: {
+			advances: [...bounds, end],
+			ends
+		},
+		next: g
+	};
+}
+//#endregion
 //#region src/model/text.ts
 /** Fractions of the font size used when PDF.js has no usable metrics for the font. */
 const FALLBACK_ASCENT = .75;
@@ -2696,8 +3400,10 @@ const FALLBACK_DESCENT = .25;
 * So p3 = (e, f) - v * descent * fontSize, p4 = p3 + u * width, p1 = p3 + v * (ascent + descent) * fontSize,
 * p2 = p4 + (p1 - p3). `rect` is the axis-aligned bounding box of the quad.
 */
-function textContentFromPdfjs(page, tc) {
+function textContentFromPdfjs(page, tc, measure, glyphs) {
 	const items = [];
+	const runs = [];
+	const families = [];
 	for (const raw of tc.items) {
 		if (!("str" in raw)) continue;
 		const item = raw;
@@ -2742,21 +3448,61 @@ function textContentFromPdfjs(page, tc) {
 			p3,
 			p4
 		};
+		const dir = isDir(item.dir) ? item.dir : "ltr";
 		items.push({
 			str: item.str,
-			dir: isDir(item.dir) ? item.dir : "ltr",
+			dir,
 			fontName: item.fontName,
 			fontSize,
 			hasEOL: item.hasEOL,
 			quad,
 			rect: rectFromQuad(quad)
 		});
+		runs.push({
+			str: item.str,
+			dir,
+			fontSize,
+			origin: {
+				x: e,
+				y: f
+			},
+			along: u,
+			width: w
+		});
+		families.push(tc.styles[item.fontName]?.fontFamily ?? "sans-serif");
 	}
+	const exact = glyphs ? glyphAdvances(runs, glyphs) : [];
+	items.forEach((it, i) => {
+		const bounds = exact[i];
+		if (bounds) {
+			it.advances = bounds.advances;
+			it.glyphEnds = bounds.ends;
+		} else if (measure && it.dir === "ltr") {
+			const advances = advancesOf(it.str, families[i], measure);
+			if (advances) it.advances = advances;
+		}
+	});
 	return {
 		page,
 		items
 	};
 }
+/** Each character boundary of `str` as a fraction of its measured width, or undefined if it measures 0. */
+function advancesOf(str, family, measure) {
+	const ends = [0];
+	let sum = 0;
+	for (let i = 0; i < str.length; i++) {
+		const cp = str.codePointAt(i);
+		if (cp > 65535) {
+			sum += measure(String.fromCodePoint(cp), family);
+			ends.push(sum);
+			i++;
+		} else sum += measure(str[i], family);
+		ends.push(sum);
+	}
+	if (!(sum > 0)) return void 0;
+	return ends.map((e) => e / sum);
+}
 function metrics(style) {
 	if (!style || style.vertical) return {
 		ascent: FALLBACK_ASCENT,
@@ -2795,6 +3541,7 @@ async function openDocument(source, options) {
 	let pageCache;
 	let destroyed = false;
 	let handles;
+	const measure = canvasMeasureChar();
 	let destroyTask;
 	const store = createAnnotationStore({
 		mode: options.annotations ?? { mode: "uncontrolled" },
@@ -2868,16 +3615,93 @@ async function openDocument(source, options) {
 			if (!destroyed && patched.size > 0) store._patchEmbedded(patched);
 		}).catch(() => void 0);
 	}, () => void 0);
-	return {
+	/**
+	* A page's text with item boundaries measured or, with `glyphs`, taken from where the page
+	* draws each glyph. Reading the glyphs means reading the page's drawing commands, which also
+	* decodes its images, so search does it only for pages with hits.
+	*/
+	async function pageContent(page, glyphs) {
+		if (destroyed) throw destroyedError();
+		if (!handles) throw statusError(status.get());
+		const p = await handles.getPage(page);
+		const tc = await p.getTextContent();
+		const placed = glyphs && tc.items.length > 0 ? await pageGlyphs(p, handles.module).catch(() => void 0) : void 0;
+		return textContentFromPdfjs(page, tc, measure, placed);
+	}
+	/** Each page's searchable text, and whether its boundaries come from the page's glyphs. */
+	const searchable = /* @__PURE__ */ new Map();
+	const abortError = (signal) => signal?.reason ?? new DOMException("Aborted", "AbortError");
+	const searchableFor = (page, placed) => {
+		let cached = searchable.get(page);
+		if (!cached) cached = pageContent(page, placed).then((c) => ({
+			st: searchableText(c),
+			placed
+		}));
+		else if (placed) cached = cached.then((c) => c.placed ? c : pageContent(page, true).then((pc) => ({
+			st: searchableText(pc),
+			placed: true
+		})));
+		else return cached.then((c) => c.st);
+		const entry = cached;
+		searchable.set(page, entry);
+		entry.catch(() => {
+			if (searchable.get(page) === entry) searchable.delete(page);
+		});
+		return entry.then((c) => c.st);
+	};
+	async function* scan(query, opts) {
+		const { signal } = opts;
+		const matchOpts = {
+			matchCase: opts.matchCase ?? false,
+			wholeWord: opts.wholeWord ?? false
+		};
+		const order = opts.pages ?? Array.from({ length: pages.length }, (_, i) => i);
+		const check = () => {
+			if (signal?.aborted || destroyed) throw abortError(signal);
+		};
+		check();
+		for (let n = 0; n < order.length; n++) {
+			if (n > 0) await new Promise((r) => setTimeout(r));
+			check();
+			let hits;
+			try {
+				hits = matchPage(await searchableFor(order[n], false), query, matchOpts);
+				if (hits.length > 0) {
+					check();
+					hits = matchPage(await searchableFor(order[n], true), query, matchOpts);
+				}
+			} catch (error) {
+				check();
+				throw error;
+			}
+			check();
+			for (const hit of hits) {
+				yield hit;
+				check();
+			}
+		}
+	}
+	const doc = {
 		key: resolved.key,
 		status: readonly(status),
 		ready,
 		pages,
 		info,
-		async text(page) {
-			if (destroyed) throw destroyedError();
-			if (!handles) throw statusError(status.get());
-			return textContentFromPdfjs(page, await (await handles.getPage(page)).getTextContent());
+		text(page) {
+			return pageContent(page, true);
+		},
+		async pageText(page) {
+			return searchableText(await doc.text(page)).raw;
+		},
+		search(query, opts = {}) {
+			return {
+				[Symbol.asyncIterator]: () => scan(query, opts),
+				async all() {
+					const hits = [];
+					for await (const hit of scan(query, opts)) hits.push(hit);
+					return hits;
+				}
+			};
 		},
 		annotations: store,
 		embedded,
@@ -2901,6 +3725,7 @@ async function openDocument(source, options) {
 			history.destroy();
 			store.destroy();
 			pageCache?.clear();
+			searchable.clear();
 			if (destroyTask) teardown(destroyTask);
 		},
 		get _pdfjs() {
@@ -2908,6 +3733,7 @@ async function openDocument(source, options) {
 			return handles;
 		}
 	};
+	return doc;
 }
 const EMBEDDED_CONCURRENCY = 8;
 /** Runs `task(0..count-1)` with at most `limit` in flight; results come back in index order. */
@@ -4707,6 +5533,6 @@ function createSignatureLibrary(store) {
 	};
 }
 //#endregion
-export { importAnnotations as $, readonly as $t, styleGroupOf as A, RectSchema as At, isTextMarkup as B, withCalloutBounds as Bt, repliesTo as C, NoteIconSchema as Ct, STYLE_GROUPS as D, PolygonSchema as Dt, withoutReplies as E, PolySchema as Et, typesInGroup as F, TextMarkupSchema as Ft, resizedRect as G, isKnown as Gt, movedEndpoint as H, LINE_ENDINGS as Ht, hasCallout as I, FringeSchema as It, withBox as J, cssVariableDefaults as Jt, scaled as K, pdfNameSet as Kt, hasCornerHandles as L, calloutStroke as Lt, styleGroupsOf as M, ShapeSchema as Mt, supportedProps as N, SquareSchema as Nt, createToolStyle as O, PolylineSchema as Ot, toFields as P, StampSchema as Pt, exportAnnotations as Q, derived as Qt, hasRectGeometry as R, freeTextBox as Rt, isThreadRoot as S, MaskSchema as St, threadRoot as T, PointSchema as Tt, movedTip as U, NOTE_ICONS as Ut, keepsAspect as V, INTENTS as Vt, resizedBox as W, PDF_NAME$1 as Wt, createAnnotationStore as X, staticDefaults as Xt, openDocument as Y, normalizeColor as Yt, deriveRect as Z, mergeLineRects as Zt, defaultEnds as _, isInkError as _n, IMAGE_DATA_URL as _t, createLocalSignatureStore as a, pointsFromFlat as an, pdfColorToHex as at, isAbandonedNote as b, LineSchema as bt, normaliseInk as c, rectContainsPoint as cn, AnnotationSchema as ct, recogniseStroke as d, rectsIntersect as dn, FreeTextSchema as dt, writable as en, createHistory as et, DEFAULT_CORNER_RADIUS as f, translateQuad as fn, FreeTextStyleSchema as ft, constrain as g, InkError as gn, GLOSS_VERSION$1 as gt, SHAPE_KINDS as h, Emitter as hn, GLOSS_SCHEMA_ID as ht, createInkTemplate as i, multiplyMatrix as in, importedId as it, styleGroupOfType as j, RedactSchema as jt, fromAnnotation as k, QuadSchema as kt, placeSignature as l, rectFromPoints as ln, CircleSchema as lt, DEFAULT_SHAPE_SIZE as m, unionRects as mn, GLOSS_MEDIA_TYPE as mt, SIGNATURE_INK_WIDTH as n, approxEqual as nn, SUPPORTED_SUBTYPES as nt, createMemorySignatureStore as o, quadFromRect as on, summarise as ot, DEFAULT_SHAPE_OPTIONS as p, translateRect as pn, GLOSS_FORMAT$1 as pt, translated as q, parsePdfDate as qt, createImageTemplate as r, invertMatrix as rn, importEmbeddedPage as rt, createSignatureLibrary as s, quadsFromFlat as sn, AnnotationDocumentSchema as st, DEFAULT_SIGNATURE_WIDTH as t, applyMatrix as tn, isProduction as tt, RECOGNISE_THRESHOLD as u, rectFromQuad as un, ExportedAnnotationSchema as ut, isPointerOnlyKind as v, InkSchema as vt, threadOf as w, NoteSchema as wt, isReply as x, LoupeSchema as xt, shapeInput as y, LineEndingSchema as yt, isBubble as z, isStandardCallout as zt };
+export { exportAnnotations as $, createRecordStore as $t, styleGroupOf as A, QuadSchema as At, isTextMarkup as B, isStandardCallout as Bt, repliesTo as C, MaskSchema as Ct, STYLE_GROUPS as D, PolySchema as Dt, withoutReplies as E, PointSchema as Et, typesInGroup as F, StampSchema as Ft, resizedRect as G, PDF_NAME$1 as Gt, movedEndpoint as H, INTENTS as Ht, hasCallout as I, TextMarkupSchema as It, withBox as J, parsePdfDate as Jt, scaled as K, isKnown as Kt, hasCornerHandles as L, FringeSchema as Lt, styleGroupsOf as M, RedactSchema as Mt, supportedProps as N, ShapeSchema as Nt, createToolStyle as O, PolygonSchema as Ot, toFields as P, SquareSchema as Pt, deriveRect as Q, mergeLineRects as Qt, hasRectGeometry as R, calloutStroke as Rt, isThreadRoot as S, LoupeSchema as St, threadRoot as T, NoteSchema as Tt, movedTip as U, LINE_ENDINGS as Ut, keepsAspect as V, withCalloutBounds as Vt, resizedBox as W, NOTE_ICONS as Wt, isBlankQuery as X, normalizeColor as Xt, openDocument as Y, cssVariableDefaults as Yt, createAnnotationStore as Z, staticDefaults as Zt, defaultEnds as _, translateRect as _n, GLOSS_VERSION$1 as _t, createLocalSignatureStore as a, invertMatrix as an, importedId as at, isAbandonedNote as b, InkError as bn, LineEndingSchema as bt, normaliseInk as c, quadFromRect as cn, AnnotationDocumentSchema as ct, recogniseStroke as d, rectContainsPoint as dn, ExportedAnnotationSchema as dt, derived as en, importAnnotations as et, DEFAULT_CORNER_RADIUS as f, rectFromPoints as fn, FreeTextSchema as ft, constrain as g, translateQuad as gn, GLOSS_SCHEMA_ID as gt, SHAPE_KINDS as h, rectsIntersect as hn, GLOSS_MEDIA_TYPE as ht, createInkTemplate as i, approxEqual as in, importEmbeddedPage as it, styleGroupOfType as j, RectSchema as jt, fromAnnotation as k, PolylineSchema as kt, placeSignature as l, quadsFromFlat as ln, AnnotationSchema as lt, DEFAULT_SHAPE_SIZE as m, rectFromQuads as mn, GLOSS_FORMAT$1 as mt, SIGNATURE_INK_WIDTH as n, writable as nn, isProduction as nt, createMemorySignatureStore as o, multiplyMatrix as on, pdfColorToHex as ot, DEFAULT_SHAPE_OPTIONS as p, rectFromQuad as pn, FreeTextStyleSchema as pt, translated as q, pdfNameSet as qt, createImageTemplate as r, applyMatrix as rn, SUPPORTED_SUBTYPES as rt, createSignatureLibrary as s, pointsFromFlat as sn, summarise as st, DEFAULT_SIGNATURE_WIDTH as t, readonly as tn, createHistory as tt, RECOGNISE_THRESHOLD as u, quadsFromRect as un, CircleSchema as ut, isPointerOnlyKind as v, unionRects as vn, IMAGE_DATA_URL as vt, threadOf as w, NoteIconSchema as wt, isReply as x, isInkError as xn, LineSchema as xt, shapeInput as y, Emitter as yn, InkSchema as yt, isBubble as z, freeTextBox as zt };
 
-//# sourceMappingURL=signatures-CMapTKrC.mjs.map
+//# sourceMappingURL=signatures-Do_l2IlM.mjs.map