@embedpdf/plugin-selection 3.0.0-next.14 → 3.0.0-next.16

package/dist/reducer-DbKtk9Xl.js

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