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

package/dist/index.js

@@ -1,1523 +1,564 @@
-import { clamp, BasePlugin, createScopedEmitter, REFRESH_PAGES } from "@embedpdf/core";
-import { boundingRect, Task, ignore, PdfErrorCode, PdfTaskHelper, PdfPermissionFlag } from "@embedpdf/models";
-const SELECTION_PLUGIN_ID = "selection";
-const manifest = {
-  id: SELECTION_PLUGIN_ID,
-  name: "Selection Plugin",
-  version: "1.0.0",
-  provides: ["selection"],
-  requires: ["interaction-manager"],
-  optional: ["viewport", "scroll"],
-  defaultConfig: {
-    menuHeight: 40
-  }
-};
-const INIT_SELECTION_STATE = "SELECTION/INIT_STATE";
-const CLEANUP_SELECTION_STATE = "SELECTION/CLEANUP_STATE";
-const CACHE_PAGE_GEOMETRY = "SELECTION/CACHE_PAGE_GEOMETRY";
-const SET_SELECTION = "SELECTION/SET_SELECTION";
-const START_SELECTION = "SELECTION/START_SELECTION";
-const END_SELECTION = "SELECTION/END_SELECTION";
-const CLEAR_SELECTION = "SELECTION/CLEAR_SELECTION";
-const SET_RECTS = "SELECTION/SET_RECTS";
-const SET_SLICES = "SELECTION/SET_SLICES";
-const EVICT_PAGE_GEOMETRY = "SELECTION/EVICT_PAGE_GEOMETRY";
-const RESET = "SELECTION/RESET";
-const initSelectionState = (documentId, state) => ({
-  type: INIT_SELECTION_STATE,
-  payload: { documentId, state }
-});
-const cleanupSelectionState = (documentId) => ({
-  type: CLEANUP_SELECTION_STATE,
-  payload: documentId
-});
-const cachePageGeometry = (documentId, page, geo) => ({
-  type: CACHE_PAGE_GEOMETRY,
-  payload: { documentId, page, geo }
-});
-const setSelection = (documentId, sel) => ({
-  type: SET_SELECTION,
-  payload: { documentId, selection: sel }
-});
-const startSelection = (documentId) => ({
-  type: START_SELECTION,
-  payload: { documentId }
-});
-const endSelection = (documentId) => ({
-  type: END_SELECTION,
-  payload: { documentId }
-});
-const clearSelection = (documentId) => ({
-  type: CLEAR_SELECTION,
-  payload: { documentId }
+import { createCapabilityToken, definePlugin } from "@embedpdf/core";
+import { InteractionToken } from "@embedpdf/plugin-interaction";
+import { applyRect, boundsOfRects, pageGeometry } from "@embedpdf/core-geometry";
+//#region src/geometry.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.
+*
+* 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
 });
-const setRects = (documentId, allRects) => ({
-  type: SET_RECTS,
-  payload: { documentId, rects: allRects }
-});
-const setSlices = (documentId, slices) => ({ type: SET_SLICES, payload: { documentId, slices } });
-const evictPageGeometry = (documentId, pages) => ({
-  type: EVICT_PAGE_GEOMETRY,
-  payload: { documentId, pages }
-});
-const initialSelectionDocumentState = {
-  geometry: {},
-  rects: {},
-  slices: {},
-  selection: null,
-  active: false,
-  selecting: false
-};
-const initialState = {
-  documents: {}
-};
-const updateDocState = (state, documentId, newDocState) => ({
-  ...state,
-  documents: {
-    ...state.documents,
-    [documentId]: newDocState
-  }
-});
-const selectionReducer = (state = initialState, action) => {
-  switch (action.type) {
-    case INIT_SELECTION_STATE: {
-      const { documentId, state: docState } = action.payload;
-      return updateDocState(state, documentId, docState);
-    }
-    case CLEANUP_SELECTION_STATE: {
-      const documentId = action.payload;
-      const { [documentId]: removed, ...remaining } = state.documents;
-      return {
-        ...state,
-        documents: remaining
-      };
-    }
-    case CACHE_PAGE_GEOMETRY: {
-      const { documentId, page, geo } = action.payload;
-      const docState = state.documents[documentId];
-      if (!docState) return state;
-      return updateDocState(state, documentId, {
-        ...docState,
-        geometry: { ...docState.geometry, [page]: geo }
-      });
-    }
-    case SET_SELECTION: {
-      const { documentId, selection } = action.payload;
-      const docState = state.documents[documentId];
-      if (!docState) return state;
-      return updateDocState(state, documentId, {
-        ...docState,
-        selection,
-        active: true
-      });
-    }
-    case START_SELECTION: {
-      const { documentId } = action.payload;
-      const docState = state.documents[documentId];
-      if (!docState) return state;
-      return updateDocState(state, documentId, {
-        ...docState,
-        selecting: true,
-        selection: null,
-        rects: {}
-      });
-    }
-    case END_SELECTION: {
-      const { documentId } = action.payload;
-      const docState = state.documents[documentId];
-      if (!docState) return state;
-      return updateDocState(state, documentId, { ...docState, selecting: false });
-    }
-    case CLEAR_SELECTION: {
-      const { documentId } = action.payload;
-      const docState = state.documents[documentId];
-      if (!docState) return state;
-      return updateDocState(state, documentId, {
-        ...docState,
-        selecting: false,
-        selection: null,
-        rects: {},
-        active: false
-      });
-    }
-    case SET_RECTS: {
-      const { documentId, rects } = action.payload;
-      const docState = state.documents[documentId];
-      if (!docState) return state;
-      return updateDocState(state, documentId, { ...docState, rects });
-    }
-    case SET_SLICES: {
-      const { documentId, slices } = action.payload;
-      const docState = state.documents[documentId];
-      if (!docState) return state;
-      return updateDocState(state, documentId, { ...docState, slices });
-    }
-    case EVICT_PAGE_GEOMETRY: {
-      const { documentId, pages } = action.payload;
-      const docState = state.documents[documentId];
-      if (!docState) return state;
-      const geometry = { ...docState.geometry };
-      const rects = { ...docState.rects };
-      const slices = { ...docState.slices };
-      for (const p of pages) {
-        delete geometry[p];
-        delete rects[p];
-        delete slices[p];
-      }
-      return updateDocState(state, documentId, { ...docState, geometry, rects, slices });
-    }
-    case RESET: {
-      const { documentId } = action.payload;
-      const docState = state.documents[documentId];
-      if (!docState) return state;
-      return updateDocState(state, documentId, initialSelectionDocumentState);
-    }
-    default:
-      return state;
-  }
-};
-function selectRectsForPage(state, page) {
-  return state.rects[page] ?? [];
-}
-function selectBoundingRectForPage(state, page) {
-  return boundingRect(selectRectsForPage(state, page));
+/**
+* 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 selectBoundingRectsForAllPages(state) {
-  const out = [];
-  const rectMap = state.rects;
-  for (const key in rectMap) {
-    const page = Number(key);
-    const bRect = boundingRect(rectMap[page]);
-    if (bRect) out.push({ page, rect: bRect });
-  }
-  return out;
+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;
 }
-function getFormattedSelectionForPage(state, page) {
-  const segmentRects = state.rects[page] || [];
-  if (segmentRects.length === 0) return null;
-  const boundingRect2 = selectBoundingRectForPage(state, page);
-  if (!boundingRect2) return null;
-  return { pageIndex: page, rect: boundingRect2, segmentRects };
+/**
+* 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`).
+*/
+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;
 }
-function getFormattedSelection(state) {
-  const result = [];
-  const pages = Object.keys(state.rects).map(Number);
-  for (const pageIndex of pages) {
-    const segmentRects = state.rects[pageIndex] || [];
-    if (segmentRects.length === 0) continue;
-    const boundingRect2 = selectBoundingRectForPage(state, pageIndex);
-    if (boundingRect2) {
-      result.push({
-        pageIndex,
-        rect: boundingRect2,
-        segmentRects
-      });
-    }
-  }
-  return result;
+/** 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];
 }
-function glyphAt(geo, pt, toleranceFactor = 1.5) {
-  for (const run of geo.runs) {
-    const inRun = pt.y >= run.rect.y && pt.y <= run.rect.y + run.rect.height && pt.x >= run.rect.x && pt.x <= run.rect.x + run.rect.width;
-    if (!inRun) continue;
-    const rel = run.glyphs.findIndex((g) => {
-      const gx = g.tightX ?? g.x;
-      const gy = g.tightY ?? g.y;
-      const gw = g.tightWidth ?? g.width;
-      const gh = g.tightHeight ?? g.height;
-      return pt.x >= gx && pt.x <= gx + gw && pt.y >= gy && pt.y <= gy + gh;
-    });
-    if (rel !== -1) {
-      return run.charStart + rel;
-    }
-  }
-  if (toleranceFactor <= 0) return -1;
-  const tolerance = computeTolerance(geo, toleranceFactor);
-  const halfTol = tolerance / 2;
-  let bestIndex = -1;
-  let bestDist = Infinity;
-  for (const run of geo.runs) {
-    if (pt.y < run.rect.y - halfTol || pt.y > run.rect.y + run.rect.height + halfTol || pt.x < run.rect.x - halfTol || pt.x > run.rect.x + run.rect.width + halfTol) {
-      continue;
-    }
-    for (let i = 0; i < run.glyphs.length; i++) {
-      const g = run.glyphs[i];
-      if (g.flags === 2) continue;
-      const gx = g.tightX ?? g.x;
-      const gy = g.tightY ?? g.y;
-      const gw = g.tightWidth ?? g.width;
-      const gh = g.tightHeight ?? g.height;
-      const expandedLeft = gx - halfTol;
-      const expandedRight = gx + gw + halfTol;
-      const expandedTop = gy - halfTol;
-      const expandedBottom = gy + gh + halfTol;
-      if (pt.x < expandedLeft || pt.x > expandedRight || pt.y < expandedTop || pt.y > expandedBottom) {
-        continue;
-      }
-      const curXdif = Math.min(Math.abs(pt.x - gx), Math.abs(pt.x - (gx + gw)));
-      const curYdif = Math.min(Math.abs(pt.y - gy), Math.abs(pt.y - (gy + gh)));
-      const dist = curXdif + curYdif;
-      if (dist < bestDist) {
-        bestDist = dist;
-        bestIndex = run.charStart + i;
-      }
-    }
-  }
-  return bestIndex;
+/** 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];
 }
-function computeTolerance(geo, factor) {
-  let totalHeight = 0;
-  let count = 0;
-  for (const run of geo.runs) {
-    for (const g of run.glyphs) {
-      if (g.flags === 2) continue;
-      totalHeight += g.height;
-      count++;
-    }
-  }
-  if (count === 0) return 0;
-  return totalHeight / count * factor;
+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 sliceBounds(sel, geo, page) {
-  if (!sel || !geo) return null;
-  if (page < sel.start.page || page > sel.end.page) return null;
-  const from = page === sel.start.page ? sel.start.index : 0;
-  const lastRun = geo.runs[geo.runs.length - 1];
-  const lastCharOnPage = lastRun.charStart + lastRun.glyphs.length - 1;
-  const to = page === sel.end.page ? sel.end.index : lastCharOnPage;
-  return { from, to };
+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 rectsWithinSlice(geo, from, to, merge = true) {
-  const textRuns = [];
-  const CHAR_DISTANCE_FACTOR = 2.5;
-  for (const run of geo.runs) {
-    const runStart = run.charStart;
-    const runEnd = runStart + run.glyphs.length - 1;
-    if (runEnd < from || runStart > to) continue;
-    const sIdx = Math.max(from, runStart) - runStart;
-    const eIdx = Math.min(to, runEnd) - runStart;
-    let minX = Infinity, maxX = -Infinity;
-    let minY = Infinity, maxY = -Infinity;
-    let charCount = 0;
-    let widthSum = 0;
-    let prevRight = -Infinity;
-    const flushSubRun = () => {
-      if (minX !== Infinity && charCount > 0) {
-        textRuns.push({
-          rect: {
-            origin: { x: minX, y: minY },
-            size: { 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 i = sIdx; i <= eIdx; i++) {
-      const g = run.glyphs[i];
-      if (g.flags === 2) continue;
-      if (charCount > 0 && prevRight > -Infinity) {
-        const gap = Math.abs(g.x - prevRight);
-        const avgWidth = widthSum / charCount;
-        if (avgWidth > 0 && gap > CHAR_DISTANCE_FACTOR * avgWidth) {
-          flushSubRun();
-        }
-      }
-      minX = Math.min(minX, g.x);
-      maxX = Math.max(maxX, g.x + g.width);
-      minY = Math.min(minY, g.y);
-      maxY = Math.max(maxY, g.y + g.height);
-      charCount++;
-      widthSum += g.width;
-      prevRight = g.x + g.width;
-    }
-    flushSubRun();
-  }
-  if (!merge) {
-    return textRuns.map((run) => run.rect);
-  }
-  return mergeAdjacentRects(textRuns);
+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;
+	}
+	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 rectUnion(rect1, rect2) {
-  const left = Math.min(rect1.origin.x, rect2.origin.x);
-  const top = Math.min(rect1.origin.y, rect2.origin.y);
-  const right = Math.max(rect1.origin.x + rect1.size.width, rect2.origin.x + rect2.size.width);
-  const bottom = Math.max(rect1.origin.y + rect1.size.height, rect2.origin.y + rect2.size.height);
-  return {
-    origin: { x: left, y: top },
-    size: { width: right - left, height: bottom - top }
-  };
+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;
 }
-function rectIntersect(rect1, rect2) {
-  const left = Math.max(rect1.origin.x, rect2.origin.x);
-  const top = Math.max(rect1.origin.y, rect2.origin.y);
-  const right = Math.min(rect1.origin.x + rect1.size.width, rect2.origin.x + rect2.size.width);
-  const bottom = Math.min(rect1.origin.y + rect1.size.height, rect2.origin.y + rect2.size.height);
-  const width = Math.max(0, right - left);
-  const height = Math.max(0, bottom - top);
-  return {
-    origin: { x: left, y: top },
-    size: { width, height }
-  };
+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;
 }
-function rectIsEmpty(rect) {
-  return rect.size.width <= 0 || rect.size.height <= 0;
+//#endregion
+//#region src/capability.ts
+const EMPTY = [];
+/**
+* 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 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.
+*/
+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
+			}
+		});
+	}
+	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();
+		},
+		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
+	};
 }
-function getVerticalOverlap(rect1, rect2) {
-  if (rectIsEmpty(rect1) || rectIsEmpty(rect2)) return 0;
-  const unionRect = rectUnion(rect1, rect2);
-  if (unionRect.size.height === rect1.size.height || unionRect.size.height === rect2.size.height) {
-    return 1;
-  }
-  const intersectRect = rectIntersect(rect1, rect2);
-  return intersectRect.size.height / unionRect.size.height;
+//#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) {
+	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.selectLine(pon, point);
+				return true;
+			}
+			if (clicks === 2) {
+				selection.selectWord(pon, point);
+				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();
+		},
+		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);
+		}
+	};
 }
-function shouldMergeHorizontalRects(textRun1, textRun2) {
-  const FONT_SIZE_RATIO_THRESHOLD = 1.5;
-  if (textRun1.fontSize != null && textRun2.fontSize != null && textRun1.fontSize > 0 && textRun2.fontSize > 0) {
-    const ratio = Math.max(textRun1.fontSize, textRun2.fontSize) / Math.min(textRun1.fontSize, textRun2.fontSize);
-    if (ratio > FONT_SIZE_RATIO_THRESHOLD) {
-      return false;
-    }
-  }
-  const VERTICAL_OVERLAP_THRESHOLD = 0.8;
-  const rect1 = textRun1.rect;
-  const rect2 = textRun2.rect;
-  if (getVerticalOverlap(rect1, rect2) < VERTICAL_OVERLAP_THRESHOLD) {
-    return false;
-  }
-  const HORIZONTAL_WIDTH_FACTOR = 1;
-  const averageWidth1 = HORIZONTAL_WIDTH_FACTOR * rect1.size.width / textRun1.charCount;
-  const averageWidth2 = HORIZONTAL_WIDTH_FACTOR * rect2.size.width / textRun2.charCount;
-  const rect1Left = rect1.origin.x - averageWidth1;
-  const rect1Right = rect1.origin.x + rect1.size.width + averageWidth1;
-  const rect2Left = rect2.origin.x - averageWidth2;
-  const rect2Right = rect2.origin.x + rect2.size.width + averageWidth2;
-  return rect1Left < rect2Right && rect1Right > rect2Left;
-}
-function mergeAdjacentRects(textRuns) {
-  const results = [];
-  let previousTextRun = null;
-  let currentRect = null;
-  for (const textRun of textRuns) {
-    if (previousTextRun && currentRect) {
-      if (shouldMergeHorizontalRects(previousTextRun, textRun)) {
-        currentRect = rectUnion(currentRect, textRun.rect);
-      } else {
-        results.push(currentRect);
-        currentRect = textRun.rect;
-      }
-    } else {
-      currentRect = textRun.rect;
-    }
-    previousTextRun = textRun;
-  }
-  if (currentRect && !rectIsEmpty(currentRect)) {
-    results.push(currentRect);
-  }
-  return results;
-}
-const VERTICAL_OVERLAP_THRESHOLD_LINE = 0.5;
-function resolveCharIndex(geo, charIndex) {
-  for (let r = 0; r < geo.runs.length; r++) {
-    const run = geo.runs[r];
-    const localIdx = charIndex - run.charStart;
-    if (localIdx >= 0 && localIdx < run.glyphs.length) {
-      return { runIdx: r, localIdx };
-    }
-  }
-  return null;
-}
-function isGlyphWordBoundary(flags) {
-  return flags === 1 || flags === 2;
-}
-function expandToWordBoundary(geo, charIndex) {
-  const resolved = resolveCharIndex(geo, charIndex);
-  if (!resolved) return null;
-  const totalChars = getTotalCharCount(geo);
-  if (totalChars === 0) return null;
-  let from = charIndex;
-  while (from > 0) {
-    const prev = resolveCharIndex(geo, from - 1);
-    if (!prev) break;
-    if (isGlyphWordBoundary(geo.runs[prev.runIdx].glyphs[prev.localIdx].flags)) break;
-    from--;
-  }
-  let to = charIndex;
-  while (to < totalChars - 1) {
-    const next = resolveCharIndex(geo, to + 1);
-    if (!next) break;
-    if (isGlyphWordBoundary(geo.runs[next.runIdx].glyphs[next.localIdx].flags)) break;
-    to++;
-  }
-  return { from, to };
-}
-function expandToLineBoundary(geo, charIndex) {
-  const resolved = resolveCharIndex(geo, charIndex);
-  if (!resolved) return null;
-  const anchorRun = geo.runs[resolved.runIdx];
-  const anchorTop = anchorRun.rect.y;
-  const anchorBottom = anchorRun.rect.y + anchorRun.rect.height;
-  let from = anchorRun.charStart;
-  let to = anchorRun.charStart + anchorRun.glyphs.length - 1;
-  for (let r = resolved.runIdx - 1; r >= 0; r--) {
-    const run = geo.runs[r];
-    if (isZeroSizeRun(run)) continue;
-    if (!runsOverlapVertically(run.rect.y, run.rect.y + run.rect.height, anchorTop, anchorBottom)) {
-      break;
-    }
-    from = run.charStart;
-  }
-  for (let r = resolved.runIdx + 1; r < geo.runs.length; r++) {
-    const run = geo.runs[r];
-    if (isZeroSizeRun(run)) continue;
-    if (!runsOverlapVertically(run.rect.y, run.rect.y + run.rect.height, anchorTop, anchorBottom)) {
-      break;
-    }
-    to = run.charStart + run.glyphs.length - 1;
-  }
-  return { from, to };
-}
-function isZeroSizeRun(run) {
-  return run.rect.width === 0 && run.rect.height === 0;
-}
-function runsOverlapVertically(top1, bottom1, top2, bottom2) {
-  const unionHeight = Math.max(bottom1, bottom2) - Math.min(top1, top2);
-  const intersectHeight = Math.max(0, Math.min(bottom1, bottom2) - Math.max(top1, top2));
-  if (unionHeight === 0) return false;
-  return intersectHeight / unionHeight >= VERTICAL_OVERLAP_THRESHOLD_LINE;
-}
-function getTotalCharCount(geo) {
-  if (geo.runs.length === 0) return 0;
-  const lastRun = geo.runs[geo.runs.length - 1];
-  return lastRun.charStart + lastRun.glyphs.length;
-}
-const TRIPLE_CLICK_INTERVAL_MS = 500;
-function createTextSelectionHandler(opts) {
-  const minDrag = opts.minDragDistance ?? 3;
-  const tolFactor = opts.toleranceFactor ?? 1.5;
-  let anchorGlyph = null;
-  let anchorPos = null;
-  let dragStarted = false;
-  let lastDblClickTime = 0;
-  function reset() {
-    var _a;
-    anchorGlyph = null;
-    anchorPos = null;
-    dragStarted = false;
-    (_a = opts.setHasTextAnchor) == null ? void 0 : _a.call(opts, false);
-  }
-  return {
-    onPointerDown: (point, evt, modeId) => {
-      var _a, _b;
-      if (evt.target === evt.currentTarget) {
-        (_a = opts.onEmptySpaceClick) == null ? void 0 : _a.call(opts, modeId);
-      }
-      if (!opts.isEnabled(modeId)) return;
-      const now = Date.now();
-      if (lastDblClickTime === 0 || now - lastDblClickTime >= TRIPLE_CLICK_INTERVAL_MS) {
-        opts.onClear(modeId);
-      }
-      const geo = opts.getGeometry();
-      if (!geo) return;
-      const g = glyphAt(geo, point, tolFactor);
-      if (g !== -1) {
-        anchorGlyph = g;
-        anchorPos = point;
-        dragStarted = false;
-        (_b = opts.setHasTextAnchor) == null ? void 0 : _b.call(opts, true);
-      }
-    },
-    onPointerMove: (point, _evt, modeId) => {
-      if (!opts.isEnabled(modeId)) return;
-      const geo = opts.getGeometry();
-      if (!geo) return;
-      const g = glyphAt(geo, point, tolFactor);
-      opts.setCursor(g !== -1 ? "text" : null);
-      if (anchorGlyph !== null && anchorPos && !dragStarted) {
-        const dx = point.x - anchorPos.x;
-        const dy = point.y - anchorPos.y;
-        const dist = Math.sqrt(dx * dx + dy * dy);
-        if (dist >= minDrag) {
-          dragStarted = true;
-          opts.onBegin(anchorGlyph, modeId);
-          if (g !== -1) {
-            opts.onUpdate(g, modeId);
-          }
-        }
-        return;
-      }
-      if (opts.isSelecting() && g !== -1) {
-        opts.onUpdate(g, modeId);
-      }
-    },
-    onPointerUp: (_point, _evt, modeId) => {
-      if (!opts.isEnabled(modeId)) {
-        reset();
-        return;
-      }
-      if (dragStarted) {
-        opts.onEnd(modeId);
-      }
-      reset();
-    },
-    onDoubleClick: (point, _evt, modeId) => {
-      var _a;
-      if (!opts.isEnabled(modeId)) return;
-      const geo = opts.getGeometry();
-      if (!geo) return;
-      const g = glyphAt(geo, point, tolFactor);
-      if (g === -1) return;
-      lastDblClickTime = Date.now();
-      (_a = opts.onWordSelect) == null ? void 0 : _a.call(opts, g, modeId);
-    },
-    onClick: (point, _evt, modeId) => {
-      var _a;
-      if (!opts.isEnabled(modeId)) return;
-      if (lastDblClickTime === 0) return;
-      const now = Date.now();
-      if (now - lastDblClickTime > TRIPLE_CLICK_INTERVAL_MS) {
-        lastDblClickTime = 0;
-        return;
-      }
-      lastDblClickTime = 0;
-      const geo = opts.getGeometry();
-      if (!geo) return;
-      const g = glyphAt(geo, point, tolFactor);
-      if (g === -1) return;
-      (_a = opts.onLineSelect) == null ? void 0 : _a.call(opts, g, modeId);
-    },
-    onHandlerActiveEnd: (modeId) => {
-      reset();
-      if (!opts.isEnabled(modeId)) return;
-      opts.onClear(modeId);
-    }
-  };
-}
-function createMarqueeSelectionHandler(opts) {
-  const { pageSize, scale, minDragPx = 5 } = opts;
-  let start = null;
-  let last = null;
-  return {
-    onPointerDown: (pos, evt, modeId) => {
-      var _a, _b;
-      if (!opts.isEnabled(modeId)) return;
-      if ((_a = opts.isTextSelecting) == null ? void 0 : _a.call(opts)) return;
-      start = pos;
-      last = { origin: { x: pos.x, y: pos.y }, size: { width: 0, height: 0 } };
-      opts.onBegin(pos, modeId);
-      (_b = evt.setPointerCapture) == null ? void 0 : _b.call(evt);
-    },
-    onPointerMove: (pos, _evt, modeId) => {
-      if (!start || !opts.isEnabled(modeId)) return;
-      const x = clamp(pos.x, 0, pageSize.width);
-      const y = clamp(pos.y, 0, pageSize.height);
-      last = {
-        origin: { x: Math.min(start.x, x), y: Math.min(start.y, y) },
-        size: { width: Math.abs(x - start.x), height: Math.abs(y - start.y) }
-      };
-      opts.onChange(last, modeId);
-    },
-    onPointerUp: (_pos, evt, modeId) => {
-      var _a;
-      if (!opts.isEnabled(modeId)) return;
-      if (last && start) {
-        const dragPx = Math.max(last.size.width, last.size.height) * scale;
-        if (dragPx > minDragPx) {
-          opts.onEnd(last, modeId);
-        } else {
-          opts.onCancel(modeId);
-        }
-      }
-      start = null;
-      last = null;
-      (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-    },
-    onPointerCancel: (_pos, evt, modeId) => {
-      var _a;
-      if (!opts.isEnabled(modeId)) return;
-      start = null;
-      last = null;
-      opts.onCancel(modeId);
-      (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-    }
-  };
-}
-const _SelectionPlugin = class _SelectionPlugin extends BasePlugin {
-  constructor(id, registry, config) {
-    var _a, _b, _c;
-    super(id, registry);
-    this.enabledModesPerDoc = /* @__PURE__ */ new Map();
-    this.selecting = /* @__PURE__ */ new Map();
-    this.anchor = /* @__PURE__ */ new Map();
-    this.hasTextAnchor = /* @__PURE__ */ new Map();
-    this.marqueePage = /* @__PURE__ */ new Map();
-    this.pageCallbacks = /* @__PURE__ */ new Map();
-    this.geoAccessOrder = /* @__PURE__ */ new Map();
-    this.menuPlacement$ = createScopedEmitter((documentId, placement) => ({ documentId, placement }));
-    this.selChange$ = createScopedEmitter((documentId, selection) => ({
-      documentId,
-      selection,
-      modeId: this.interactionManagerCapability.forDocument(documentId).getActiveMode()
-    }));
-    this.textRetrieved$ = createScopedEmitter(
-      (documentId, text) => ({ documentId, text })
-    );
-    this.copyToClipboard$ = createScopedEmitter(
-      (documentId, text) => ({ documentId, text }),
-      { cache: false }
-    );
-    this.beginSelection$ = createScopedEmitter(
-      (documentId, data) => ({
-        documentId,
-        page: data.page,
-        index: data.index,
-        modeId: data.modeId
-      }),
-      { cache: false }
-    );
-    this.endSelection$ = createScopedEmitter((documentId, data) => ({ documentId, modeId: data.modeId }), { cache: false });
-    this.marqueeChange$ = createScopedEmitter(
-      (documentId, data) => ({
-        documentId,
-        pageIndex: data.pageIndex,
-        rect: data.rect,
-        modeId: data.modeId
-      }),
-      { cache: false }
-    );
-    this.marqueeEnd$ = createScopedEmitter(
-      (documentId, data) => ({
-        documentId,
-        pageIndex: data.pageIndex,
-        rect: data.rect,
-        modeId: data.modeId
-      }),
-      { cache: false }
-    );
-    this.emptySpaceClick$ = createScopedEmitter(
-      (documentId, data) => ({
-        documentId,
-        pageIndex: data.pageIndex,
-        modeId: data.modeId
-      }),
-      { cache: false }
-    );
-    this.viewportCapability = null;
-    this.scrollCapability = null;
-    this.config = config;
-    this.menuHeight = config.menuHeight ?? 40;
-    const imPlugin = registry.getPlugin("interaction-manager");
-    if (!imPlugin) {
-      throw new Error("SelectionPlugin: InteractionManagerPlugin is required.");
-    }
-    this.interactionManagerCapability = imPlugin.provides();
-    this.viewportCapability = ((_a = registry.getPlugin("viewport")) == null ? void 0 : _a.provides()) ?? null;
-    this.scrollCapability = ((_b = registry.getPlugin("scroll")) == null ? void 0 : _b.provides()) ?? null;
-    this.coreStore.onAction(REFRESH_PAGES, (action) => {
-      const { documentId, pageIndexes } = action.payload;
-      const tasks = pageIndexes.map(
-        (pageIndex) => this.getNewPageGeometryAndCache(documentId, pageIndex)
-      );
-      Task.all(tasks).wait(() => {
-        pageIndexes.forEach((pageIndex) => {
-          this.notifyPage(documentId, pageIndex);
-        });
-      }, ignore);
-    });
-    (_c = this.viewportCapability) == null ? void 0 : _c.onViewportChange(
-      (event) => {
-        this.recalculateMenuPlacement(event.documentId);
-      },
-      { mode: "throttle", wait: 100 }
-    );
-  }
-  /* ── life-cycle ────────────────────────────────────────── */
-  onDocumentLoadingStarted(documentId) {
-    var _a;
-    this.dispatch(initSelectionState(documentId, initialSelectionDocumentState));
-    const marqueeEnabled = ((_a = this.config.marquee) == null ? void 0 : _a.enabled) !== false;
-    this.enabledModesPerDoc.set(
-      documentId,
-      /* @__PURE__ */ new Map([
-        [
-          "pointerMode",
-          {
-            enableSelection: true,
-            showSelectionRects: true,
-            enableMarquee: marqueeEnabled,
-            showMarqueeRects: true
-          }
-        ]
-      ])
-    );
-    this.pageCallbacks.set(documentId, /* @__PURE__ */ new Map());
-    this.geoAccessOrder.set(documentId, []);
-    this.selecting.set(documentId, false);
-    this.anchor.set(documentId, void 0);
-    this.hasTextAnchor.set(documentId, false);
-  }
-  onDocumentClosed(documentId) {
-    this.dispatch(cleanupSelectionState(documentId));
-    this.enabledModesPerDoc.delete(documentId);
-    this.pageCallbacks.delete(documentId);
-    this.geoAccessOrder.delete(documentId);
-    this.selecting.delete(documentId);
-    this.hasTextAnchor.delete(documentId);
-    this.anchor.delete(documentId);
-    this.marqueePage.delete(documentId);
-    this.selChange$.clearScope(documentId);
-    this.textRetrieved$.clearScope(documentId);
-    this.copyToClipboard$.clearScope(documentId);
-    this.beginSelection$.clearScope(documentId);
-    this.endSelection$.clearScope(documentId);
-    this.menuPlacement$.clearScope(documentId);
-    this.marqueeChange$.clearScope(documentId);
-    this.marqueeEnd$.clearScope(documentId);
-    this.emptySpaceClick$.clearScope(documentId);
-  }
-  async initialize() {
-  }
-  async destroy() {
-    this.selChange$.clear();
-    this.textRetrieved$.clear();
-    this.copyToClipboard$.clear();
-    this.beginSelection$.clear();
-    this.endSelection$.clear();
-    this.menuPlacement$.clear();
-    this.marqueeChange$.clear();
-    this.marqueeEnd$.clear();
-    this.emptySpaceClick$.clear();
-    super.destroy();
-  }
-  /* ── capability exposed to UI / other plugins ─────────── */
-  buildCapability() {
-    const getDocId = (documentId) => documentId ?? this.getActiveDocumentId();
-    return {
-      // Active document operations
-      getFormattedSelection: (docId) => getFormattedSelection(this.getDocumentState(getDocId(docId))),
-      getFormattedSelectionForPage: (p, docId) => getFormattedSelectionForPage(this.getDocumentState(getDocId(docId)), p),
-      getHighlightRectsForPage: (p, docId) => selectRectsForPage(this.getDocumentState(getDocId(docId)), p),
-      getHighlightRects: (docId) => this.getDocumentState(getDocId(docId)).rects,
-      getBoundingRectForPage: (p, docId) => selectBoundingRectForPage(this.getDocumentState(getDocId(docId)), p),
-      getBoundingRects: (docId) => selectBoundingRectsForAllPages(this.getDocumentState(getDocId(docId))),
-      getSelectedText: (docId) => this.getSelectedText(getDocId(docId)),
-      setSelection: (range, docId) => this.applySelection(getDocId(docId), range),
-      clear: (docId) => this.clearSelection(getDocId(docId)),
-      copyToClipboard: (docId) => this.copyToClipboard(getDocId(docId)),
-      getState: (docId) => this.getDocumentState(getDocId(docId)),
-      enableForMode: (modeId, options, docId) => {
-        var _a;
-        return (_a = this.enabledModesPerDoc.get(getDocId(docId))) == null ? void 0 : _a.set(modeId, { ...options });
-      },
-      isEnabledForMode: (modeId, docId) => {
-        var _a;
-        return ((_a = this.enabledModesPerDoc.get(getDocId(docId))) == null ? void 0 : _a.has(modeId)) ?? false;
-      },
-      setMarqueeEnabled: (enabled, docId) => this.setMarqueeEnabled(getDocId(docId), enabled),
-      isMarqueeEnabled: (docId) => this.isMarqueeEnabled(getDocId(docId)),
-      // Document-scoped operations
-      forDocument: this.createSelectionScope.bind(this),
-      // Global events
-      onCopyToClipboard: this.copyToClipboard$.onGlobal,
-      onSelectionChange: this.selChange$.onGlobal,
-      onTextRetrieved: this.textRetrieved$.onGlobal,
-      onBeginSelection: this.beginSelection$.onGlobal,
-      onEndSelection: this.endSelection$.onGlobal,
-      // Marquee selection events
-      onMarqueeChange: this.marqueeChange$.onGlobal,
-      onMarqueeEnd: this.marqueeEnd$.onGlobal,
-      // Empty space click event
-      onEmptySpaceClick: this.emptySpaceClick$.onGlobal
-    };
-  }
-  createSelectionScope(documentId) {
-    return {
-      getFormattedSelection: () => getFormattedSelection(this.getDocumentState(documentId)),
-      getFormattedSelectionForPage: (p) => getFormattedSelectionForPage(this.getDocumentState(documentId), p),
-      getHighlightRectsForPage: (p) => selectRectsForPage(this.getDocumentState(documentId), p),
-      getHighlightRects: () => this.getDocumentState(documentId).rects,
-      getBoundingRectForPage: (p) => selectBoundingRectForPage(this.getDocumentState(documentId), p),
-      getBoundingRects: () => selectBoundingRectsForAllPages(this.getDocumentState(documentId)),
-      getSelectedText: () => this.getSelectedText(documentId),
-      setSelection: (range) => this.applySelection(documentId, range),
-      clear: () => this.clearSelection(documentId),
-      copyToClipboard: () => this.copyToClipboard(documentId),
-      getState: () => this.getDocumentState(documentId),
-      setMarqueeEnabled: (enabled) => this.setMarqueeEnabled(documentId, enabled),
-      isMarqueeEnabled: () => this.isMarqueeEnabled(documentId),
-      onSelectionChange: this.selChange$.forScope(documentId),
-      onTextRetrieved: this.textRetrieved$.forScope(documentId),
-      onCopyToClipboard: this.copyToClipboard$.forScope(documentId),
-      onBeginSelection: this.beginSelection$.forScope(documentId),
-      onEndSelection: this.endSelection$.forScope(documentId),
-      onMarqueeChange: this.marqueeChange$.forScope(documentId),
-      onMarqueeEnd: this.marqueeEnd$.forScope(documentId),
-      onEmptySpaceClick: this.emptySpaceClick$.forScope(documentId)
-    };
-  }
-  getDocumentState(documentId) {
-    const state = this.state.documents[documentId];
-    if (!state) {
-      throw new Error(`Selection state not found for document: ${documentId}`);
-    }
-    return state;
-  }
-  /**
-   * Subscribe to menu placement changes for a specific document
-   * @param documentId - The document ID to subscribe to
-   * @param listener - Callback function that receives placement updates
-   * @returns Unsubscribe function
-   */
-  onMenuPlacement(documentId, listener) {
-    return this.menuPlacement$.forScope(documentId)(listener);
-  }
-  /**
-   * Register text selection on a page. Uses `registerAlways` so any plugin
-   * can enable text selection for their mode via `enableForMode()`.
-   */
-  registerSelectionOnPage(opts) {
-    var _a;
-    const { documentId, pageIndex, onRectsChange } = opts;
-    const docState = this.state.documents[documentId];
-    if (!docState) {
-      this.logger.warn(
-        "SelectionPlugin",
-        "RegisterFailed",
-        `Cannot register selection on page ${pageIndex} for document ${documentId}: document state not initialized.`
-      );
-      return () => {
-      };
-    }
-    (_a = this.pageCallbacks.get(documentId)) == null ? void 0 : _a.set(pageIndex, onRectsChange);
-    const geoTask = this.getOrLoadGeometry(documentId, pageIndex);
-    const interactionScope = this.interactionManagerCapability.forDocument(documentId);
-    const enabledModes = this.enabledModesPerDoc.get(documentId);
-    onRectsChange({
-      rects: selectRectsForPage(docState, pageIndex),
-      boundingRect: selectBoundingRectForPage(docState, pageIndex)
-    });
-    geoTask.wait((geo) => {
-      const currentState = this.getDocumentState(documentId);
-      const sel = currentState.selection;
-      if (!sel || pageIndex < sel.start.page || pageIndex > sel.end.page) return;
-      const sb = sliceBounds(sel, geo, pageIndex);
-      if (!sb) return;
-      const pageRects = rectsWithinSlice(geo, sb.from, sb.to);
-      this.dispatch(setRects(documentId, { ...currentState.rects, [pageIndex]: pageRects }));
-      this.dispatch(
-        setSlices(documentId, {
-          ...currentState.slices,
-          [pageIndex]: { start: sb.from, count: sb.to - sb.from + 1 }
-        })
-      );
-      this.notifyPage(documentId, pageIndex);
-    }, ignore);
-    const textHandler = createTextSelectionHandler({
-      getGeometry: () => this.getDocumentState(documentId).geometry[pageIndex],
-      isEnabled: (modeId) => {
-        const config = enabledModes == null ? void 0 : enabledModes.get(modeId);
-        if (!config) return false;
-        return config.enableSelection !== false;
-      },
-      onBegin: (g, modeId) => this.beginSelection(documentId, pageIndex, g, modeId),
-      onUpdate: (g, modeId) => this.updateSelection(documentId, pageIndex, g, modeId),
-      onEnd: (modeId) => this.endSelection(documentId, modeId),
-      onClear: (modeId) => this.clearSelection(documentId, modeId),
-      isSelecting: () => this.selecting.get(documentId) ?? false,
-      setCursor: (cursor) => cursor ? interactionScope.setCursor("selection-text", cursor, 10) : interactionScope.removeCursor("selection-text"),
-      onEmptySpaceClick: (modeId) => this.emptySpaceClick$.emit(documentId, { pageIndex, modeId }),
-      onWordSelect: (g, modeId) => this.selectWord(documentId, pageIndex, g, modeId),
-      onLineSelect: (g, modeId) => this.selectLine(documentId, pageIndex, g, modeId),
-      setHasTextAnchor: (active) => this.hasTextAnchor.set(documentId, active),
-      minDragDistance: this.config.minSelectionDragDistance,
-      toleranceFactor: this.config.toleranceFactor
-    });
-    const unregisterHandlers = this.interactionManagerCapability.registerAlways({
-      scope: { type: "page", documentId, pageIndex },
-      handlers: textHandler
-    });
-    return () => {
-      var _a2;
-      unregisterHandlers();
-      (_a2 = this.pageCallbacks.get(documentId)) == null ? void 0 : _a2.delete(pageIndex);
-      geoTask.abort({ code: PdfErrorCode.Cancelled, message: "Cleanup" });
-    };
-  }
-  /**
-   * Register marquee selection on a page. Uses `registerAlways` so any plugin
-   * can enable marquee selection for their mode via `enableForMode({ enableMarquee: true })`.
-   */
-  registerMarqueeOnPage(opts) {
-    var _a;
-    const { documentId, pageIndex, scale, onRectChange } = opts;
-    const docState = this.state.documents[documentId];
-    if (!docState) {
-      this.logger.warn(
-        "SelectionPlugin",
-        "RegisterMarqueeFailed",
-        `Cannot register marquee on page ${pageIndex} for document ${documentId}: document state not initialized.`
-      );
-      return () => {
-      };
-    }
-    const coreDoc = this.coreState.core.documents[documentId];
-    if (!coreDoc || !coreDoc.document) {
-      this.logger.warn(
-        "SelectionPlugin",
-        "DocumentNotFound",
-        `Cannot register marquee on page ${pageIndex}: document not found`
-      );
-      return () => {
-      };
-    }
-    const page = coreDoc.document.pages[pageIndex];
-    if (!page) {
-      this.logger.warn(
-        "SelectionPlugin",
-        "PageNotFound",
-        `Cannot register marquee on page ${pageIndex}: page not found`
-      );
-      return () => {
-      };
-    }
-    const pageSize = page.size;
-    const minDragPx = ((_a = this.config.marquee) == null ? void 0 : _a.minDragPx) ?? 5;
-    const shouldShowRect = () => {
-      var _a2;
-      const mode = this.interactionManagerCapability.forDocument(documentId).getActiveMode();
-      const config = (_a2 = this.enabledModesPerDoc.get(documentId)) == null ? void 0 : _a2.get(mode);
-      return (config == null ? void 0 : config.showMarqueeRects) !== false;
-    };
-    const marqueeHandler = createMarqueeSelectionHandler({
-      pageSize,
-      scale,
-      minDragPx,
-      isEnabled: (modeId) => {
-        var _a2;
-        const config = (_a2 = this.enabledModesPerDoc.get(documentId)) == null ? void 0 : _a2.get(modeId);
-        return (config == null ? void 0 : config.enableMarquee) === true;
-      },
-      isTextSelecting: () => (this.selecting.get(documentId) ?? false) || (this.hasTextAnchor.get(documentId) ?? false),
-      onBegin: (pos, modeId) => this.beginMarquee(documentId, pageIndex, pos, modeId),
-      onChange: (rect, modeId) => {
-        this.updateMarquee(documentId, pageIndex, rect, modeId);
-        onRectChange(shouldShowRect() ? rect : null);
-      },
-      onEnd: (rect, modeId) => {
-        this.endMarquee(documentId, pageIndex, rect, modeId);
-        onRectChange(null);
-      },
-      onCancel: (modeId) => {
-        this.cancelMarquee(documentId, modeId);
-        onRectChange(null);
-      }
-    });
-    const unregisterHandlers = this.interactionManagerCapability.registerAlways({
-      scope: { type: "page", documentId, pageIndex },
-      handlers: marqueeHandler
-    });
-    return unregisterHandlers;
-  }
-  /**
-   * Helper to calculate viewport relative metrics for a page rect.
-   * Returns null if the rect cannot be converted to viewport space.
-   */
-  getPlacementMetrics(documentId, pageIndex, rect, vpMetrics) {
-    var _a;
-    const scrollScope = (_a = this.scrollCapability) == null ? void 0 : _a.forDocument(documentId);
-    const viewportRect = scrollScope == null ? void 0 : scrollScope.getRectPositionForPage(pageIndex, rect);
-    if (!viewportRect) return null;
-    const rectTopInView = viewportRect.origin.y - vpMetrics.scrollTop;
-    const rectBottomInView = viewportRect.origin.y + viewportRect.size.height - vpMetrics.scrollTop;
-    return {
-      pageIndex,
-      rect,
-      // Original Page Rect
-      spaceAbove: rectTopInView,
-      spaceBelow: vpMetrics.clientHeight - rectBottomInView,
-      isBottomVisible: rectBottomInView > 0 && rectBottomInView <= vpMetrics.clientHeight,
-      isTopVisible: rectTopInView >= 0 && rectTopInView < vpMetrics.clientHeight
-    };
-  }
-  emitMenuPlacement(documentId, placement) {
-    this.menuPlacement$.emit(documentId, placement);
-    if (placement) {
-      this.interactionManagerCapability.claimPageActivity(
-        documentId,
-        "selection-menu",
-        placement.pageIndex
-      );
-    } else {
-      this.interactionManagerCapability.releasePageActivity(documentId, "selection-menu");
-    }
-  }
-  recalculateMenuPlacement(documentId) {
-    const docState = this.state.documents[documentId];
-    if (!docState) return;
-    if (docState.selecting || docState.selection === null) {
-      this.emitMenuPlacement(documentId, null);
-      return;
-    }
-    const bounds = selectBoundingRectsForAllPages(docState);
-    if (bounds.length === 0) {
-      this.emitMenuPlacement(documentId, null);
-      return;
-    }
-    const tail = bounds[bounds.length - 1];
-    if (!this.viewportCapability || !this.scrollCapability) {
-      this.emitMenuPlacement(documentId, {
-        pageIndex: tail.page,
-        rect: tail.rect,
-        spaceAbove: 0,
-        spaceBelow: Infinity,
-        // Pretend we have infinite space below to prevent auto-flipping
-        suggestTop: false,
-        isVisible: true
-        // Assume visible
-      });
-      return;
-    }
-    const viewportScope = this.viewportCapability.forDocument(documentId);
-    const vpMetrics = viewportScope.getMetrics();
-    const head = bounds[0];
-    const tailMetrics = this.getPlacementMetrics(documentId, tail.page, tail.rect, vpMetrics);
-    const headMetrics = this.getPlacementMetrics(documentId, head.page, head.rect, vpMetrics);
-    if (tailMetrics) {
-      if (tailMetrics.isBottomVisible && tailMetrics.spaceBelow > this.menuHeight) {
-        this.emitMenuPlacement(documentId, {
-          ...tailMetrics,
-          suggestTop: false,
-          isVisible: true
-        });
-        return;
-      }
-    }
-    if (headMetrics) {
-      if (headMetrics.isTopVisible) {
-        this.emitMenuPlacement(documentId, {
-          ...headMetrics,
-          suggestTop: true,
-          isVisible: true
-        });
-        return;
-      }
-    }
-    if (tailMetrics && tailMetrics.isBottomVisible) {
-      this.emitMenuPlacement(documentId, {
-        ...tailMetrics,
-        suggestTop: false,
-        isVisible: true
-      });
-      return;
-    }
-    this.emitMenuPlacement(documentId, null);
-  }
-  notifyPage(documentId, pageIndex) {
-    var _a, _b;
-    const callback = (_a = this.pageCallbacks.get(documentId)) == null ? void 0 : _a.get(pageIndex);
-    if (callback) {
-      const docState = this.getDocumentState(documentId);
-      const mode = this.interactionManagerCapability.forDocument(documentId).getActiveMode();
-      const modeConfig = (_b = this.enabledModesPerDoc.get(documentId)) == null ? void 0 : _b.get(mode);
-      const shouldShowRects = modeConfig && (modeConfig.showSelectionRects ?? modeConfig.showRects) !== false;
-      if (shouldShowRects) {
-        callback({
-          rects: selectRectsForPage(docState, pageIndex),
-          boundingRect: selectBoundingRectForPage(docState, pageIndex)
-        });
-      } else {
-        callback({ rects: [], boundingRect: null });
-      }
-    }
-  }
-  notifyAllPages(documentId) {
-    var _a;
-    (_a = this.pageCallbacks.get(documentId)) == null ? void 0 : _a.forEach((_, pageIndex) => {
-      this.notifyPage(documentId, pageIndex);
-    });
-  }
-  getNewPageGeometryAndCache(documentId, pageIdx) {
-    const coreDoc = this.getCoreDocument(documentId);
-    if (!coreDoc || !coreDoc.document)
-      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Doc Not Found" });
-    const page = coreDoc.document.pages.find((p) => p.index === pageIdx);
-    const task = this.engine.getPageGeometry(coreDoc.document, page);
-    task.wait((geo) => {
-      this.dispatch(cachePageGeometry(documentId, pageIdx, geo));
-      this.touchGeometry(documentId, pageIdx);
-    }, ignore);
-    return task;
-  }
-  /* ── geometry cache ───────────────────────────────────── */
-  getOrLoadGeometry(documentId, pageIdx) {
-    const cached = this.getDocumentState(documentId).geometry[pageIdx];
-    if (cached) {
-      this.touchGeometry(documentId, pageIdx);
-      return PdfTaskHelper.resolve(cached);
-    }
-    return this.getNewPageGeometryAndCache(documentId, pageIdx);
-  }
-  /* ── geometry LRU eviction ──────────────────────────────── */
-  touchGeometry(documentId, pageIdx) {
-    const order = this.geoAccessOrder.get(documentId);
-    if (!order) return;
-    const idx = order.indexOf(pageIdx);
-    if (idx > -1) order.splice(idx, 1);
-    order.push(pageIdx);
-    this.evictGeometryIfNeeded(documentId);
-  }
-  evictGeometryIfNeeded(documentId) {
-    const max = this.config.maxCachedGeometries ?? 50;
-    const order = this.geoAccessOrder.get(documentId);
-    if (!order || order.length <= max) return;
-    const pinned = this.pageCallbacks.get(documentId);
-    const toEvict = [];
-    while (order.length - toEvict.length > max) {
-      const candidate = order.find((p) => !toEvict.includes(p) && !(pinned == null ? void 0 : pinned.has(p)));
-      if (candidate === void 0) break;
-      toEvict.push(candidate);
-    }
-    if (toEvict.length === 0) return;
-    for (const p of toEvict) {
-      const idx = order.indexOf(p);
-      if (idx > -1) order.splice(idx, 1);
-    }
-    this.dispatch(evictPageGeometry(documentId, toEvict));
-  }
-  /* ── selection state updates ───────────────────────────── */
-  beginSelection(documentId, page, index, modeId) {
-    this.selecting.set(documentId, true);
-    this.anchor.set(documentId, { page, index });
-    this.dispatch(startSelection(documentId));
-    this.beginSelection$.emit(documentId, { page, index, modeId });
-    this.recalculateMenuPlacement(documentId);
-  }
-  endSelection(documentId, modeId) {
-    this.selecting.set(documentId, false);
-    this.anchor.set(documentId, void 0);
-    this.dispatch(endSelection(documentId));
-    this.endSelection$.emit(documentId, { modeId });
-    this.recalculateMenuPlacement(documentId);
-  }
-  clearSelection(documentId, _modeId) {
-    this.selecting.set(documentId, false);
-    this.anchor.set(documentId, void 0);
-    this.dispatch(clearSelection(documentId));
-    this.selChange$.emit(documentId, null);
-    this.emitMenuPlacement(documentId, null);
-    this.notifyAllPages(documentId);
-  }
-  /**
-   * Programmatically apply (or restore) a text selection without going through
-   * the pointer drag flow. Useful for restoring a previously persisted selection
-   * or driving selection from code (e.g. search results).
-   *
-   * Geometry for every page spanned by the range is loaded on demand (the data
-   * comes from the WASM engine), so the returned task settles only once the
-   * selection rects have actually been computed.
-   *
-   * Passing `null` is equivalent to calling {@link clearSelection}.
-   *
-   * @returns a task that resolves once the selection has been applied.
-   */
-  applySelection(documentId, range) {
-    if (!this.state.documents[documentId]) {
-      return PdfTaskHelper.reject({
-        code: PdfErrorCode.NotFound,
-        message: `Selection state not found for document: ${documentId}`
-      });
-    }
-    if (range === null) {
-      this.clearSelection(documentId);
-      return PdfTaskHelper.resolve(void 0);
-    }
-    const validationError = this.validateRange(documentId, range);
-    if (validationError) {
-      return PdfTaskHelper.reject(validationError);
-    }
-    const normalized = this.normalizeRange(range);
-    const pages = [];
-    for (let p = normalized.start.page; p <= normalized.end.page; p++) {
-      pages.push(p);
-    }
-    const geoTasks = pages.map((p) => this.getOrLoadGeometry(documentId, p));
-    const result = PdfTaskHelper.create();
-    Task.all(geoTasks).wait(() => {
-      if (!this.state.documents[documentId]) {
-        result.reject({
-          code: PdfErrorCode.NotFound,
-          message: `Selection state not found for document: ${documentId}`
-        });
-        return;
-      }
-      const clamped = this.clampRangeToGeometry(documentId, normalized);
-      if (!clamped) {
-        result.reject({
-          code: PdfErrorCode.NotFound,
-          message: `Cannot apply selection: page(s) ${normalized.start.page}-${normalized.end.page} have no text geometry`
-        });
-        return;
-      }
-      this.selecting.set(documentId, false);
-      this.anchor.set(documentId, void 0);
-      const previouslyHighlighted = Object.keys(this.getDocumentState(documentId).rects).map(
-        Number
-      );
-      this.dispatch(startSelection(documentId));
-      this.dispatch(setSelection(documentId, clamped));
-      this.updateRectsAndSlices(documentId, clamped);
-      this.dispatch(endSelection(documentId));
-      this.selChange$.emit(documentId, clamped);
-      const pagesToNotify = new Set(previouslyHighlighted);
-      for (let p = clamped.start.page; p <= clamped.end.page; p++) {
-        pagesToNotify.add(p);
-      }
-      pagesToNotify.forEach((p) => this.notifyPage(documentId, p));
-      this.recalculateMenuPlacement(documentId);
-      result.resolve(void 0);
-    }, (error) => result.reject(error.reason));
-    return result;
-  }
-  /**
-   * Validate the structure and page bounds of a programmatic selection range.
-   * Returns a rejection reason when the input is invalid, or null when it is
-   * structurally sound. Glyph-index bounds are enforced separately, after the
-   * page geometry has loaded (see {@link clampRangeToGeometry}).
-   */
-  validateRange(documentId, range) {
-    var _a, _b;
-    const isValidPointer = (g) => !!g && typeof g === "object" && Number.isInteger(g.page) && Number.isInteger(g.index);
-    if (!range || typeof range !== "object" || !range.start || !range.end) {
-      return { code: PdfErrorCode.Unknown, message: "Invalid selection range: expected { start, end }" };
-    }
-    if (!isValidPointer(range.start) || !isValidPointer(range.end)) {
-      return {
-        code: PdfErrorCode.Unknown,
-        message: "Invalid selection range: start/end must have integer page and index"
-      };
-    }
-    if (range.start.index < 0 || range.end.index < 0) {
-      return { code: PdfErrorCode.Unknown, message: "Invalid selection range: glyph index cannot be negative" };
-    }
-    const pageCount = ((_b = (_a = this.getCoreDocument(documentId)) == null ? void 0 : _a.document) == null ? void 0 : _b.pageCount) ?? 0;
-    const minPage = Math.min(range.start.page, range.end.page);
-    const maxPage = Math.max(range.start.page, range.end.page);
-    if (minPage < 0 || maxPage >= pageCount) {
-      return {
-        code: PdfErrorCode.NotFound,
-        message: `Invalid selection range: page ${minPage < 0 ? minPage : maxPage} out of bounds [0, ${pageCount})`
-      };
-    }
-    return null;
-  }
-  /**
-   * Clamp the glyph indices of a (normalized) range to the number of glyphs
-   * available on the corresponding pages. Returns null when none of the
-   * spanned pages have any text geometry to select.
-   */
-  clampRangeToGeometry(documentId, range) {
-    const docState = this.getDocumentState(documentId);
-    const lastGlyphIndex = (page) => {
-      const geo = docState.geometry[page];
-      if (!geo || geo.runs.length === 0) return -1;
-      const lastRun = geo.runs[geo.runs.length - 1];
-      return lastRun.charStart + lastRun.glyphs.length - 1;
-    };
-    const startMax = lastGlyphIndex(range.start.page);
-    const endMax = lastGlyphIndex(range.end.page);
-    if (startMax < 0 && endMax < 0) return null;
-    const clampIndex = (index, max) => max < 0 ? 0 : Math.min(Math.max(index, 0), max);
-    return {
-      start: { page: range.start.page, index: clampIndex(range.start.index, startMax) },
-      end: { page: range.end.page, index: clampIndex(range.end.index, endMax) }
-    };
-  }
-  /** Order a range so that `start` never comes after `end`. */
-  normalizeRange(range) {
-    const { start, end } = range;
-    const forward = end.page > start.page || end.page === start.page && end.index >= start.index;
-    return forward ? { start, end } : { start: end, end: start };
-  }
-  selectWord(documentId, page, charIndex, modeId) {
-    const geo = this.getDocumentState(documentId).geometry[page];
-    if (!geo) return;
-    const bounds = expandToWordBoundary(geo, charIndex);
-    if (!bounds) return;
-    this.applyInstantSelection(documentId, page, bounds.from, bounds.to, modeId);
-  }
-  selectLine(documentId, page, charIndex, modeId) {
-    const geo = this.getDocumentState(documentId).geometry[page];
-    if (!geo) return;
-    const bounds = expandToLineBoundary(geo, charIndex);
-    if (!bounds) return;
-    this.applyInstantSelection(documentId, page, bounds.from, bounds.to, modeId);
-  }
-  /**
-   * Set a selection range without going through the drag begin/update/end flow.
-   * Used by double-click (word) and triple-click (line) selection.
-   */
-  applyInstantSelection(documentId, page, from, to, modeId) {
-    const range = {
-      start: { page, index: from },
-      end: { page, index: to }
-    };
-    this.selecting.set(documentId, false);
-    this.anchor.set(documentId, void 0);
-    this.dispatch(startSelection(documentId));
-    this.dispatch(setSelection(documentId, range));
-    this.updateRectsAndSlices(documentId, range);
-    this.dispatch(endSelection(documentId));
-    this.selChange$.emit(documentId, range);
-    this.beginSelection$.emit(documentId, { page, index: from, modeId });
-    this.endSelection$.emit(documentId, { modeId });
-    for (let p = range.start.page; p <= range.end.page; p++) {
-      this.notifyPage(documentId, p);
-    }
-    this.recalculateMenuPlacement(documentId);
-  }
-  updateSelection(documentId, page, index, modeId) {
-    if (!this.selecting.get(documentId) || !this.anchor.get(documentId)) return;
-    const a = this.anchor.get(documentId);
-    const forward = page > a.page || page === a.page && index >= a.index;
-    const start = forward ? a : { page, index };
-    const end = forward ? { page, index } : a;
-    const range = { start, end };
-    this.dispatch(setSelection(documentId, range));
-    this.updateRectsAndSlices(documentId, range);
-    this.selChange$.emit(documentId, range);
-    for (let p = range.start.page; p <= range.end.page; p++) {
-      this.notifyPage(documentId, p);
-    }
-  }
-  updateRectsAndSlices(documentId, range) {
-    const docState = this.getDocumentState(documentId);
-    const allRects = {};
-    const allSlices = {};
-    for (let p = range.start.page; p <= range.end.page; p++) {
-      const geo = docState.geometry[p];
-      const sb = sliceBounds(range, geo, p);
-      if (!sb) continue;
-      allRects[p] = rectsWithinSlice(geo, sb.from, sb.to);
-      allSlices[p] = { start: sb.from, count: sb.to - sb.from + 1 };
-    }
-    this.dispatch(setRects(documentId, allRects));
-    this.dispatch(setSlices(documentId, allSlices));
-  }
-  getSelectedText(documentId) {
-    if (!this.checkPermission(documentId, PdfPermissionFlag.CopyContents)) {
-      this.logger.debug(
-        "SelectionPlugin",
-        "GetSelectedText",
-        `Cannot get selected text: document ${documentId} lacks CopyContents permission`
-      );
-      return PdfTaskHelper.reject({
-        code: PdfErrorCode.Security,
-        message: "Document lacks CopyContents permission"
-      });
-    }
-    const coreDoc = this.getCoreDocument(documentId);
-    const docState = this.getDocumentState(documentId);
-    if (!(coreDoc == null ? void 0 : coreDoc.document) || !docState.selection) {
-      return PdfTaskHelper.reject({
-        code: PdfErrorCode.NotFound,
-        message: "Doc Not Found or No Selection"
-      });
-    }
-    const sel = docState.selection;
-    const req = [];
-    for (let p = sel.start.page; p <= sel.end.page; p++) {
-      const s = docState.slices[p];
-      if (s) req.push({ pageIndex: p, charIndex: s.start, charCount: s.count });
-    }
-    if (req.length === 0) return PdfTaskHelper.resolve([]);
-    const task = this.engine.getTextSlices(coreDoc.document, req);
-    task.wait((text) => {
-      this.textRetrieved$.emit(documentId, text);
-    }, ignore);
-    return task;
-  }
-  copyToClipboard(documentId) {
-    if (!this.checkPermission(documentId, PdfPermissionFlag.CopyContents)) {
-      this.logger.debug(
-        "SelectionPlugin",
-        "CopyToClipboard",
-        `Cannot copy to clipboard: document ${documentId} lacks CopyContents permission`
-      );
-      return;
-    }
-    const text = this.getSelectedText(documentId);
-    text.wait((text2) => {
-      this.copyToClipboard$.emit(documentId, text2.join("\n"));
-    }, ignore);
-  }
-  /* ── marquee selection state updates ─────────────────────── */
-  beginMarquee(documentId, pageIndex, _startPos, _modeId) {
-    this.marqueePage.set(documentId, pageIndex);
-  }
-  updateMarquee(documentId, pageIndex, rect, modeId) {
-    this.marqueeChange$.emit(documentId, { pageIndex, rect, modeId });
-  }
-  endMarquee(documentId, pageIndex, rect, modeId) {
-    this.marqueeEnd$.emit(documentId, { pageIndex, rect, modeId });
-    this.marqueeChange$.emit(documentId, { pageIndex, rect: null, modeId });
-    this.marqueePage.delete(documentId);
-  }
-  cancelMarquee(documentId, modeId) {
-    const pageIndex = this.marqueePage.get(documentId);
-    if (pageIndex !== void 0) {
-      this.marqueeChange$.emit(documentId, { pageIndex, rect: null, modeId });
-      this.marqueePage.delete(documentId);
-    }
-  }
-  /** @deprecated — shim for backward compat; delegates to pointerMode config */
-  setMarqueeEnabled(documentId, enabled) {
-    const modes = this.enabledModesPerDoc.get(documentId);
-    if (!modes) return;
-    const current = modes.get("pointerMode");
-    if (current) {
-      current.enableMarquee = enabled;
-    } else if (enabled) {
-      modes.set("pointerMode", { enableMarquee: true });
-    }
-  }
-  /** @deprecated — shim for backward compat; reads pointerMode config */
-  isMarqueeEnabled(documentId) {
-    var _a;
-    const config = (_a = this.enabledModesPerDoc.get(documentId)) == null ? void 0 : _a.get("pointerMode");
-    return (config == null ? void 0 : config.enableMarquee) !== false;
-  }
-};
-_SelectionPlugin.id = "selection";
-let SelectionPlugin = _SelectionPlugin;
-const SelectionPluginPackage = {
-  manifest,
-  create: (registry, config) => new SelectionPlugin(SELECTION_PLUGIN_ID, registry, config),
-  reducer: selectionReducer,
-  initialState
+//#endregion
+//#region src/reducer.ts
+const initialSelectionState = {
+	selection: null,
+	rects: {},
+	loaded: {},
+	highlightHidden: false
 };
-export {
-  SELECTION_PLUGIN_ID,
-  SelectionPlugin,
-  SelectionPluginPackage,
-  expandToLineBoundary,
-  expandToWordBoundary,
-  getVerticalOverlap,
-  glyphAt,
-  manifest,
-  mergeAdjacentRects,
-  rectIntersect,
-  rectIsEmpty,
-  rectUnion,
-  rectsWithinSlice,
-  shouldMergeHorizontalRects,
-  sliceBounds
+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;
+	}
 };
-//# sourceMappingURL=index.js.map
+//#endregion
+//#region src/types.ts
+const SelectionToken = createCapabilityToken("selection");
+//#endregion
+//#region src/selection.plugin.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.
+*/
+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));
+	}
+});
+//#endregion
+export { SelectionToken, buildPageText, createSelectionCapability, createTextSelectHandler, expandToLine, expandToWord, glyphAt, initialSelectionState, rectsForRange, selectionPlugin, selectionReducer };
+
+//# sourceMappingURL=index.js.map