@embedpdf/plugin-selection 3.0.0-next.1 → 3.0.0-next.10

package/dist/reducer-dmDFWFVx.cjs

@@ -0,0 +1,748 @@
+let _embedpdf_core = require("@embedpdf/core");
+let _embedpdf_core_geometry = require("@embedpdf/core-geometry");
+let _embedpdf_engine_core_runtime = require("@embedpdf/engine-core/runtime");
+//#region src/types.ts
+/**
+* The selection capability token. Typed to the full
+* {@link SelectionHostCapability} for this module and `/internal`; the
+* package root re-exports the SAME token narrowed to
+* {@link SelectionCapability}.
+*/
+const SelectionToken = (0, _embedpdf_core.createCapabilityToken)("selection");
+//#endregion
+//#region src/geometry.ts
+/**
+* The selection plugin's COORDINATE SEAM — and nothing else.
+*
+* Segmentation, hit-testing, and word/line expansion live in the canonical
+* engine-core text layout (`@embedpdf/engine-core` `text/layout`): a text
+* range has exactly one segmentation whether it came from a drag or a
+* search. This module only converts between the viewer's content space
+* (y-down, crop-relative) and the engine's PDF space (y-up) — pointer
+* points inward, canonical segments outward. The PDF↔content y-flip is the
+* geometry package's `pageGeometry` (the one place that math lives), never
+* hand-rolled here.
+*/
+/**
+* Build a page's selection geometry. Page display rotation does NOT enter
+* here — the overlay rides the page's CSS rotation, so content space stays
+* un-rotated (the crop-relative y-flip is the only conversion; zoom = 1,
+* the viewer's zoom is applied later by `PageTransform.toPixels`).
+*/
+function buildSelectionPageGeometry(snapshot, crop, rotation, userUnit) {
+	const { pdfToContent } = (0, _embedpdf_core_geometry.pageGeometry)({
+		crop,
+		rotation,
+		userUnit
+	}, 1);
+	return {
+		layout: (0, _embedpdf_engine_core_runtime.buildPageTextLayout)(snapshot),
+		toContent: pdfToContent,
+		fromContent: (0, _embedpdf_core_geometry.invert)(pdfToContent)
+	};
+}
+/** A content-space pointer point in the layout's PDF space. */
+function contentPointToPdf(geom, p) {
+	return (0, _embedpdf_core_geometry.applyPoint)(geom.fromContent, p);
+}
+/**
+* A canonical PDF quad in content space. Engine quads carry frame-geometric
+* slot semantics (`p1..p4` = upper-start, upper-end, lower-start,
+* lower-end) — a trusted producer, so the y-flip maps corners straight onto
+* their names; imported-annotation normalization does NOT apply here.
+*/
+function toContentTextQuad(geom, quad) {
+	const pt = (p) => (0, _embedpdf_core_geometry.applyPoint)(geom.toContent, p);
+	return {
+		upperStart: pt(quad.p1),
+		upperEnd: pt(quad.p2),
+		lowerStart: pt(quad.p3),
+		lowerEnd: pt(quad.p4)
+	};
+}
+/** A canonical segment in content space (`rect` recomputed from the mapped
+*  quad so the pair can never drift). */
+function toContentSegment(geom, segment) {
+	const quad = toContentTextQuad(geom, segment.quad);
+	return {
+		quad,
+		rect: (0, _embedpdf_core_geometry.textQuadBounds)(quad),
+		advance: segment.advance
+	};
+}
+//#endregion
+//#region src/capability.ts
+const EMPTY_SEGMENTS = [];
+/** How many page-text reads `readText()` keeps in flight at once. */
+const TEXT_READ_CONCURRENCY = 8;
+/**
+* The selection capability — ONE closure returning the host lens (the
+* public lens is the same object, narrowed at the package root).
+*
+* State model: the reducer holds the selection range and the derived
+* content-space segments; the large, non-serializable per-page caches live
+* HERE in the closure, split by what invalidates them:
+*
+*   - `rawGeometry` — PDF-space geometry snapshots, rotation-independent
+*     (pages load normalized; see `PageRotateResult`). Dropped only when a
+*     page leaves the registry or page CONTENT changes (redaction apply /
+*     flatten).
+*   - `derived` — the content-space transform + layout, keyed by the
+*     layout params (crop/rotation/userUnit) so a view-rotate re-derives
+*     from the cached raw snapshot with NO refetch.
+*   - `textSnapshots` — per-page text (for `readText`), same content-only
+*     invalidation as `rawGeometry`.
+*
+* Permission model: `doc.text.select` gates geometry (selection exists),
+* `doc.text.copy` gates text (extraction) — neither implies the other.
+* Host gesture functions are INERT when select is denied (`ensurePage`
+* no-ops, so nothing warms and nothing hit-tests: the pointer handler
+* needs no special-casing); the public `select()` THROWS `PermissionDenied`
+* so programmatic misuse is loud; `clear()` is always allowed. The engine
+* independently enforces both scopes — these gates exist so the plugin
+* never issues a request that is guaranteed to fail.
+*
+* Selection is cross-page: glyphs are ordered globally by (pageIndex,
+* glyph), so a drag from page 2 into page 4 selects the tail of 2, all of
+* 3, and the head of 4. `recompute` rebuilds the merged line segments for
+* every loaded page in the span, re-runs whenever a mid-span page finishes
+* loading, and CLAMPS stored endpoints once their page's geometry is known
+* (so `selectAll`'s open-ended focus settles to the real last character).
+*/
+function createSelectionCapability(ctx) {
+	const rawGeometry = /* @__PURE__ */ new Map();
+	const derived = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Set();
+	const textSnapshots = /* @__PURE__ */ new Map();
+	/** Bumped on content invalidation; in-flight reads from before are discarded. */
+	let epoch = 0;
+	const changeCbs = /* @__PURE__ */ new Set();
+	const commitCbs = /* @__PURE__ */ new Set();
+	const fireChange = () => changeCbs.forEach((cb) => cb());
+	const canSelect = () => ctx.doc?.security.allows("doc.text.select") ?? false;
+	const canCopy = () => ctx.doc?.security.allows("doc.text.copy") ?? false;
+	const layoutOf = (pon) => ctx.document()?.pages.find((p) => p.pageObjectNumber === pon);
+	const pageIndexOf = (pon) => ctx.document()?.pages.findIndex((p) => p.pageObjectNumber === pon) ?? -1;
+	const ponAtIndex = (i) => ctx.document()?.pages[i]?.pageObjectNumber;
+	/**
+	* The content-space geometry for a page, derived on demand from the raw
+	* snapshot + the CURRENT layout params. A view-rotate (or crop change)
+	* changes the key and re-derives — raw caches and the engine are never
+	* touched (rotation is presentation metadata).
+	*/
+	function geometryFor(pon) {
+		const raw = rawGeometry.get(pon);
+		const layout = layoutOf(pon);
+		if (!raw || !layout) return null;
+		const crop = layout.boxes.crop;
+		const key = `${layout.rotation}|${layout.userUnit}|${crop.left},${crop.bottom},${crop.right},${crop.top}`;
+		const hit = derived.get(pon);
+		if (hit && hit.key === key) return hit.geom;
+		const geom = buildSelectionPageGeometry(raw, crop, layout.rotation, layout.userUnit);
+		derived.set(pon, {
+			key,
+			geom
+		});
+		return geom;
+	}
+	const glyphAt = (geom, point) => (0, _embedpdf_engine_core_runtime.textGlyphAt)(geom.layout, contentPointToPdf(geom, point));
+	function orderedEnds(sel) {
+		const ai = pageIndexOf(sel.anchor.pon);
+		const fi = pageIndexOf(sel.focus.pon);
+		return ai < fi || ai === fi && sel.anchor.glyph <= sel.focus.glyph ? {
+			start: sel.anchor,
+			end: sel.focus,
+			direction: "forward"
+		} : {
+			start: sel.focus,
+			end: sel.anchor,
+			direction: "backward"
+		};
+	}
+	function endpointFor(ptr, which) {
+		const segments = ctx.getState().segments[ptr.pon] ?? EMPTY_SEGMENTS;
+		if (!segments.length) return null;
+		const segment = which === "start" ? segments[0] : segments[segments.length - 1];
+		const geom = geometryFor(ptr.pon);
+		const cell = geom ? (0, _embedpdf_engine_core_runtime.textGlyphQuad)(geom.layout, ptr.glyph) : null;
+		if (geom && cell) {
+			const glyphQuad = toContentTextQuad(geom, cell);
+			return {
+				pon: ptr.pon,
+				glyphQuad,
+				advance: segment.advance,
+				rect: (0, _embedpdf_core_geometry.textQuadBounds)(glyphQuad)
+			};
+		}
+		return {
+			pon: ptr.pon,
+			glyphQuad: segment.quad,
+			advance: segment.advance,
+			rect: segment.rect
+		};
+	}
+	/** Union box of a page's segments, or null when none have materialized. */
+	function pageBounds(pon) {
+		const segs = ctx.getState().segments[pon];
+		if (!segs || segs.length === 0) return null;
+		let x1 = Infinity;
+		let y1 = Infinity;
+		let x2 = -Infinity;
+		let y2 = -Infinity;
+		for (const s of segs) {
+			x1 = Math.min(x1, s.rect.x);
+			y1 = Math.min(y1, s.rect.y);
+			x2 = Math.max(x2, s.rect.x + s.rect.width);
+			y2 = Math.max(y2, s.rect.y + s.rect.height);
+		}
+		return {
+			x: x1,
+			y: y1,
+			width: x2 - x1,
+			height: y2 - y1
+		};
+	}
+	function menuAnchor() {
+		const sel = ctx.getState().selection;
+		if (!sel) return null;
+		const { end } = orderedEnds(sel);
+		let bounds = pageBounds(end.pon);
+		if (bounds) return {
+			pon: end.pon,
+			bounds
+		};
+		const pages = ctx.document()?.pages ?? [];
+		for (let i = pages.length - 1; i >= 0; i--) {
+			const pon = pages[i].pageObjectNumber;
+			bounds = pageBounds(pon);
+			if (bounds) return {
+				pon,
+				bounds
+			};
+		}
+		return null;
+	}
+	function snapshot() {
+		const { selection, segments } = ctx.getState();
+		const pages = Object.keys(segments).map(Number).filter((pon) => (segments[pon]?.length ?? 0) > 0).map((pon) => ({
+			pon,
+			segments: segments[pon]
+		}));
+		if (!selection) return {
+			pages,
+			start: null,
+			end: null,
+			direction: "forward",
+			range: null
+		};
+		const { start, end, direction } = orderedEnds(selection);
+		return {
+			pages,
+			start: endpointFor(start, "start"),
+			end: endpointFor(end, "end"),
+			direction,
+			range: {
+				start: {
+					pon: start.pon,
+					index: start.glyph
+				},
+				end: {
+					pon: end.pon,
+					index: end.glyph + 1
+				}
+			}
+		};
+	}
+	function ensurePage(pon) {
+		if (rawGeometry.has(pon) || pending.has(pon)) return;
+		if (!canSelect()) return;
+		const doc = ctx.doc;
+		if (!doc || !layoutOf(pon)) return;
+		pending.add(pon);
+		const at = epoch;
+		doc.page(pon).geometry.read().then((snapshot) => {
+			pending.delete(pon);
+			if (at !== epoch) return;
+			rawGeometry.set(pon, snapshot);
+			ctx.dispatch({
+				type: "PAGE_LOADED",
+				pon
+			});
+			if (ctx.getState().selection) recompute();
+		}, () => {
+			pending.delete(pon);
+		});
+	}
+	/** Clamp a pointer into its page's real character range once geometry is
+	*  known — how `selectAll`'s open-ended focus settles. */
+	function clampPointer(ptr) {
+		const geom = geometryFor(ptr.pon);
+		if (!geom) return ptr;
+		const max = Math.max(geom.layout.glyphs.length - 1, 0);
+		const glyph = Math.max(0, Math.min(ptr.glyph, max));
+		return glyph === ptr.glyph ? ptr : {
+			pon: ptr.pon,
+			glyph
+		};
+	}
+	function recompute(sel = ctx.getState().selection) {
+		if (!sel) return;
+		const clamped = {
+			anchor: clampPointer(sel.anchor),
+			focus: clampPointer(sel.focus)
+		};
+		const { start, end } = orderedEnds(clamped);
+		const si = pageIndexOf(start.pon);
+		const ei = pageIndexOf(end.pon);
+		if (si < 0 || ei < 0) {
+			clearSelection();
+			return;
+		}
+		const segments = {};
+		for (let i = si; i <= ei; i++) {
+			const pon = ponAtIndex(i);
+			if (pon == null) continue;
+			const geom = geometryFor(pon);
+			if (!geom) {
+				ensurePage(pon);
+				continue;
+			}
+			const from = i === si ? start.glyph : 0;
+			const to = i === ei ? end.glyph : geom.layout.glyphs.length - 1;
+			segments[pon] = (0, _embedpdf_engine_core_runtime.textSegmentsForRange)(geom.layout, from, to - from + 1).map((s) => toContentSegment(geom, s));
+		}
+		ctx.dispatch({
+			type: "SET",
+			selection: clamped,
+			segments
+		});
+		fireChange();
+	}
+	/** Flip the gesture-in-flight FACT (see `SelectionState.selecting`). Set
+	*  BEFORE the recompute that fires `onChange`, so change listeners always
+	*  observe a coherent (selecting, segments) pair. */
+	function setSelecting(selecting) {
+		ctx.dispatch({
+			type: "SET_SELECTING",
+			selecting
+		});
+	}
+	function clearSelection() {
+		setSelecting(false);
+		ctx.dispatch({ type: "CLEAR" });
+		fireChange();
+	}
+	function selectSpanAt(pon, point, expand) {
+		const geom = geometryFor(pon);
+		if (!geom) return false;
+		const i = glyphAt(geom, point);
+		if (i == null) return false;
+		const [from, to] = expand === "word" ? (0, _embedpdf_engine_core_runtime.expandTextRangeToWord)(geom.layout, i) : (0, _embedpdf_engine_core_runtime.expandTextRangeToLine)(geom.layout, i);
+		setSelecting(true);
+		recompute({
+			anchor: {
+				pon,
+				glyph: from
+			},
+			focus: {
+				pon,
+				glyph: to
+			}
+		});
+		return true;
+	}
+	function assertCanSelect(context) {
+		if (!canSelect()) throw new _embedpdf_engine_core_runtime.PermissionDenied("doc.text.select", context);
+	}
+	/** The public programmatic entry: a half-open character range in. */
+	function select(input) {
+		assertCanSelect("selection.select");
+		const range = "pon" in input ? {
+			start: {
+				pon: input.pon,
+				index: input.start
+			},
+			end: {
+				pon: input.pon,
+				index: input.start + input.count
+			}
+		} : input;
+		const si = pageIndexOf(range.start.pon);
+		let ei = pageIndexOf(range.end.pon);
+		if (si < 0 || ei < 0) throw new Error(`select: unknown page object ${si < 0 ? range.start.pon : range.end.pon}`);
+		let endIndex = range.end.index;
+		if (ei < si || ei === si && endIndex <= range.start.index) {
+			clearSelection();
+			return;
+		}
+		if (endIndex === 0) {
+			ei -= 1;
+			if (ei < si) {
+				clearSelection();
+				return;
+			}
+			endIndex = Number.MAX_SAFE_INTEGER;
+		}
+		const focusPon = ponAtIndex(ei);
+		if (focusPon == null) throw new Error(`select: unknown page at index ${ei}`);
+		setSelecting(false);
+		recompute({
+			anchor: {
+				pon: range.start.pon,
+				glyph: Math.max(0, range.start.index)
+			},
+			focus: {
+				pon: focusPon,
+				glyph: endIndex - 1
+			}
+		});
+	}
+	function selectAll() {
+		assertCanSelect("selection.selectAll");
+		const pages = ctx.document()?.pages ?? [];
+		if (pages.length === 0) return;
+		setSelecting(false);
+		recompute({
+			anchor: {
+				pon: pages[0].pageObjectNumber,
+				glyph: 0
+			},
+			focus: {
+				pon: pages[pages.length - 1].pageObjectNumber,
+				glyph: Number.MAX_SAFE_INTEGER
+			}
+		});
+	}
+	/** Per-page text snapshot, cached as a PROMISE so concurrent readers
+	*  share one fetch. Rejections are evicted (a denied or failed read must
+	*  not poison the cache for a later authorized call). */
+	function pageTextSnapshot(pon) {
+		let p = textSnapshots.get(pon);
+		if (!p) {
+			const doc = ctx.doc;
+			if (!doc) return Promise.reject(/* @__PURE__ */ new Error("readText: document is not open"));
+			p = Promise.resolve(doc.page(pon).text.read());
+			p.catch(() => textSnapshots.delete(pon));
+			textSnapshots.set(pon, p);
+		}
+		return p;
+	}
+	async function readText() {
+		const sel = ctx.getState().selection;
+		if (!sel) return "";
+		if (!canCopy()) throw new _embedpdf_engine_core_runtime.PermissionDenied("doc.text.copy", "selection.readText");
+		const { start, end } = orderedEnds(sel);
+		const si = pageIndexOf(start.pon);
+		const ei = pageIndexOf(end.pon);
+		if (si < 0 || ei < 0) return "";
+		const spans = [];
+		for (let i = si; i <= ei; i++) {
+			const pon = ponAtIndex(i);
+			if (pon == null) continue;
+			spans.push({
+				pon,
+				from: i === si ? start.glyph : 0,
+				to: i === ei ? end.glyph + 1 : Number.MAX_SAFE_INTEGER
+			});
+		}
+		const parts = new Array(spans.length);
+		for (let base = 0; base < spans.length; base += TEXT_READ_CONCURRENCY) {
+			const batch = spans.slice(base, base + TEXT_READ_CONCURRENCY);
+			(await Promise.all(batch.map((s) => pageTextSnapshot(s.pon)))).forEach((snap, j) => {
+				parts[base + j] = (0, _embedpdf_engine_core_runtime.sliceTextByChars)(snap, batch[j].from, batch[j].to);
+			});
+		}
+		return parts.join("\n");
+	}
+	/** Structural registry change (rotate/move/delete/insert — `revision`
+	*  bumped): drop caches for pages that left, then recompute. Rotation
+	*  re-derives transforms via the layout key; a deleted endpoint page
+	*  clears via recompute's registry check. Raw snapshots are NEVER
+	*  refetched here — they are rotation-independent. */
+	function onPagesUpdated() {
+		const alive = new Set((ctx.document()?.pages ?? []).map((p) => p.pageObjectNumber));
+		for (const pon of [...rawGeometry.keys()]) if (!alive.has(pon)) {
+			rawGeometry.delete(pon);
+			derived.delete(pon);
+			textSnapshots.delete(pon);
+		}
+		if (ctx.getState().selection) recompute();
+	}
+	/** Page CONTENT changed (redaction apply / flatten): every cached
+	*  snapshot — geometry AND text — is stale, and any live range points
+	*  into a character space that no longer exists. Drop everything, clear. */
+	function invalidateContent() {
+		epoch++;
+		rawGeometry.clear();
+		derived.clear();
+		pending.clear();
+		textSnapshots.clear();
+		if (ctx.getState().selection) clearSelection();
+	}
+	let lastRevision = ctx.document()?.revision ?? -1;
+	const offStore = ctx.subscribe(() => {
+		const revision = ctx.document()?.revision;
+		if (revision === void 0 || revision === lastRevision) return;
+		lastRevision = revision;
+		onPagesUpdated();
+	});
+	ctx.cleanup(offStore);
+	const offEvents = ctx.doc?.events.subscribe((event) => {
+		if (event.type === "redaction.applied" || event.type === "pages.flattened") invalidateContent();
+	});
+	if (offEvents) ctx.cleanup(offEvents);
+	return {
+		canSelect,
+		canCopy,
+		select,
+		selectAll,
+		clear: clearSelection,
+		snapshot,
+		menuAnchor,
+		isSelecting: () => ctx.getState().selecting,
+		hasSelection: () => ctx.getState().selection != null,
+		selectedPages: () => {
+			const { segments } = ctx.getState();
+			return Object.keys(segments).map(Number).filter((pon) => (segments[pon]?.length ?? 0) > 0);
+		},
+		segmentsForPage: (pon) => ctx.getState().segments[pon] ?? EMPTY_SEGMENTS,
+		rectsForPage: (pon) => (ctx.getState().segments[pon] ?? EMPTY_SEGMENTS).map((s) => s.rect),
+		readText,
+		onChange: (cb) => {
+			changeCbs.add(cb);
+			return () => changeCbs.delete(cb);
+		},
+		onCommit: (cb) => {
+			commitCbs.add(cb);
+			return () => commitCbs.delete(cb);
+		},
+		ensurePage,
+		isLoaded: (pon) => !!ctx.getState().loaded[pon],
+		isOverText: (pon, point) => {
+			const geom = geometryFor(pon);
+			return geom ? glyphAt(geom, point) != null : false;
+		},
+		beginAt: (pon, point) => {
+			const geom = geometryFor(pon);
+			if (!geom) return false;
+			const i = glyphAt(geom, point);
+			if (i == null) return false;
+			setSelecting(true);
+			recompute({
+				anchor: {
+					pon,
+					glyph: i
+				},
+				focus: {
+					pon,
+					glyph: i
+				}
+			});
+			return true;
+		},
+		selectWordAt: (pon, point) => selectSpanAt(pon, point, "word"),
+		selectLineAt: (pon, point) => selectSpanAt(pon, point, "line"),
+		extendTo: (pon, point) => {
+			const cur = ctx.getState().selection;
+			if (!cur) return;
+			const geom = geometryFor(pon);
+			if (!geom) {
+				ensurePage(pon);
+				return;
+			}
+			const i = glyphAt(geom, point);
+			if (i == null) return;
+			recompute({
+				anchor: cur.anchor,
+				focus: {
+					pon,
+					glyph: i
+				}
+			});
+		},
+		end: () => {
+			setSelecting(false);
+			commitCbs.forEach((cb) => cb());
+		},
+		setHighlightVisible: (visible) => ctx.dispatch({
+			type: "SET_HIGHLIGHT_HIDDEN",
+			hidden: !visible
+		}),
+		highlightVisible: () => !ctx.getState().highlightHidden
+	};
+}
+//#endregion
+//#region src/handler.ts
+const CURSOR_TOKEN = "selection-text";
+const DRAG_THRESHOLD_PX = 4;
+/**
+* The text-selection pointer handler. It is live only under tools that enable the
+* `'text-select'` tag (the built-in `pointer` tool does; `pan` does not — so
+* switching to pan disables text selection with zero special-casing here).
+*
+*  - single click        → deselect; records an anchor but selects NOTHING until
+*                          the pointer moves past the drag threshold (Chrome/Acrobat feel)
+*  - single-click + drag → caret selection from the anchor (extends across pages)
+*  - double-click        → select the word
+*  - triple-click        → select the visual line
+*  - down off-text       → deselect, and DON'T capture (so it can't block)
+*  - hover               → I-beam only when over text, else the pointer cursor
+*/
+function createTextSelectHandler(selection, interaction, feedback) {
+	let anchor = null;
+	let dragging = false;
+	return {
+		id: "text-select",
+		priority: 60,
+		enabledFor: (tool) => tool.enables.has("text-select"),
+		onDown: (s) => {
+			anchor = null;
+			dragging = false;
+			if (!s.page) return false;
+			const { pon, point } = s.page;
+			const clicks = s.clickCount ?? 1;
+			if (clicks >= 3) {
+				selection.selectLineAt(pon, point);
+				return true;
+			}
+			if (clicks === 2) {
+				if (selection.selectWordAt(pon, point) && s.gesture === "long-press") feedback?.selection();
+				return true;
+			}
+			selection.clear();
+			if (!selection.isOverText(pon, point)) return false;
+			anchor = {
+				pon,
+				point,
+				vx: s.viewport.x,
+				vy: s.viewport.y
+			};
+			return true;
+		},
+		onMove: (s) => {
+			if (!s.page || !anchor) return;
+			if (!dragging) {
+				if (Math.hypot(s.viewport.x - anchor.vx, s.viewport.y - anchor.vy) < DRAG_THRESHOLD_PX) return;
+				dragging = true;
+				selection.beginAt(anchor.pon, anchor.point);
+			}
+			selection.extendTo(s.page.pon, s.page.point);
+		},
+		onUp: () => {
+			anchor = null;
+			dragging = false;
+			selection.end();
+		},
+		onCancel: () => {
+			anchor = null;
+			dragging = false;
+			selection.clear();
+			selection.end();
+		},
+		onHover: (s) => {
+			if (!s.page) {
+				interaction.setCursor(CURSOR_TOKEN, null);
+				return;
+			}
+			selection.ensurePage(s.page.pon);
+			const overText = selection.isOverText(s.page.pon, s.page.point);
+			interaction.setCursor(CURSOR_TOKEN, overText ? "text" : null, 10);
+		}
+	};
+}
+//#endregion
+//#region src/reducer.ts
+const initialSelectionState = {
+	selection: null,
+	segments: {},
+	loaded: {},
+	highlightHidden: false,
+	selecting: false
+};
+const selectionReducer = (state, action) => {
+	switch (action.type) {
+		case "PAGE_LOADED": return state.loaded[action.pon] ? state : {
+			...state,
+			loaded: {
+				...state.loaded,
+				[action.pon]: true
+			}
+		};
+		case "SET": return {
+			...state,
+			selection: action.selection,
+			segments: action.segments
+		};
+		case "CLEAR": return state.selection === null && Object.keys(state.segments).length === 0 ? state : {
+			...state,
+			selection: null,
+			segments: {}
+		};
+		case "SET_HIGHLIGHT_HIDDEN": return state.highlightHidden === action.hidden ? state : {
+			...state,
+			highlightHidden: action.hidden
+		};
+		case "SET_SELECTING": return state.selecting === action.selecting ? state : {
+			...state,
+			selecting: action.selecting
+		};
+		default: return state;
+	}
+};
+//#endregion
+Object.defineProperty(exports, "SelectionToken", {
+	enumerable: true,
+	get: function() {
+		return SelectionToken;
+	}
+});
+Object.defineProperty(exports, "buildSelectionPageGeometry", {
+	enumerable: true,
+	get: function() {
+		return buildSelectionPageGeometry;
+	}
+});
+Object.defineProperty(exports, "contentPointToPdf", {
+	enumerable: true,
+	get: function() {
+		return contentPointToPdf;
+	}
+});
+Object.defineProperty(exports, "createSelectionCapability", {
+	enumerable: true,
+	get: function() {
+		return createSelectionCapability;
+	}
+});
+Object.defineProperty(exports, "createTextSelectHandler", {
+	enumerable: true,
+	get: function() {
+		return createTextSelectHandler;
+	}
+});
+Object.defineProperty(exports, "initialSelectionState", {
+	enumerable: true,
+	get: function() {
+		return initialSelectionState;
+	}
+});
+Object.defineProperty(exports, "selectionReducer", {
+	enumerable: true,
+	get: function() {
+		return selectionReducer;
+	}
+});
+Object.defineProperty(exports, "toContentSegment", {
+	enumerable: true,
+	get: function() {
+		return toContentSegment;
+	}
+});
+Object.defineProperty(exports, "toContentTextQuad", {
+	enumerable: true,
+	get: function() {
+		return toContentTextQuad;
+	}
+});
+
+//# sourceMappingURL=reducer-dmDFWFVx.cjs.map