@inkbar/core 0.6.0 → 0.7.0

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

@@ -410,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",
@@ -2792,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();
@@ -2832,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) {
@@ -2893,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;
@@ -2910,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;
@@ -2956,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,
@@ -3009,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" },
@@ -3082,19 +3615,93 @@ async function openDocument(source, options) {
 			if (!destroyed && patched.size > 0) store._patchEmbedded(patched);
 		}).catch(() => void 0);
 	}, () => void 0);
+	/**
+	* 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 (await doc.text(page)).items.map((item) => item.str).join(" ");
+			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,
@@ -3118,6 +3725,7 @@ async function openDocument(source, options) {
 			history.destroy();
 			store.destroy();
 			pageCache?.clear();
+			searchable.clear();
 			if (destroyTask) teardown(destroyTask);
 		},
 		get _pdfjs() {
@@ -4925,6 +5533,6 @@ function createSignatureLibrary(store) {
 	};
 }
 //#endregion
-export { importAnnotations as $, derived 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, createRecordStore 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 _, unionRects as _n, IMAGE_DATA_URL as _t, createLocalSignatureStore as a, multiplyMatrix as an, pdfColorToHex as at, isAbandonedNote as b, isInkError as bn, LineSchema as bt, normaliseInk as c, quadsFromFlat as cn, AnnotationSchema as ct, recogniseStroke as d, rectFromPoints as dn, FreeTextSchema as dt, readonly as en, createHistory as et, DEFAULT_CORNER_RADIUS as f, rectFromQuad as fn, FreeTextStyleSchema as ft, constrain as g, translateRect as gn, GLOSS_VERSION$1 as gt, SHAPE_KINDS as h, translateQuad as hn, GLOSS_SCHEMA_ID as ht, createInkTemplate as i, invertMatrix as in, importedId as it, styleGroupOfType as j, RedactSchema as jt, fromAnnotation as k, QuadSchema as kt, placeSignature as l, quadsFromRect as ln, CircleSchema as lt, DEFAULT_SHAPE_SIZE as m, rectsIntersect as mn, GLOSS_MEDIA_TYPE as mt, SIGNATURE_INK_WIDTH as n, applyMatrix as nn, SUPPORTED_SUBTYPES as nt, createMemorySignatureStore as o, pointsFromFlat as on, summarise as ot, DEFAULT_SHAPE_OPTIONS as p, rectFromQuads as pn, GLOSS_FORMAT$1 as pt, translated as q, parsePdfDate as qt, createImageTemplate as r, approxEqual as rn, importEmbeddedPage as rt, createSignatureLibrary as s, quadFromRect as sn, AnnotationDocumentSchema as st, DEFAULT_SIGNATURE_WIDTH as t, writable as tn, isProduction as tt, RECOGNISE_THRESHOLD as u, rectContainsPoint as un, ExportedAnnotationSchema as ut, isPointerOnlyKind as v, Emitter as vn, InkSchema as vt, threadOf as w, NoteSchema as wt, isReply as x, LoupeSchema as xt, shapeInput as y, InkError as yn, 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-D68fuLlt.mjs.map
+//# sourceMappingURL=signatures-Do_l2IlM.mjs.map