@embedpdf/engine-core 3.0.0-next.2 → 3.0.0-next.4

package/dist/{builders-BvikWRuO.cjs → builders-CBK8k_cn.cjs}

@@ -1,120 +1,5 @@
-const require_subtype = require("./subtype-qejjVr6h.cjs");
-const require_fold = require("./fold-IaMph3CO.cjs");
-//#region src/geometry/convert.ts
-/**
-* Normalize a `PdfRect` to the y-up invariant (`left <= right`, `bottom <= top`),
-* regardless of how the PDF ordered the corners (a `/Rect` array or `FS_RECTF`
-* may carry them in any order). THE enforcement point for the "PdfRect is always
-* normalized" rule: every producer that reads a raw box from PDFium passes it
-* through here, so the invariant holds once, centrally — downstream `width =
-* right - left` is never negative.
-*/
-function normalizePdfRect(r) {
-	return {
-		left: Math.min(r.left, r.right),
-		right: Math.max(r.left, r.right),
-		bottom: Math.min(r.top, r.bottom),
-		top: Math.max(r.top, r.bottom)
-	};
-}
-function pdfRectWidth(r) {
-	return r.right - r.left;
-}
-function pdfRectHeight(r) {
-	return r.top - r.bottom;
-}
-function pdfRectSize(r) {
-	return {
-		width: r.right - r.left,
-		height: r.top - r.bottom
-	};
-}
-/** Convert edges -> origin+size, staying y-up (origin at bottom-left). */
-function pdfRectToOriginSize(r) {
-	return {
-		x: r.left,
-		y: r.bottom,
-		width: r.right - r.left,
-		height: r.top - r.bottom
-	};
-}
-/** Convert y-up origin+size back to edges. */
-function pdfRectFromOriginSize(o) {
-	return {
-		left: o.x,
-		bottom: o.y,
-		right: o.x + o.width,
-		top: o.y + o.height
-	};
-}
-/**
-* Enclosing axis-aligned box of a quad, in PDF user space. Orientation
-* agnostic (correct for rotated/skewed quads) — this is what highlight
-* rendering and hit-testing want.
-*/
-function pdfQuadBounds(q) {
-	const xs = [
-		q.p1.x,
-		q.p2.x,
-		q.p3.x,
-		q.p4.x
-	];
-	const ys = [
-		q.p1.y,
-		q.p2.y,
-		q.p3.y,
-		q.p4.y
-	];
-	return {
-		left: Math.min(...xs),
-		right: Math.max(...xs),
-		bottom: Math.min(...ys),
-		top: Math.max(...ys)
-	};
-}
-/**
-* Axis-aligned named-corner interpretation of a quad.
-*
-* VALID ONLY for upright (non-rotated, non-skewed) quads: it is derived from
-* the enclosing bounds, so for rotated/skewed quads it returns the bounding
-* box corners, not the true geometric corners. For arbitrary quads use the
-* positional `p1..p4` or `pdfQuadBounds` directly.
-*/
-function pdfQuadCorners(q) {
-	const b = pdfQuadBounds(q);
-	return {
-		topLeft: {
-			x: b.left,
-			y: b.top
-		},
-		topRight: {
-			x: b.right,
-			y: b.top
-		},
-		bottomLeft: {
-			x: b.left,
-			y: b.bottom
-		},
-		bottomRight: {
-			x: b.right,
-			y: b.bottom
-		}
-	};
-}
-/**
-* Build a quad from named corners, in PDFium `FS_QUADPOINTSF` slot order
-* (`p1 = topLeft`, `p2 = topRight`, `p3 = bottomLeft`, `p4 = bottomRight`).
-* The inverse of `pdfQuadCorners` for upright quads.
-*/
-function pdfQuadFromCorners(c) {
-	return {
-		p1: c.topLeft,
-		p2: c.topRight,
-		p3: c.bottomLeft,
-		p4: c.bottomRight
-	};
-}
-//#endregion
+const require_fold = require("./fold-M6iEyY8X.cjs");
+const require_subtype = require("./subtype-C4XA7C16.cjs");
 //#region src/dto/PageRender.ts
 function createPageImageHandle(result, blobSource) {
 	return {
@@ -1007,37 +892,275 @@ function buildSnippet(text, range, context = 48) {
 	};
 }
 //#endregion
-//#region src/search/rects.ts
-/**
-* Match-range → merged line rects, in PDF user space (y-up).
-*
-* This is the same line-merge text selection uses (adapted from Chromium's
-* pdf/pdfium/pdfium_range.cc `MergeAdjacentRects`, BSD-licensed, Copyright
-* 2010 The Chromium Authors), operating directly on the engine's
-* `PageGeometrySnapshot`: glyph loose boxes → sub-runs (split on big
-* intra-run gaps) → one rect per visual line. Search highlights therefore
-* look exactly like selections — never a rect per glyph (the v2 bug).
-*
-* It lives in engine-core because BOTH sides need it: the server computes
-* rects here for `'rects'`-mode responses (geometry never leaves the trust
-* boundary), and the local engine computes them in the worker.
-*/
+//#region src/text/layout.ts
 const FLAG_EMPTY = 2;
+const isBoundary = (flags) => (flags & 3) !== 0;
+const isEmpty = (flags) => (flags & FLAG_EMPTY) !== 0;
 const CHAR_DISTANCE_FACTOR = 2.5;
 const FONT_SIZE_RATIO_THRESHOLD = 1.5;
 const VERTICAL_OVERLAP_THRESHOLD = .8;
+const LINE_OVERLAP_THRESHOLD = .5;
+/** Baseline directions within ~0.5° share a frame. */
+const FRAME_DOT_TOLERANCE = Math.cos(.0087);
+const EDGE_EPSILON = 1e-6;
+const IDENTITY_FRAME = {
+	baseline: {
+		x: 1,
+		y: 0
+	},
+	ascent: {
+		x: 0,
+		y: 1
+	}
+};
+const toFrame = (f, p) => ({
+	x: p.x * f.baseline.x + p.y * f.baseline.y,
+	y: p.x * f.ascent.x + p.y * f.ascent.y
+});
+const fromFrame = (f, p) => ({
+	x: f.baseline.x * p.x + f.ascent.x * p.y,
+	y: f.baseline.y * p.x + f.ascent.y * p.y
+});
+const ZERO_RECT = {
+	left: 0,
+	bottom: 0,
+	right: 0,
+	top: 0
+};
+/** Frame-local AABB of a page-space cell (exact under the frame's rotation;
+*  shear residue is the documented in-frame envelope). */
+function frameBoxOfQuad(f, q) {
+	const pts = [
+		q.p1,
+		q.p2,
+		q.p3,
+		q.p4
+	].map((p) => toFrame(f, p));
+	const xs = pts.map((p) => p.x);
+	const ys = pts.map((p) => p.y);
+	return {
+		left: Math.min(...xs),
+		bottom: Math.min(...ys),
+		right: Math.max(...xs),
+		top: Math.max(...ys)
+	};
+}
+/** Find-or-create the frame for a rotated run, keyed by the baseline
+*  direction + ascent handedness of its first classifiable glyph's edges. */
+function frameForRun(frames, run) {
+	const seed = run.glyphs.find((g) => !isEmpty(g.flags));
+	if (!seed) return 0;
+	const q = seed.looseQuad;
+	const bx = q.p2.x - q.p1.x;
+	const by = q.p2.y - q.p1.y;
+	const len = Math.hypot(bx, by);
+	if (len <= EDGE_EPSILON) return 0;
+	const baseline = {
+		x: bx / len,
+		y: by / len
+	};
+	const ax = q.p1.x - q.p3.x;
+	const ay = q.p1.y - q.p3.y;
+	const sign = baseline.x * ay - baseline.y * ax >= 0 ? 1 : -1;
+	const ascent = {
+		x: -baseline.y * sign,
+		y: baseline.x * sign
+	};
+	for (let i = 0; i < frames.length; i++) {
+		const f = frames[i];
+		const dot = f.baseline.x * baseline.x + f.baseline.y * baseline.y;
+		const sameHandedness = f.ascent.x * ascent.x + f.ascent.y * ascent.y > 0;
+		if (dot >= FRAME_DOT_TOLERANCE && sameHandedness) return i;
+	}
+	frames.push({
+		baseline,
+		ascent
+	});
+	return frames.length - 1;
+}
 /**
-* Merged line rects for the text-page char range
-* `[charStart, charStart + charCount)`. Ranges index the same space as
-* `PageGeometryRun.charStart`; chars outside the snapshot are ignored.
+* Flatten a page's geometry snapshot into the canonical layout. Upright runs
+* copy their wire boxes verbatim (frame 0 — byte-identical to the
+* pre-orientation behavior, wire run rects included); rotated runs project
+* their glyph cells into their cluster's frame.
 */
-function searchRectsForRange(snapshot, charStart, charCount) {
-	if (charCount <= 0) return [];
-	const lo = charStart;
-	const hi = charStart + charCount - 1;
-	const subRuns = [];
+function buildPageTextLayout(snapshot) {
+	const glyphs = [];
+	const runs = [];
+	const frames = [IDENTITY_FRAME];
 	for (const run of snapshot.runs) {
-		const runEnd = run.charStart + run.glyphs.length - 1;
+		if (!require_fold.isRotatedGeometryRun(run)) {
+			for (const g of run.glyphs) glyphs.push({
+				loose: g.looseBox,
+				tight: g.tightBox,
+				flags: g.flags
+			});
+			runs.push({
+				charStart: run.charStart,
+				count: run.glyphs.length,
+				rect: run.rect,
+				fontSize: run.fontSize,
+				frame: 0
+			});
+			continue;
+		}
+		const frame = frameForRun(frames, run);
+		const f = frames[frame];
+		let runBox = null;
+		for (const g of run.glyphs) {
+			if (isEmpty(g.flags)) {
+				glyphs.push({
+					loose: ZERO_RECT,
+					flags: g.flags
+				});
+				continue;
+			}
+			const loose = frameBoxOfQuad(f, g.looseQuad);
+			const tight = g.tightQuad ? frameBoxOfQuad(f, g.tightQuad) : void 0;
+			glyphs.push({
+				loose,
+				tight,
+				flags: g.flags
+			});
+			runBox = runBox ? {
+				left: Math.min(runBox.left, loose.left),
+				bottom: Math.min(runBox.bottom, loose.bottom),
+				right: Math.max(runBox.right, loose.right),
+				top: Math.max(runBox.top, loose.top)
+			} : loose;
+		}
+		runs.push({
+			charStart: run.charStart,
+			count: run.glyphs.length,
+			rect: runBox ?? ZERO_RECT,
+			fontSize: run.fontSize,
+			frame
+		});
+	}
+	return {
+		glyphs,
+		runs,
+		frames
+	};
+}
+const inRect = (r, p) => p.x >= r.left && p.x <= r.right && p.y >= r.bottom && p.y <= r.top;
+function avgGlyphHeight(layout) {
+	let total = 0;
+	let count = 0;
+	for (const g of layout.glyphs) {
+		if (isEmpty(g.flags)) continue;
+		total += g.loose.top - g.loose.bottom;
+		count++;
+	}
+	return count === 0 ? 0 : total / count;
+}
+/** The point expressed in every frame (index-aligned with `layout.frames`).
+*  Frame 0 returns the point itself — no float round-trip on the fast path. */
+function pointPerFrame(layout, p) {
+	return layout.frames.map((f, i) => i === 0 ? p : toFrame(f, p));
+}
+/**
+* The glyph (char) index at a page-space point, or null when nothing is near
+* (so callers can show the pointer cursor off-text). PDFium `GetIndexAtPos`:
+* exact tight-box containment first, then a tolerance pass (closest by
+* Manhattan distance within `toleranceFactor × average glyph height`). Each
+* run tests the point in ITS OWN frame, so rotated text hit-tests exactly.
+*/
+function textGlyphAt(layout, point, toleranceFactor = 1.5) {
+	const pts = pointPerFrame(layout, point);
+	for (const run of layout.runs) {
+		const q = pts[run.frame];
+		if (!inRect(run.rect, q)) continue;
+		for (let i = 0; i < run.count; i++) {
+			const g = layout.glyphs[run.charStart + i];
+			if (inRect(g.tight ?? g.loose, q)) return run.charStart + i;
+		}
+	}
+	if (toleranceFactor <= 0) return null;
+	const half = avgGlyphHeight(layout) * toleranceFactor / 2;
+	let best = -1;
+	let bestDist = Infinity;
+	for (const run of layout.runs) {
+		const q = pts[run.frame];
+		const r = run.rect;
+		if (q.x < r.left - half || q.x > r.right + half || q.y < r.bottom - half || q.y > r.top + half) continue;
+		for (let i = 0; i < run.count; i++) {
+			const g = layout.glyphs[run.charStart + i];
+			if (isEmpty(g.flags)) continue;
+			const b = g.tight ?? g.loose;
+			if (q.x < b.left - half || q.x > b.right + half || q.y < b.bottom - half || q.y > b.top + half) continue;
+			const dx = Math.min(Math.abs(q.x - b.left), Math.abs(q.x - b.right));
+			const dy = Math.min(Math.abs(q.y - b.bottom), Math.abs(q.y - b.top));
+			if (dx + dy < bestDist) {
+				bestDist = dx + dy;
+				best = run.charStart + i;
+			}
+		}
+	}
+	return best >= 0 ? best : null;
+}
+/** Double-click: the word around `glyph` (walk to space/empty glyphs both ways). */
+function expandTextRangeToWord(layout, glyph) {
+	const n = layout.glyphs.length;
+	if (glyph < 0 || glyph >= n) return [glyph, glyph];
+	let from = glyph;
+	while (from > 0 && !isBoundary(layout.glyphs[from - 1].flags)) from--;
+	let to = glyph;
+	while (to < n - 1 && !isBoundary(layout.glyphs[to + 1].flags)) to++;
+	return [from, to];
+}
+/** Triple-click: the full visual line — SAME-FRAME runs whose vertical extent
+*  overlaps the anchor run's. A differently-oriented run is a line boundary. */
+function expandTextRangeToLine(layout, glyph) {
+	const ri = layout.runs.findIndex((r) => glyph >= r.charStart && glyph < r.charStart + r.count);
+	if (ri < 0) return [glyph, glyph];
+	const anchor = layout.runs[ri];
+	const bottom = anchor.rect.bottom;
+	const top = anchor.rect.top;
+	let from = anchor.charStart;
+	let to = anchor.charStart + anchor.count - 1;
+	for (let r = ri - 1; r >= 0; r--) {
+		const run = layout.runs[r];
+		if (isZero(run.rect)) continue;
+		if (run.frame !== anchor.frame) break;
+		if (!overlapV(run.rect.bottom, run.rect.top, bottom, top)) break;
+		from = run.charStart;
+	}
+	for (let r = ri + 1; r < layout.runs.length; r++) {
+		const run = layout.runs[r];
+		if (isZero(run.rect)) continue;
+		if (run.frame !== anchor.frame) break;
+		if (!overlapV(run.rect.bottom, run.rect.top, bottom, top)) break;
+		to = run.charStart + run.count - 1;
+	}
+	return [from, to];
+}
+/**
+* A single glyph's oriented cell in page space, or null for degenerate
+* glyphs — the anchor for caret placement at a selection boundary.
+*/
+function textGlyphQuad(layout, glyph) {
+	const g = layout.glyphs[glyph];
+	if (!g || isEmpty(g.flags)) return null;
+	const b = g.loose;
+	if (b.right <= b.left || b.top <= b.bottom) return null;
+	const run = layout.runs.find((r) => glyph >= r.charStart && glyph < r.charStart + r.count);
+	const f = layout.frames[run?.frame ?? 0];
+	return quadOfFrameRect(f, run?.frame ?? 0, b);
+}
+/**
+* Merged visual-line segments for the half-open char range
+* `[charStart, charStart + charCount)` — THE canonical segmentation. Chars
+* outside the layout are ignored.
+*/
+function textSegmentsForRange(layout, charStart, charCount) {
+	if (charCount <= 0 || layout.glyphs.length === 0) return [];
+	const lo = Math.max(0, charStart);
+	const hi = Math.min(layout.glyphs.length - 1, charStart + charCount - 1);
+	if (hi < lo) return [];
+	const subRuns = [];
+	for (const run of layout.runs) {
+		const runEnd = run.charStart + run.count - 1;
 		if (runEnd < lo || run.charStart > hi) continue;
 		const s = Math.max(lo, run.charStart);
 		const e = Math.min(hi, runEnd);
@@ -1045,63 +1168,141 @@ function searchRectsForRange(snapshot, charStart, charCount) {
 		let right = -Infinity;
 		let bottom = Infinity;
 		let top = -Infinity;
-		let count = 0;
+		let charCountAcc = 0;
 		let widthSum = 0;
 		let prevRight = -Infinity;
+		let firstX = 0;
+		let lastX = 0;
 		const flush = () => {
-			if (count > 0 && right > left && top > bottom) subRuns.push({
+			if (charCountAcc > 0 && left !== Infinity) subRuns.push({
 				rect: {
 					left,
 					bottom,
 					right,
 					top
 				},
-				charCount: count,
-				fontSize: run.fontSize
+				charCount: charCountAcc,
+				fontSize: run.fontSize,
+				frame: run.frame,
+				firstX,
+				lastX
 			});
 			left = Infinity;
 			right = -Infinity;
 			bottom = Infinity;
 			top = -Infinity;
-			count = 0;
+			charCountAcc = 0;
 			widthSum = 0;
 			prevRight = -Infinity;
 		};
 		for (let ci = s; ci <= e; ci++) {
-			const g = run.glyphs[ci - run.charStart];
-			if ((g.flags & FLAG_EMPTY) !== 0) continue;
-			const b = g.looseBox;
-			if (count > 0 && prevRight > -Infinity) {
-				const avg = widthSum / count;
+			const g = layout.glyphs[ci];
+			if (isEmpty(g.flags)) continue;
+			const b = g.loose;
+			if (charCountAcc > 0 && prevRight > -Infinity) {
+				const avg = widthSum / charCountAcc;
 				if (avg > 0 && Math.abs(b.left - prevRight) > CHAR_DISTANCE_FACTOR * avg) flush();
 			}
+			const centerX = (b.left + b.right) / 2;
+			if (charCountAcc === 0) firstX = centerX;
+			lastX = centerX;
 			left = Math.min(left, b.left);
 			right = Math.max(right, b.right);
 			bottom = Math.min(bottom, b.bottom);
 			top = Math.max(top, b.top);
-			count++;
+			charCountAcc++;
 			widthSum += b.right - b.left;
 			prevRight = b.right;
 		}
 		flush();
 	}
-	return mergeAdjacentRects(subRuns);
+	return mergeAdjacentSubRuns(subRuns).map((m) => materializeSegment(layout, m));
 }
-function mergeAdjacentRects(runs) {
+function mergeAdjacentSubRuns(runs) {
 	const out = [];
 	let prev = null;
 	let cur = null;
 	for (const run of runs) {
-		if (prev && cur && shouldMerge(prev, run)) cur = union(cur, run.rect);
+		if (prev && cur && prev.frame === run.frame && shouldMerge(prev, run)) cur = {
+			rect: {
+				left: Math.min(cur.rect.left, run.rect.left),
+				bottom: Math.min(cur.rect.bottom, run.rect.bottom),
+				right: Math.max(cur.rect.right, run.rect.right),
+				top: Math.max(cur.rect.top, run.rect.top)
+			},
+			frame: cur.frame,
+			firstX: cur.firstX,
+			lastX: run.lastX
+		};
 		else {
 			if (cur) out.push(cur);
-			cur = run.rect;
+			cur = {
+				rect: run.rect,
+				frame: run.frame,
+				firstX: run.firstX,
+				lastX: run.lastX
+			};
 		}
 		prev = run;
 	}
-	if (cur) out.push(cur);
+	if (cur && cur.rect.right > cur.rect.left && cur.rect.top > cur.rect.bottom) out.push(cur);
 	return out;
 }
+/** Segment quad for a frame-local rect (frame 0: the rect's own corners,
+*  no float round-trip). Slot order US, UE, LS, LE; frame is y-up, so the
+*  upper corners sit at the frame TOP. */
+function quadOfFrameRect(f, frameIndex, r) {
+	if (frameIndex === 0) return {
+		p1: {
+			x: r.left,
+			y: r.top
+		},
+		p2: {
+			x: r.right,
+			y: r.top
+		},
+		p3: {
+			x: r.left,
+			y: r.bottom
+		},
+		p4: {
+			x: r.right,
+			y: r.bottom
+		}
+	};
+	return {
+		p1: fromFrame(f, {
+			x: r.left,
+			y: r.top
+		}),
+		p2: fromFrame(f, {
+			x: r.right,
+			y: r.top
+		}),
+		p3: fromFrame(f, {
+			x: r.left,
+			y: r.bottom
+		}),
+		p4: fromFrame(f, {
+			x: r.right,
+			y: r.bottom
+		})
+	};
+}
+function materializeSegment(layout, m) {
+	const frame = layout.frames[m.frame];
+	const quad = quadOfFrameRect(frame, m.frame, m.rect);
+	return {
+		quad,
+		rect: m.frame === 0 ? m.rect : {
+			left: Math.min(quad.p1.x, quad.p2.x, quad.p3.x, quad.p4.x),
+			bottom: Math.min(quad.p1.y, quad.p2.y, quad.p3.y, quad.p4.y),
+			right: Math.max(quad.p1.x, quad.p2.x, quad.p3.x, quad.p4.x),
+			top: Math.max(quad.p1.y, quad.p2.y, quad.p3.y, quad.p4.y)
+		},
+		advance: m.lastX >= m.firstX ? 1 : -1
+	};
+}
 function shouldMerge(a, b) {
 	if (a.fontSize != null && b.fontSize != null && a.fontSize > 0 && b.fontSize > 0) {
 		if (Math.max(a.fontSize, b.fontSize) / Math.min(a.fontSize, b.fontSize) > FONT_SIZE_RATIO_THRESHOLD) return false;
@@ -1114,14 +1315,6 @@ function shouldMerge(a, b) {
 	const bL = b.rect.left - bw;
 	return aL < b.rect.right + bw && aR > bL;
 }
-function union(a, b) {
-	return {
-		left: Math.min(a.left, b.left),
-		bottom: Math.min(a.bottom, b.bottom),
-		right: Math.max(a.right, b.right),
-		top: Math.max(a.top, b.top)
-	};
-}
 function verticalOverlap(a, b) {
 	const ah = a.top - a.bottom;
 	const bh = b.top - b.bottom;
@@ -1130,6 +1323,28 @@ function verticalOverlap(a, b) {
 	if (u === ah || u === bh) return 1;
 	return Math.max(0, Math.min(a.top, b.top) - Math.max(a.bottom, b.bottom)) / u;
 }
+const isZero = (r) => r.right === r.left && r.top === r.bottom;
+function overlapV(bottom1, top1, bottom2, top2) {
+	const u = Math.max(top1, top2) - Math.min(bottom1, bottom2);
+	if (u === 0) return false;
+	return Math.max(0, Math.min(top1, top2) - Math.max(bottom1, bottom2)) / u >= LINE_OVERLAP_THRESHOLD;
+}
+//#endregion
+//#region src/search/rects.ts
+/**
+* Match-range → canonical visual-line segments. Thin wrappers over the ONE
+* text layout (`src/text/layout.ts`) — search owns matching and cursors,
+* never segmentation, so a match highlights exactly like a selection of the
+* same characters. No frame or merge logic lives here.
+*/
+/** Canonical segments for `[charStart, charStart + charCount)`. */
+function searchSegmentsForRange(snapshot, charStart, charCount) {
+	return textSegmentsForRange(buildPageTextLayout(snapshot), charStart, charCount);
+}
+/** The segments' AABBs — for consumers that genuinely want boxes. */
+function searchRectsForRange(snapshot, charStart, charCount) {
+	return searchSegmentsForRange(snapshot, charStart, charCount).map((s) => s.rect);
+}
 //#endregion
 //#region src/search/epoch.ts
 /**
@@ -1404,6 +1619,12 @@ Object.defineProperty(exports, "appearanceImpactOf", {
 		return appearanceImpactOf;
 	}
 });
+Object.defineProperty(exports, "buildPageTextLayout", {
+	enumerable: true,
+	get: function() {
+		return buildPageTextLayout;
+	}
+});
 Object.defineProperty(exports, "buildSnippet", {
 	enumerable: true,
 	get: function() {
@@ -1482,6 +1703,18 @@ Object.defineProperty(exports, "encodeStableIdKey", {
 		return encodeStableIdKey;
 	}
 });
+Object.defineProperty(exports, "expandTextRangeToLine", {
+	enumerable: true,
+	get: function() {
+		return expandTextRangeToLine;
+	}
+});
+Object.defineProperty(exports, "expandTextRangeToWord", {
+	enumerable: true,
+	get: function() {
+		return expandTextRangeToWord;
+	}
+});
 Object.defineProperty(exports, "foldOptionsFor", {
 	enumerable: true,
 	get: function() {
@@ -1548,66 +1781,12 @@ Object.defineProperty(exports, "normalizeAttachmentFileSource", {
 		return normalizeAttachmentFileSource;
 	}
 });
-Object.defineProperty(exports, "normalizePdfRect", {
-	enumerable: true,
-	get: function() {
-		return normalizePdfRect;
-	}
-});
 Object.defineProperty(exports, "pdfPermissions", {
 	enumerable: true,
 	get: function() {
 		return pdfPermissions;
 	}
 });
-Object.defineProperty(exports, "pdfQuadBounds", {
-	enumerable: true,
-	get: function() {
-		return pdfQuadBounds;
-	}
-});
-Object.defineProperty(exports, "pdfQuadCorners", {
-	enumerable: true,
-	get: function() {
-		return pdfQuadCorners;
-	}
-});
-Object.defineProperty(exports, "pdfQuadFromCorners", {
-	enumerable: true,
-	get: function() {
-		return pdfQuadFromCorners;
-	}
-});
-Object.defineProperty(exports, "pdfRectFromOriginSize", {
-	enumerable: true,
-	get: function() {
-		return pdfRectFromOriginSize;
-	}
-});
-Object.defineProperty(exports, "pdfRectHeight", {
-	enumerable: true,
-	get: function() {
-		return pdfRectHeight;
-	}
-});
-Object.defineProperty(exports, "pdfRectSize", {
-	enumerable: true,
-	get: function() {
-		return pdfRectSize;
-	}
-});
-Object.defineProperty(exports, "pdfRectToOriginSize", {
-	enumerable: true,
-	get: function() {
-		return pdfRectToOriginSize;
-	}
-});
-Object.defineProperty(exports, "pdfRectWidth", {
-	enumerable: true,
-	get: function() {
-		return pdfRectWidth;
-	}
-});
 Object.defineProperty(exports, "refKey", {
 	enumerable: true,
 	get: function() {
@@ -1638,6 +1817,12 @@ Object.defineProperty(exports, "searchRectsForRange", {
 		return searchRectsForRange;
 	}
 });
+Object.defineProperty(exports, "searchSegmentsForRange", {
+	enumerable: true,
+	get: function() {
+		return searchSegmentsForRange;
+	}
+});
 Object.defineProperty(exports, "semanticEqual", {
 	enumerable: true,
 	get: function() {
@@ -1656,6 +1841,24 @@ Object.defineProperty(exports, "sniffBinaryMetadata", {
 		return sniffBinaryMetadata;
 	}
 });
+Object.defineProperty(exports, "textGlyphAt", {
+	enumerable: true,
+	get: function() {
+		return textGlyphAt;
+	}
+});
+Object.defineProperty(exports, "textGlyphQuad", {
+	enumerable: true,
+	get: function() {
+		return textGlyphQuad;
+	}
+});
+Object.defineProperty(exports, "textSegmentsForRange", {
+	enumerable: true,
+	get: function() {
+		return textSegmentsForRange;
+	}
+});
 Object.defineProperty(exports, "validateSearchQuery", {
 	enumerable: true,
 	get: function() {
@@ -1681,4 +1884,4 @@ Object.defineProperty(exports, "wordBefore", {
 	}
 });
 
-//# sourceMappingURL=builders-BvikWRuO.cjs.map
+//# sourceMappingURL=builders-CBK8k_cn.cjs.map