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

package/dist/index.js

@@ -1,564 +1,147 @@
-import { createCapabilityToken, definePlugin } from "@embedpdf/core";
-import { InteractionToken } from "@embedpdf/plugin-interaction";
-import { applyRect, boundsOfRects, pageGeometry } from "@embedpdf/core-geometry";
-//#region src/geometry.ts
+import { i as createSelectionCapability, l as SelectionToken$1, n as selectionReducer, r as createTextSelectHandler, t as initialSelectionState } from "./reducer-Dy0YPuX0.js";
+import { definePlugin } from "@embedpdf/core";
+import { FeedbackToken, InteractionToken } from "@embedpdf/plugin-interaction";
+import { textQuadEdge } from "@embedpdf/core-geometry";
+//#region src/selection.plugin.ts
 /**
-* The pure selection geometry: engine text geometry (PDF user space, y-up) →
-* viewer content space (y-down), glyph hit-testing, word/line expansion, and the
-* line-merge. No DOM, no engine, no React.
+* Text selection — document-scoped, requires the interaction hub. In `init` it
+* registers ITS pointer handler with the hub; the hub owns the pointer stream
+* and arbitration. Works with `<Stage>` or a standalone `<PageView>` — selection
+* only needs the page coordinate context + the engine's text geometry.
 *
-* The non-trivial bits are ports of battle-tested algorithms, adapted to v3's
-* content-space `Rect {x,y,width,height}`:
-*   - `glyphAt`     — PDFium `GetIndexAtPos` (exact tight box, then a tolerance pass).
-*   - `rectsForRange` — Chromium `pdfium_range.cc` `MergeAdjacentRects` (one rect per line).
-*   - `expandToWord/Line` — Chromium `OnMultipleClick` (double = word, triple = line).
-* The PDF↔content y-flip is the geometry package's `pageGeometry` (the one place
-* that math lives), never hand-rolled here.
-*/
-const FLAG_EMPTY = 2;
-const isBoundary = (flags) => (flags & 3) !== 0;
-const isEmpty = (flags) => (flags & FLAG_EMPTY) !== 0;
-const toContent = (m, b) => applyRect(m, {
-	x: b.left,
-	y: b.bottom,
-	width: b.right - b.left,
-	height: b.top - b.bottom
-});
-/**
-* Flatten a page's text geometry into content-space glyphs + runs. Rotation does
-* NOT enter here — the overlay rides the page's CSS rotation, so glyphs stay in
-* un-rotated content space (the crop-relative y-flip is the only conversion).
-*/
-function buildPageText(snapshot, crop, rotation, userUnit) {
-	const { pdfToContent } = pageGeometry({
-		crop,
-		rotation,
-		userUnit
-	}, 1);
-	const glyphs = [];
-	const runs = [];
-	for (const run of snapshot.runs) {
-		const start = glyphs.length;
-		for (const g of run.glyphs) glyphs.push({
-			loose: toContent(pdfToContent, g.looseBox),
-			tight: g.tightBox ? toContent(pdfToContent, g.tightBox) : void 0,
-			flags: g.flags
-		});
-		runs.push({
-			start,
-			count: run.glyphs.length,
-			rect: toContent(pdfToContent, run.rect),
-			fontSize: run.fontSize
-		});
-	}
-	return {
-		glyphs,
-		runs
-	};
-}
-function avgGlyphHeight(text) {
-	let total = 0;
-	let count = 0;
-	for (const g of text.glyphs) {
-		if (isEmpty(g.flags)) continue;
-		total += g.loose.height;
-		count++;
-	}
-	return count === 0 ? 0 : total / count;
-}
-/**
-* The glyph index at a content-space point, or null when nothing is near (so the
-* caller 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`).
+* Registry/content invalidation is wired inside the capability itself
+* (revision watch + document event subscription), so headless/programmatic
+* use gets the same reconciliation as the full viewer.
 */
-function glyphAt(text, p, toleranceFactor = 1.5) {
-	for (const run of text.runs) {
-		const r = run.rect;
-		if (p.x < r.x || p.x > r.x + r.width || p.y < r.y || p.y > r.y + r.height) continue;
-		for (let i = 0; i < run.count; i++) {
-			const b = text.glyphs[run.start + i].tight ?? text.glyphs[run.start + i].loose;
-			if (p.x >= b.x && p.x <= b.x + b.width && p.y >= b.y && p.y <= b.y + b.height) return run.start + i;
-		}
-	}
-	if (toleranceFactor <= 0) return null;
-	const half = avgGlyphHeight(text) * toleranceFactor / 2;
-	let best = -1;
-	let bestDist = Infinity;
-	for (const run of text.runs) {
-		const r = run.rect;
-		if (p.y < r.y - half || p.y > r.y + r.height + half || p.x < r.x - half || p.x > r.x + r.width + half) continue;
-		for (let i = 0; i < run.count; i++) {
-			const g = text.glyphs[run.start + i];
-			if (isEmpty(g.flags)) continue;
-			const b = g.tight ?? g.loose;
-			if (p.x < b.x - half || p.x > b.x + b.width + half || p.y < b.y - half || p.y > b.y + b.height + half) continue;
-			const dx = Math.min(Math.abs(p.x - b.x), Math.abs(p.x - (b.x + b.width)));
-			const dy = Math.min(Math.abs(p.y - b.y), Math.abs(p.y - (b.y + b.height)));
-			if (dx + dy < bestDist) {
-				bestDist = dx + dy;
-				best = run.start + i;
-			}
-		}
-	}
-	return best >= 0 ? best : null;
-}
-/** Double-click: the word around `i` (walk to space/empty glyphs both ways). */
-function expandToWord(text, i) {
-	const n = text.glyphs.length;
-	if (i < 0 || i >= n) return [i, i];
-	let from = i;
-	while (from > 0 && !isBoundary(text.glyphs[from - 1].flags)) from--;
-	let to = i;
-	while (to < n - 1 && !isBoundary(text.glyphs[to + 1].flags)) to++;
-	return [from, to];
-}
-/** Triple-click: the full visual line — runs whose vertical extent overlaps the anchor run's. */
-function expandToLine(text, i) {
-	const ri = text.runs.findIndex((r) => i >= r.start && i < r.start + r.count);
-	if (ri < 0) return [i, i];
-	const anchor = text.runs[ri];
-	const top = anchor.rect.y;
-	const bottom = anchor.rect.y + anchor.rect.height;
-	let from = anchor.start;
-	let to = anchor.start + anchor.count - 1;
-	for (let r = ri - 1; r >= 0; r--) {
-		const run = text.runs[r];
-		if (isZero(run.rect)) continue;
-		if (!overlapV(run.rect.y, run.rect.y + run.rect.height, top, bottom)) break;
-		from = run.start;
-	}
-	for (let r = ri + 1; r < text.runs.length; r++) {
-		const run = text.runs[r];
-		if (isZero(run.rect)) continue;
-		if (!overlapV(run.rect.y, run.rect.y + run.rect.height, top, bottom)) break;
-		to = run.start + run.count - 1;
-	}
-	return [from, to];
-}
-const CHAR_DISTANCE_FACTOR = 2.5;
-const FONT_SIZE_RATIO_THRESHOLD = 1.5;
-const VERTICAL_OVERLAP_THRESHOLD = .8;
-const LINE_OVERLAP_THRESHOLD = .5;
-function rectsForRange(text, from, to) {
-	const lo = Math.max(0, Math.min(from, to));
-	const hi = Math.min(text.glyphs.length - 1, Math.max(from, to));
-	const subRuns = [];
-	for (const run of text.runs) {
-		const runEnd = run.start + run.count - 1;
-		if (runEnd < lo || run.start > hi) continue;
-		const s = Math.max(lo, run.start);
-		const e = Math.min(hi, runEnd);
-		let minX = Infinity;
-		let maxX = -Infinity;
-		let minY = Infinity;
-		let maxY = -Infinity;
-		let charCount = 0;
-		let widthSum = 0;
-		let prevRight = -Infinity;
-		const flush = () => {
-			if (minX !== Infinity && charCount > 0) subRuns.push({
-				rect: {
-					x: minX,
-					y: minY,
-					width: maxX - minX,
-					height: maxY - minY
-				},
-				charCount,
-				fontSize: run.fontSize
-			});
-			minX = Infinity;
-			maxX = -Infinity;
-			minY = Infinity;
-			maxY = -Infinity;
-			charCount = 0;
-			widthSum = 0;
-			prevRight = -Infinity;
-		};
-		for (let gi = s; gi <= e; gi++) {
-			const g = text.glyphs[gi];
-			if (isEmpty(g.flags)) continue;
-			const b = g.loose;
-			if (charCount > 0 && prevRight > -Infinity) {
-				const avg = widthSum / charCount;
-				if (avg > 0 && Math.abs(b.x - prevRight) > CHAR_DISTANCE_FACTOR * avg) flush();
-			}
-			minX = Math.min(minX, b.x);
-			maxX = Math.max(maxX, b.x + b.width);
-			minY = Math.min(minY, b.y);
-			maxY = Math.max(maxY, b.y + b.height);
-			charCount++;
-			widthSum += b.width;
-			prevRight = b.x + b.width;
-		}
-		flush();
-	}
-	return mergeAdjacentRects(subRuns);
-}
-function mergeAdjacentRects(runs) {
-	const out = [];
-	let prev = null;
-	let cur = null;
-	for (const run of runs) {
-		if (prev && cur && shouldMerge(prev, run)) cur = boundsOfRects([cur, run.rect]);
-		else {
-			if (cur) out.push(cur);
-			cur = run.rect;
-		}
-		prev = run;
-	}
-	if (cur && cur.width > 0 && cur.height > 0) out.push(cur);
-	return out;
-}
-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;
+const selectionPlugin = () => definePlugin({
+	id: "selection",
+	token: SelectionToken$1,
+	scope: "document",
+	requires: [InteractionToken],
+	optional: [FeedbackToken],
+	initialState: initialSelectionState,
+	reduce: selectionReducer,
+	capability: createSelectionCapability,
+	init: (ctx) => {
+		const interaction = ctx.get(InteractionToken);
+		const selection = ctx.get(SelectionToken$1);
+		const feedback = ctx.tryGet(FeedbackToken);
+		interaction.registerHandler(createTextSelectHandler(selection, interaction, feedback ?? void 0));
 	}
-	if (verticalOverlap(a.rect, b.rect) < VERTICAL_OVERLAP_THRESHOLD) return false;
-	const aw = a.rect.width / a.charCount;
-	const bw = b.rect.width / b.charCount;
-	const aL = a.rect.x - aw;
-	const aR = a.rect.x + a.rect.width + aw;
-	const bL = b.rect.x - bw;
-	return aL < b.rect.x + b.rect.width + bw && aR > bL;
-}
-function verticalOverlap(a, b) {
-	if (a.height <= 0 || b.height <= 0) return 0;
-	const u = Math.max(a.y + a.height, b.y + b.height) - Math.min(a.y, b.y);
-	if (u === a.height || u === b.height) return 1;
-	return Math.max(0, Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y)) / u;
-}
-const isZero = (r) => r.width === 0 && r.height === 0;
-function overlapV(top1, bottom1, top2, bottom2) {
-	const u = Math.max(bottom1, bottom2) - Math.min(top1, top2);
-	if (u === 0) return false;
-	return Math.max(0, Math.min(bottom1, bottom2) - Math.max(top1, top2)) / u >= LINE_OVERLAP_THRESHOLD;
-}
+});
 //#endregion
-//#region src/capability.ts
-const EMPTY = [];
+//#region src/handles.ts
 /**
-* The selection capability. The reducer state holds the selection range, the
-* derived content-space rects (per page), and per-page loaded flags; the (large,
-* non-serializable) per-page text geometry is cached HERE in the closure.
+* Selection handles — the pure policy half (the `wheel.ts` convention).
+*
+* A handle IS the boundary glyph's leading (or trailing) edge: a segment
+* between two corners of the glyph's ORIENTED cell, with the grab head just
+* beyond the ascent at the start / past the baseline at the end. Bar length,
+* angle, and head all derive from that one segment, so rotated text and
+* rotated pages are carried by construction — the AABB never enters.
 *
-* 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 rects for every loaded page in the span
-* and re-runs whenever a mid-span page finishes loading.
+* Everything here is DOM-free and framework-free: geometry is pure given a
+* projector, and the drag session speaks the selection's own gesture verbs
+* (`beginAt`/`extendTo`/`end` — the same ones the pointer handler uses; a
+* handle drag IS a selection gesture, re-anchored). The framework adapters
+* keep only subscriptions and markup; the DOM listener mechanics live in
+* `@embedpdf/web`'s `attachSelectionHandle`.
+*
+* The view dependency is STRUCTURAL (satisfied by five lines over
+* `StageCapability`) so this plugin stays stage-free — selection also runs
+* in stage-less hosts (`PageView`) — and the math tests run against a fake.
 */
-function createSelectionCapability(ctx) {
-	const cache = /* @__PURE__ */ new Map();
-	const pending = /* @__PURE__ */ new Set();
-	const changeCbs = /* @__PURE__ */ new Set();
-	const commitCbs = /* @__PURE__ */ new Set();
-	const fireChange = () => changeCbs.forEach((cb) => cb());
-	const pageIndexOf = (pon) => ctx.document()?.pages.findIndex((p) => p.pageObjectNumber === pon) ?? -1;
-	const ponAtIndex = (i) => ctx.document()?.pages[i]?.pageObjectNumber;
-	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 rects = ctx.getState().rects[ptr.pon] ?? EMPTY;
-		if (!rects.length) return null;
-		return {
-			pon: ptr.pon,
-			rect: which === "start" ? rects[0] : rects[rects.length - 1]
-		};
-	}
-	function snapshot() {
-		const { selection, rects } = ctx.getState();
-		const pages = Object.keys(rects).map(Number).filter((pon) => (rects[pon]?.length ?? 0) > 0).map((pon) => ({
-			pon,
-			rects: rects[pon]
-		}));
-		if (!selection) return {
-			pages,
-			start: null,
-			end: null,
-			direction: "forward"
-		};
-		const { start, end, direction } = orderedEnds(selection);
-		return {
-			pages,
-			start: endpointFor(start, "start"),
-			end: endpointFor(end, "end"),
-			direction
-		};
-	}
-	function ensurePage(pon) {
-		if (cache.has(pon) || pending.has(pon)) return;
-		const doc = ctx.doc;
-		const layout = ctx.document()?.pages.find((p) => p.pageObjectNumber === pon);
-		if (!doc || !layout) return;
-		pending.add(pon);
-		doc.page(pon).geometry.read().then((snapshot) => {
-			pending.delete(pon);
-			cache.set(pon, buildPageText(snapshot, layout.boxes.crop, layout.rotation, layout.userUnit));
-			ctx.dispatch({
-				type: "PAGE_LOADED",
-				pon
-			});
-			if (ctx.getState().selection) recompute();
-		}, () => {
-			pending.delete(pon);
-		});
-	}
-	function recompute(sel = ctx.getState().selection) {
-		if (!sel) return;
-		const { start, end } = orderedEnds(sel);
-		const si = pageIndexOf(start.pon);
-		const ei = pageIndexOf(end.pon);
-		if (si < 0 || ei < 0) return;
-		const rects = {};
-		for (let i = si; i <= ei; i++) {
-			const pon = ponAtIndex(i);
-			if (pon == null) continue;
-			const text = cache.get(pon);
-			if (!text) {
-				ensurePage(pon);
-				continue;
-			}
-			rects[pon] = rectsForRange(text, i === si ? start.glyph : 0, i === ei ? end.glyph : text.glyphs.length - 1);
-		}
-		ctx.dispatch({
-			type: "SET",
-			selection: sel,
-			rects
-		});
-		fireChange();
-	}
-	function selectSpan(pon, point, expand) {
-		const text = cache.get(pon);
-		if (!text) return;
-		const i = glyphAt(text, point);
-		if (i == null) return;
-		const [from, to] = expand === "word" ? expandToWord(text, i) : expandToLine(text, i);
-		recompute({
-			anchor: {
-				pon,
-				glyph: from
-			},
-			focus: {
-				pon,
-				glyph: to
-			}
-		});
-	}
+const HANDLE_HEAD = 12;
+const HANDLE_BAR = 2;
+const HANDLE_PAD = 14;
+/** Tilts within ~0.05° of upright render untransformed (float-noise guard —
+*  and the dominant case stays pixel-identical to an axis-aligned box). */
+const HANDLE_ROT_EPSILON = .05;
+const midpoint = (a, b) => ({
+	x: (a.x + b.x) / 2,
+	y: (a.y + b.y) / 2
+});
+/**
+* The handle's geometry for one endpoint, in overlay space. Null when the
+* endpoint's page isn't laid out (or the cell is degenerate) — render nothing.
+*/
+function selectionHandleGeom(view, ep, role) {
+	const leading = role === "start" ? ep.advance > 0 : ep.advance < 0;
+	const [upperPage, lowerPage] = textQuadEdge(ep.glyphQuad, leading ? "start" : "end");
+	const upper = view.toOverlay(ep.pon, upperPage);
+	const lower = view.toOverlay(ep.pon, lowerPage);
+	if (!upper || !lower) return null;
+	const dx = lower.x - upper.x;
+	const dy = lower.y - upper.y;
+	const length = Math.hypot(dx, dy);
+	if (length === 0) return null;
+	const rotation = Math.atan2(dy, dx) * 180 / Math.PI - 90;
+	const upright = Math.abs(rotation) < HANDLE_ROT_EPSILON;
+	const ux = dx / length;
+	const uy = dy / length;
+	const head = role === "start" ? {
+		x: upper.x - ux * 12 / 2,
+		y: upper.y - uy * 12 / 2
+	} : {
+		x: lower.x + ux * 12 / 2,
+		y: lower.y + uy * 12 / 2
+	};
 	return {
-		ensurePage,
-		isLoaded: (pon) => !!ctx.getState().loaded[pon],
-		isOverText: (pon, point) => {
-			const text = cache.get(pon);
-			return text ? glyphAt(text, point) != null : false;
-		},
-		beginAt: (pon, point) => {
-			const text = cache.get(pon);
-			if (!text) return false;
-			const i = glyphAt(text, point);
-			if (i == null) return false;
-			recompute({
-				anchor: {
-					pon,
-					glyph: i
-				},
-				focus: {
-					pon,
-					glyph: i
-				}
-			});
-			return true;
-		},
-		selectWord: (pon, point) => selectSpan(pon, point, "word"),
-		selectLine: (pon, point) => selectSpan(pon, point, "line"),
-		extendTo: (pon, point) => {
-			const cur = ctx.getState().selection;
-			if (!cur) return;
-			const text = cache.get(pon);
-			if (!text) {
-				ensurePage(pon);
-				return;
-			}
-			const i = glyphAt(text, point);
-			if (i == null) return;
-			recompute({
-				anchor: cur.anchor,
-				focus: {
-					pon,
-					glyph: i
-				}
-			});
-		},
-		end: () => commitCbs.forEach((cb) => cb()),
-		clear: () => {
-			ctx.dispatch({ type: "CLEAR" });
-			fireChange();
+		bar: {
+			from: upper,
+			to: lower
 		},
-		snapshot,
-		rectsForPage: (pon) => ctx.getState().rects[pon] ?? EMPTY,
-		hasSelection: () => ctx.getState().selection != null,
-		selectedPages: () => {
-			const { rects } = ctx.getState();
-			return Object.keys(rects).map(Number).filter((pon) => (rects[pon]?.length ?? 0) > 0);
-		},
-		onChange: (cb) => {
-			changeCbs.add(cb);
-			return () => changeCbs.delete(cb);
-		},
-		onCommit: (cb) => {
-			commitCbs.add(cb);
-			return () => commitCbs.delete(cb);
-		},
-		setHighlightVisible: (visible) => ctx.dispatch({
-			type: "SET_HIGHLIGHT_HIDDEN",
-			hidden: !visible
-		}),
-		highlightVisible: () => !ctx.getState().highlightHidden
+		length,
+		rotation,
+		upright,
+		head
 	};
 }
-//#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
+* One armed handle drag. Dragging a handle extends from the OPPOSITE
+* endpoint: the first movement re-roots the selection gesture at that
+* endpoint's cell centre, and every position then extends toward the pointer
+* — snapping to glyphs and crossing pages exactly like a pointer drag,
+* firing the same change/commit signals. Over a gap the point projects onto
+* the last page hit (unclamped), so the selection keeps tracking instead of
+* freezing at a page edge. `end()` commits only if the drag actually
+* re-rooted; an untouched press settles nothing.
 */
-function createTextSelectHandler(selection, interaction) {
-	let anchor = null;
-	let dragging = false;
+function createSelectionHandleDrag(selection, view, opposite, draggedPon) {
+	const q = opposite.glyphQuad;
+	const anchorPoint = midpoint(midpoint(q.upperStart, q.lowerEnd), midpoint(q.upperEnd, q.lowerStart));
+	let begun = false;
+	let lastPon = draggedPon;
 	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.selectLine(pon, point);
-				return true;
+		move: (overlay) => {
+			if (!begun) {
+				if (!selection.beginAt(opposite.pon, anchorPoint)) return;
+				begun = true;
 			}
-			if (clicks === 2) {
-				selection.selectWord(pon, point);
-				return true;
+			const hit = view.pageAt(overlay);
+			if (hit) {
+				lastPon = hit.pon;
+				selection.extendTo(hit.pon, hit.point);
+			} else {
+				const p = view.pointOnPage(lastPon, overlay);
+				if (p) selection.extendTo(lastPon, p);
 			}
-			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();
-		},
-		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);
+		end: () => {
+			if (begun) selection.end();
 		}
 	};
 }
 //#endregion
-//#region src/reducer.ts
-const initialSelectionState = {
-	selection: null,
-	rects: {},
-	loaded: {},
-	highlightHidden: 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,
-			rects: action.rects
-		};
-		case "CLEAR": return state.selection === null && Object.keys(state.rects).length === 0 ? state : {
-			...state,
-			selection: null,
-			rects: {}
-		};
-		case "SET_HIGHLIGHT_HIDDEN": return state.highlightHidden === action.hidden ? state : {
-			...state,
-			highlightHidden: action.hidden
-		};
-		default: return state;
-	}
-};
-//#endregion
-//#region src/types.ts
-const SelectionToken = createCapabilityToken("selection");
-//#endregion
-//#region src/selection.plugin.ts
+//#region src/index.ts
 /**
-* Text selection — document-scoped, requires the interaction hub. In `init` it
-* registers ITS pointer handler with the hub; the hub owns the pointer stream
-* and arbitration. Works with `<Stage>` or a standalone `<PageView>` — selection
-* only needs the page coordinate context + the engine's text geometry.
+* The selection capability token, narrowed to the public
+* {@link SelectionCapability} lens. It is the SAME runtime token the plugin
+* provides — the host-only surface (pointer gestures, geometry warming) is
+* reachable only via `@embedpdf/plugin-selection/internal`.
 */
-const selectionPlugin = () => definePlugin({
-	id: "selection",
-	token: SelectionToken,
-	scope: "document",
-	requires: [InteractionToken],
-	initialState: initialSelectionState,
-	reduce: selectionReducer,
-	capability: createSelectionCapability,
-	init: (ctx) => {
-		const interaction = ctx.get(InteractionToken);
-		const selection = ctx.get(SelectionToken);
-		interaction.registerHandler(createTextSelectHandler(selection, interaction));
-	}
-});
+const SelectionToken = SelectionToken$1;
 //#endregion
-export { SelectionToken, buildPageText, createSelectionCapability, createTextSelectHandler, expandToLine, expandToWord, glyphAt, initialSelectionState, rectsForRange, selectionPlugin, selectionReducer };
+export { HANDLE_BAR, HANDLE_HEAD, HANDLE_PAD, SelectionToken, createSelectionHandleDrag, selectionHandleGeom, selectionPlugin };
 
 //# sourceMappingURL=index.js.map