@embedpdf/plugin-selection 3.0.0-next.5 → 3.0.0-next.7

package/dist/index.cjs

@@ -1,7 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_reducer = require("./reducer-Dyf8p5h-.cjs");
+const require_reducer = require("./reducer-B6uL_O7s.cjs");
 let _embedpdf_core = require("@embedpdf/core");
 let _embedpdf_plugin_interaction = require("@embedpdf/plugin-interaction");
+let _embedpdf_core_geometry = require("@embedpdf/core-geometry");
 //#region src/selection.plugin.ts
 /**
 * Text selection — document-scoped, requires the interaction hub. In `init` it
@@ -18,16 +19,121 @@ const selectionPlugin = () => (0, _embedpdf_core.definePlugin)({
 	token: require_reducer.SelectionToken,
 	scope: "document",
 	requires: [_embedpdf_plugin_interaction.InteractionToken],
+	optional: [_embedpdf_plugin_interaction.FeedbackToken],
 	initialState: require_reducer.initialSelectionState,
 	reduce: require_reducer.selectionReducer,
 	capability: require_reducer.createSelectionCapability,
 	init: (ctx) => {
 		const interaction = ctx.get(_embedpdf_plugin_interaction.InteractionToken);
 		const selection = ctx.get(require_reducer.SelectionToken);
-		interaction.registerHandler(require_reducer.createTextSelectHandler(selection, interaction));
+		const feedback = ctx.tryGet(_embedpdf_plugin_interaction.FeedbackToken);
+		interaction.registerHandler(require_reducer.createTextSelectHandler(selection, interaction, feedback ?? void 0));
 	}
 });
 //#endregion
+//#region src/handles.ts
+/**
+* Selection handles — the pure policy half (the `wheel.ts` convention).
+*
+* A handle IS the boundary glyph's leading (or trailing) edge: a segment
+* between two corners of the glyph's ORIENTED cell, with the grab head just
+* beyond the ascent at the start / past the baseline at the end. Bar length,
+* angle, and head all derive from that one segment, so rotated text and
+* rotated pages are carried by construction — the AABB never enters.
+*
+* Everything here is DOM-free and framework-free: geometry is pure given a
+* projector, and the drag session speaks the selection's own gesture verbs
+* (`beginAt`/`extendTo`/`end` — the same ones the pointer handler uses; a
+* handle drag IS a selection gesture, re-anchored). The framework adapters
+* keep only subscriptions and markup; the DOM listener mechanics live in
+* `@embedpdf/web`'s `attachSelectionHandle`.
+*
+* The view dependency is STRUCTURAL (satisfied by five lines over
+* `StageCapability`) so this plugin stays stage-free — selection also runs
+* in stage-less hosts (`PageView`) — and the math tests run against a fake.
+*/
+const HANDLE_HEAD = 12;
+const HANDLE_BAR = 2;
+const HANDLE_PAD = 14;
+/** Tilts within ~0.05° of upright render untransformed (float-noise guard —
+*  and the dominant case stays pixel-identical to an axis-aligned box). */
+const HANDLE_ROT_EPSILON = .05;
+const midpoint = (a, b) => ({
+	x: (a.x + b.x) / 2,
+	y: (a.y + b.y) / 2
+});
+/**
+* The handle's geometry for one endpoint, in overlay space. Null when the
+* endpoint's page isn't laid out (or the cell is degenerate) — render nothing.
+*/
+function selectionHandleGeom(view, ep, role) {
+	const leading = role === "start" ? ep.advance > 0 : ep.advance < 0;
+	const [upperPage, lowerPage] = (0, _embedpdf_core_geometry.textQuadEdge)(ep.glyphQuad, leading ? "start" : "end");
+	const upper = view.toOverlay(ep.pon, upperPage);
+	const lower = view.toOverlay(ep.pon, lowerPage);
+	if (!upper || !lower) return null;
+	const dx = lower.x - upper.x;
+	const dy = lower.y - upper.y;
+	const length = Math.hypot(dx, dy);
+	if (length === 0) return null;
+	const rotation = Math.atan2(dy, dx) * 180 / Math.PI - 90;
+	const upright = Math.abs(rotation) < HANDLE_ROT_EPSILON;
+	const ux = dx / length;
+	const uy = dy / length;
+	const head = role === "start" ? {
+		x: upper.x - ux * 12 / 2,
+		y: upper.y - uy * 12 / 2
+	} : {
+		x: lower.x + ux * 12 / 2,
+		y: lower.y + uy * 12 / 2
+	};
+	return {
+		bar: {
+			from: upper,
+			to: lower
+		},
+		length,
+		rotation,
+		upright,
+		head
+	};
+}
+/**
+* One armed handle drag. Dragging a handle extends from the OPPOSITE
+* endpoint: the first movement re-roots the selection gesture at that
+* endpoint's cell centre, and every position then extends toward the pointer
+* — snapping to glyphs and crossing pages exactly like a pointer drag,
+* firing the same change/commit signals. Over a gap the point projects onto
+* the last page hit (unclamped), so the selection keeps tracking instead of
+* freezing at a page edge. `end()` commits only if the drag actually
+* re-rooted; an untouched press settles nothing.
+*/
+function createSelectionHandleDrag(selection, view, opposite, draggedPon) {
+	const q = opposite.glyphQuad;
+	const anchorPoint = midpoint(midpoint(q.upperStart, q.lowerEnd), midpoint(q.upperEnd, q.lowerStart));
+	let begun = false;
+	let lastPon = draggedPon;
+	return {
+		move: (overlay) => {
+			if (!begun) {
+				if (!selection.beginAt(opposite.pon, anchorPoint)) return;
+				begun = true;
+			}
+			const hit = view.pageAt(overlay);
+			if (hit) {
+				lastPon = hit.pon;
+				selection.extendTo(hit.pon, hit.point);
+			} else {
+				const p = view.pointOnPage(lastPon, overlay);
+				if (p) selection.extendTo(lastPon, p);
+			}
+		},
+		end: () => {
+			if (begun) selection.end();
+		}
+	};
+}
+//#endregion
 //#region src/index.ts
 /**
 * The selection capability token, narrowed to the public
@@ -37,7 +143,12 @@ const selectionPlugin = () => (0, _embedpdf_core.definePlugin)({
 */
 const SelectionToken = require_reducer.SelectionToken;
 //#endregion
+exports.HANDLE_BAR = HANDLE_BAR;
+exports.HANDLE_HEAD = HANDLE_HEAD;
+exports.HANDLE_PAD = HANDLE_PAD;
 exports.SelectionToken = SelectionToken;
+exports.createSelectionHandleDrag = createSelectionHandleDrag;
+exports.selectionHandleGeom = selectionHandleGeom;
 exports.selectionPlugin = selectionPlugin;
 
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["SelectionToken","InteractionToken","initialSelectionState","selectionReducer","createSelectionCapability","createTextSelectHandler","SelectionHostToken"],"sources":["../src/selection.plugin.ts","../src/index.ts"],"sourcesContent":["import { definePlugin } from '@embedpdf/core';\nimport { InteractionToken } from '@embedpdf/plugin-interaction';\nimport { createSelectionCapability } from './capability';\nimport { createTextSelectHandler } from './handler';\nimport { initialSelectionState, selectionReducer } from './reducer';\nimport { SelectionToken } from './types';\nimport type { SelectionAction, SelectionHostCapability, SelectionState } from './types';\n\n/**\n * Text selection — document-scoped, requires the interaction hub. In `init` it\n * registers ITS pointer handler with the hub; the hub owns the pointer stream\n * and arbitration. Works with `<Stage>` or a standalone `<PageView>` — selection\n * only needs the page coordinate context + the engine's text geometry.\n *\n * Registry/content invalidation is wired inside the capability itself\n * (revision watch + document event subscription), so headless/programmatic\n * use gets the same reconciliation as the full viewer.\n */\nexport const selectionPlugin = () =>\n  definePlugin<SelectionState, SelectionAction, SelectionHostCapability>({\n    id: 'selection',\n    token: SelectionToken,\n    scope: 'document',\n    requires: [InteractionToken],\n    initialState: initialSelectionState,\n    reduce: selectionReducer,\n    capability: createSelectionCapability,\n    init: (ctx) => {\n      const interaction = ctx.get(InteractionToken);\n      const selection = ctx.get(SelectionToken); // our own capability (built before init)\n      interaction.registerHandler(createTextSelectHandler(selection, interaction));\n    },\n  });\n","/**\n * @embedpdf/plugin-selection — text selection over the engine's text geometry.\n *\n * The PUBLIC surface: the plugin factory, the capability token (narrowed to\n * the public lens), and the range/read vocabulary. Selection ranges live in\n * CHARACTER space (half-open `TextRange` — the same space search hits\n * address), geometry needs `doc.text.select`, text extraction needs\n * `doc.text.copy`, and neither permission implies the other.\n *\n * Framework/host plumbing (gesture intents, geometry warming, the reducer,\n * the coordinate seam) lives behind `@embedpdf/plugin-selection/internal`.\n * Clipboard writes live in `@embedpdf/web` — this package is DOM-free.\n */\nimport type { CapabilityToken } from '@embedpdf/core';\nimport { SelectionToken as SelectionHostToken } from './types';\nimport type { SelectionCapability } from './types';\n\nexport { selectionPlugin } from './selection.plugin';\nexport type {\n  SelectionCapability,\n  SelectionEndpoint,\n  SelectionMenuAnchor,\n  SelectionRangeInput,\n  SelectionSnapshot,\n  TextPosition,\n  TextRange,\n} from './types';\nexport type { SelectionSegment } from './geometry';\n\n/**\n * The selection capability token, narrowed to the public\n * {@link SelectionCapability} lens. It is the SAME runtime token the plugin\n * provides — the host-only surface (pointer gestures, geometry warming) is\n * reachable only via `@embedpdf/plugin-selection/internal`.\n */\nexport const SelectionToken =\n  SelectionHostToken as unknown as CapabilityToken<SelectionCapability>;\n"],"mappings":";;;;;;;;;;;;;;;AAkBA,MAAa,yBAAA,GAAA,eAAA,aAAA,CAC4D;CACrE,IAAI;CACJ,OAAOA,gBAAAA;CACP,OAAO;CACP,UAAU,CAACC,6BAAAA,gBAAgB;CAC3B,cAAcC,gBAAAA;CACd,QAAQC,gBAAAA;CACR,YAAYC,gBAAAA;CACZ,OAAO,QAAQ;EACb,MAAM,cAAc,IAAI,IAAIH,6BAAAA,gBAAgB;EAC5C,MAAM,YAAY,IAAI,IAAID,gBAAAA,cAAc;EACxC,YAAY,gBAAgBK,gBAAAA,wBAAwB,WAAW,WAAW,CAAC;CAC7E;AACF,CAAC;;;;;;;;;ACGH,MAAa,iBACXC,gBAAAA"}
+{"version":3,"file":"index.cjs","names":["SelectionToken","InteractionToken","FeedbackToken","initialSelectionState","selectionReducer","createSelectionCapability","createTextSelectHandler","SelectionHostToken"],"sources":["../src/selection.plugin.ts","../src/handles.ts","../src/index.ts"],"sourcesContent":["import { definePlugin } from '@embedpdf/core';\nimport { FeedbackToken, InteractionToken } from '@embedpdf/plugin-interaction';\nimport { createSelectionCapability } from './capability';\nimport { createTextSelectHandler } from './handler';\nimport { initialSelectionState, selectionReducer } from './reducer';\nimport { SelectionToken } from './types';\nimport type { SelectionAction, SelectionHostCapability, SelectionState } from './types';\n\n/**\n * Text selection — document-scoped, requires the interaction hub. In `init` it\n * registers ITS pointer handler with the hub; the hub owns the pointer stream\n * and arbitration. Works with `<Stage>` or a standalone `<PageView>` — selection\n * only needs the page coordinate context + the engine's text geometry.\n *\n * Registry/content invalidation is wired inside the capability itself\n * (revision watch + document event subscription), so headless/programmatic\n * use gets the same reconciliation as the full viewer.\n */\nexport const selectionPlugin = () =>\n  definePlugin<SelectionState, SelectionAction, SelectionHostCapability>({\n    id: 'selection',\n    token: SelectionToken,\n    scope: 'document',\n    requires: [InteractionToken],\n    // Platform feedback (haptics) is OPTIONAL: absent in headless setups, the\n    // handler simply never buzzes.\n    optional: [FeedbackToken],\n    initialState: initialSelectionState,\n    reduce: selectionReducer,\n    capability: createSelectionCapability,\n    init: (ctx) => {\n      const interaction = ctx.get(InteractionToken);\n      const selection = ctx.get(SelectionToken); // our own capability (built before init)\n      const feedback = ctx.tryGet(FeedbackToken);\n      interaction.registerHandler(\n        createTextSelectHandler(selection, interaction, feedback ?? undefined),\n      );\n    },\n  });\n","/**\n * Selection handles — the pure policy half (the `wheel.ts` convention).\n *\n * A handle IS the boundary glyph's leading (or trailing) edge: a segment\n * between two corners of the glyph's ORIENTED cell, with the grab head just\n * beyond the ascent at the start / past the baseline at the end. Bar length,\n * angle, and head all derive from that one segment, so rotated text and\n * rotated pages are carried by construction — the AABB never enters.\n *\n * Everything here is DOM-free and framework-free: geometry is pure given a\n * projector, and the drag session speaks the selection's own gesture verbs\n * (`beginAt`/`extendTo`/`end` — the same ones the pointer handler uses; a\n * handle drag IS a selection gesture, re-anchored). The framework adapters\n * keep only subscriptions and markup; the DOM listener mechanics live in\n * `@embedpdf/web`'s `attachSelectionHandle`.\n *\n * The view dependency is STRUCTURAL (satisfied by five lines over\n * `StageCapability`) so this plugin stays stage-free — selection also runs\n * in stage-less hosts (`PageView`) — and the math tests run against a fake.\n */\nimport { textQuadEdge } from '@embedpdf/core-geometry';\nimport type { Point, TextQuad } from '@embedpdf/core-geometry';\nimport type { PageObjectNumber } from '@embedpdf/core';\n\n/** What handle geometry & drags need from the hosting view. */\nexport interface SelectionHandleView {\n  /** Page content point → overlay px. Must be POINT-exact (compose\n   *  `pageToWorld` with `toScreen`); an AABB projector loses orientation. */\n  toOverlay(pon: PageObjectNumber, pt: Point): Point | null;\n  /** Overlay px → the page under it, or null over a gap. */\n  pageAt(overlay: Point): { pon: PageObjectNumber; point: Point } | null;\n  /** Overlay px → a SPECIFIC page's content space, unclamped. */\n  pointOnPage(pon: PageObjectNumber, overlay: Point): Point | null;\n}\n\n/** One selection boundary, as the handle needs it (a `SelectionEndpoint` slice). */\nexport interface SelectionHandleEndpoint {\n  pon: PageObjectNumber;\n  /** The boundary glyph's own oriented cell, page content space. */\n  glyphQuad: TextQuad;\n  /** Reading direction of its segment (+1 = the frame's +x) — decides which\n   *  side of the cell is the selection's leading edge. */\n  advance: 1 | -1;\n}\n\n/** The gesture verbs a handle drag drives — `SelectionHostCapability` satisfies it. */\nexport interface SelectionHandleTarget {\n  beginAt(pon: PageObjectNumber, point: Point): boolean;\n  extendTo(pon: PageObjectNumber, point: Point): void;\n  end(): void;\n}\n\n// The iOS caret-handle design, one source for every adapter: a thin BAR that\n// is the selection's edge, capped by a screen-constant circle; PAD is the\n// invisible finger padding around the visual.\nexport const HANDLE_HEAD = 12; // px — the circle\nexport const HANDLE_BAR = 2; // px — the caret bar\nexport const HANDLE_PAD = 14; // px — grab padding\n\n/** Tilts within ~0.05° of upright render untransformed (float-noise guard —\n *  and the dominant case stays pixel-identical to an axis-aligned box). */\nconst HANDLE_ROT_EPSILON = 0.05;\n\nexport interface SelectionHandleGeom {\n  /** The projected edge, ascent corner first, overlay px. */\n  bar: { from: Point; to: Point };\n  /** The glyph's ink height on screen — zoom scaling comes free. */\n  length: number;\n  /** Degrees clockwise; 0 when the text is upright on screen. */\n  rotation: number;\n  /** True within the epsilon of upright: render with NO transform. */\n  upright: boolean;\n  /** Centre of the grab head, overlay px. */\n  head: Point;\n}\n\nconst midpoint = (a: Point, b: Point): Point => ({ x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 });\n\n/**\n * The handle's geometry for one endpoint, in overlay space. Null when the\n * endpoint's page isn't laid out (or the cell is degenerate) — render nothing.\n */\nexport function selectionHandleGeom(\n  view: SelectionHandleView,\n  ep: SelectionHandleEndpoint,\n  role: 'start' | 'end',\n): SelectionHandleGeom | null {\n  // Which SIDE of the cell is this selection's edge is a reading-order\n  // question (`advance`), never a geometric one.\n  const leading = role === 'start' ? ep.advance > 0 : ep.advance < 0;\n  const [upperPage, lowerPage] = textQuadEdge(ep.glyphQuad, leading ? 'start' : 'end');\n  const upper = view.toOverlay(ep.pon, upperPage);\n  const lower = view.toOverlay(ep.pon, lowerPage);\n  if (!upper || !lower) return null;\n  const dx = lower.x - upper.x;\n  const dy = lower.y - upper.y;\n  const length = Math.hypot(dx, dy);\n  if (length === 0) return null;\n  // 0° when the text is upright: the bar runs straight down the screen.\n  const rotation = (Math.atan2(dy, dx) * 180) / Math.PI - 90;\n  const upright = Math.abs(rotation) < HANDLE_ROT_EPSILON;\n  const ux = dx / length;\n  const uy = dy / length;\n  const head =\n    role === 'start'\n      ? { x: upper.x - (ux * HANDLE_HEAD) / 2, y: upper.y - (uy * HANDLE_HEAD) / 2 }\n      : { x: lower.x + (ux * HANDLE_HEAD) / 2, y: lower.y + (uy * HANDLE_HEAD) / 2 };\n  return { bar: { from: upper, to: lower }, length, rotation, upright, head };\n}\n\nexport interface SelectionHandleDragSession {\n  /** Feed the pointer's current overlay position. */\n  move(overlay: Point): void;\n  /** The pointer released (or was cancelled): settle the gesture. */\n  end(): void;\n}\n\n/**\n * One armed handle drag. Dragging a handle extends from the OPPOSITE\n * endpoint: the first movement re-roots the selection gesture at that\n * endpoint's cell centre, and every position then extends toward the pointer\n * — snapping to glyphs and crossing pages exactly like a pointer drag,\n * firing the same change/commit signals. Over a gap the point projects onto\n * the last page hit (unclamped), so the selection keeps tracking instead of\n * freezing at a page edge. `end()` commits only if the drag actually\n * re-rooted; an untouched press settles nothing.\n */\nexport function createSelectionHandleDrag(\n  selection: SelectionHandleTarget,\n  view: SelectionHandleView,\n  opposite: SelectionHandleEndpoint,\n  draggedPon: PageObjectNumber,\n): SelectionHandleDragSession {\n  // The fixed anchor: the opposite endpoint's cell CENTRE — orientation-free\n  // (a parallelogram's diagonal midpoints coincide), so it lands inside the\n  // glyph for rotated text too.\n  const q = opposite.glyphQuad;\n  const anchorPoint = midpoint(midpoint(q.upperStart, q.lowerEnd), midpoint(q.upperEnd, q.lowerStart));\n  let begun = false;\n  let lastPon = draggedPon;\n  return {\n    move: (overlay) => {\n      if (!begun) {\n        if (!selection.beginAt(opposite.pon, anchorPoint)) return;\n        begun = true;\n      }\n      const hit = view.pageAt(overlay);\n      if (hit) {\n        lastPon = hit.pon;\n        selection.extendTo(hit.pon, hit.point);\n      } else {\n        const p = view.pointOnPage(lastPon, overlay);\n        if (p) selection.extendTo(lastPon, p);\n      }\n    },\n    end: () => {\n      if (begun) selection.end(); // settle → menu reappears, onCommit fires\n    },\n  };\n}\n","/**\n * @embedpdf/plugin-selection — text selection over the engine's text geometry.\n *\n * The PUBLIC surface: the plugin factory, the capability token (narrowed to\n * the public lens), and the range/read vocabulary. Selection ranges live in\n * CHARACTER space (half-open `TextRange` — the same space search hits\n * address), geometry needs `doc.text.select`, text extraction needs\n * `doc.text.copy`, and neither permission implies the other.\n *\n * Framework/host plumbing (gesture intents, geometry warming, the reducer,\n * the coordinate seam) lives behind `@embedpdf/plugin-selection/internal`.\n * Clipboard writes live in `@embedpdf/web` — this package is DOM-free.\n */\nimport type { CapabilityToken } from '@embedpdf/core';\nimport { SelectionToken as SelectionHostToken } from './types';\nimport type { SelectionCapability } from './types';\n\nexport { selectionPlugin } from './selection.plugin';\nexport type {\n  SelectionCapability,\n  SelectionEndpoint,\n  SelectionMenuAnchor,\n  SelectionRangeInput,\n  SelectionSnapshot,\n  TextPosition,\n  TextRange,\n} from './types';\nexport type { SelectionSegment } from './geometry';\n// Selection-handle policy (the touch affordance): pure geometry + the drag\n// session, consumed by the framework adapters' handle views.\nexport {\n  HANDLE_BAR,\n  HANDLE_HEAD,\n  HANDLE_PAD,\n  createSelectionHandleDrag,\n  selectionHandleGeom,\n} from './handles';\nexport type {\n  SelectionHandleDragSession,\n  SelectionHandleEndpoint,\n  SelectionHandleGeom,\n  SelectionHandleTarget,\n  SelectionHandleView,\n} from './handles';\n\n/**\n * The selection capability token, narrowed to the public\n * {@link SelectionCapability} lens. It is the SAME runtime token the plugin\n * provides — the host-only surface (pointer gestures, geometry warming) is\n * reachable only via `@embedpdf/plugin-selection/internal`.\n */\nexport const SelectionToken =\n  SelectionHostToken as unknown as CapabilityToken<SelectionCapability>;\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,MAAa,yBAAA,GAAA,eAAA,aAAA,CAC4D;CACrE,IAAI;CACJ,OAAOA,gBAAAA;CACP,OAAO;CACP,UAAU,CAACC,6BAAAA,gBAAgB;CAG3B,UAAU,CAACC,6BAAAA,aAAa;CACxB,cAAcC,gBAAAA;CACd,QAAQC,gBAAAA;CACR,YAAYC,gBAAAA;CACZ,OAAO,QAAQ;EACb,MAAM,cAAc,IAAI,IAAIJ,6BAAAA,gBAAgB;EAC5C,MAAM,YAAY,IAAI,IAAID,gBAAAA,cAAc;EACxC,MAAM,WAAW,IAAI,OAAOE,6BAAAA,aAAa;EACzC,YAAY,gBACVI,gBAAAA,wBAAwB,WAAW,aAAa,YAAY,KAAA,CAAS,CACvE;CACF;AACF,CAAC;;;;;;;;;;;;;;;;;;;;;;;ACiBH,MAAa,cAAc;AAC3B,MAAa,aAAa;AAC1B,MAAa,aAAa;;;AAI1B,MAAM,qBAAqB;AAe3B,MAAM,YAAY,GAAU,OAAqB;CAAE,IAAI,EAAE,IAAI,EAAE,KAAK;CAAG,IAAI,EAAE,IAAI,EAAE,KAAK;AAAE;;;;;AAM1F,SAAgB,oBACd,MACA,IACA,MAC4B;CAG5B,MAAM,UAAU,SAAS,UAAU,GAAG,UAAU,IAAI,GAAG,UAAU;CACjE,MAAM,CAAC,WAAW,cAAA,GAAA,wBAAA,aAAA,CAA0B,GAAG,WAAW,UAAU,UAAU,KAAK;CACnF,MAAM,QAAQ,KAAK,UAAU,GAAG,KAAK,SAAS;CAC9C,MAAM,QAAQ,KAAK,UAAU,GAAG,KAAK,SAAS;CAC9C,IAAI,CAAC,SAAS,CAAC,OAAO,OAAO;CAC7B,MAAM,KAAK,MAAM,IAAI,MAAM;CAC3B,MAAM,KAAK,MAAM,IAAI,MAAM;CAC3B,MAAM,SAAS,KAAK,MAAM,IAAI,EAAE;CAChC,IAAI,WAAW,GAAG,OAAO;CAEzB,MAAM,WAAY,KAAK,MAAM,IAAI,EAAE,IAAI,MAAO,KAAK,KAAK;CACxD,MAAM,UAAU,KAAK,IAAI,QAAQ,IAAI;CACrC,MAAM,KAAK,KAAK;CAChB,MAAM,KAAK,KAAK;CAChB,MAAM,OACJ,SAAS,UACL;EAAE,GAAG,MAAM,IAAK,KAAA,KAAoB;EAAG,GAAG,MAAM,IAAK,KAAA,KAAoB;CAAE,IAC3E;EAAE,GAAG,MAAM,IAAK,KAAA,KAAoB;EAAG,GAAG,MAAM,IAAK,KAAA,KAAoB;CAAE;CACjF,OAAO;EAAE,KAAK;GAAE,MAAM;GAAO,IAAI;EAAM;EAAG;EAAQ;EAAU;EAAS;CAAK;AAC5E;;;;;;;;;;;AAmBA,SAAgB,0BACd,WACA,MACA,UACA,YAC4B;CAI5B,MAAM,IAAI,SAAS;CACnB,MAAM,cAAc,SAAS,SAAS,EAAE,YAAY,EAAE,QAAQ,GAAG,SAAS,EAAE,UAAU,EAAE,UAAU,CAAC;CACnG,IAAI,QAAQ;CACZ,IAAI,UAAU;CACd,OAAO;EACL,OAAO,YAAY;GACjB,IAAI,CAAC,OAAO;IACV,IAAI,CAAC,UAAU,QAAQ,SAAS,KAAK,WAAW,GAAG;IACnD,QAAQ;GACV;GACA,MAAM,MAAM,KAAK,OAAO,OAAO;GAC/B,IAAI,KAAK;IACP,UAAU,IAAI;IACd,UAAU,SAAS,IAAI,KAAK,IAAI,KAAK;GACvC,OAAO;IACL,MAAM,IAAI,KAAK,YAAY,SAAS,OAAO;IAC3C,IAAI,GAAG,UAAU,SAAS,SAAS,CAAC;GACtC;EACF;EACA,WAAW;GACT,IAAI,OAAO,UAAU,IAAI;EAC3B;CACF;AACF;;;;;;;;;AC5GA,MAAa,iBACXC,gBAAAA"}

package/dist/index.d.cts

@@ -1,5 +1,6 @@
-import { a as SelectionHostCapability, c as SelectionRangeInput, f as TextPosition, h as SelectionSegment, i as SelectionEndpoint, l as SelectionSnapshot, n as SelectionAction, o as SelectionMenuAnchor, p as TextRange, r as SelectionCapability, u as SelectionState } from "./types-DtWaZIsm.cjs";
-import { CapabilityToken } from "@embedpdf/core";
+import { a as SelectionHostCapability, c as SelectionRangeInput, f as TextPosition, h as SelectionSegment, i as SelectionEndpoint, l as SelectionSnapshot, n as SelectionAction, o as SelectionMenuAnchor, p as TextRange, r as SelectionCapability, u as SelectionState } from "./types-BCPuB3iZ.cjs";
+import { CapabilityToken, PageObjectNumber } from "@embedpdf/core";
+import { Point, TextQuad } from "@embedpdf/core-geometry";
 //#region src/selection.plugin.d.ts
 /**
  * Text selection — document-scoped, requires the interaction hub. In `init` it
@@ -13,6 +14,76 @@ import { CapabilityToken } from "@embedpdf/core";
  */
 declare const selectionPlugin: () => import("@embedpdf/core").PluginDef<SelectionState, SelectionAction, SelectionHostCapability>;
 //#endregion
+//#region src/handles.d.ts
+/** What handle geometry & drags need from the hosting view. */
+interface SelectionHandleView {
+  /** Page content point → overlay px. Must be POINT-exact (compose
+   *  `pageToWorld` with `toScreen`); an AABB projector loses orientation. */
+  toOverlay(pon: PageObjectNumber, pt: Point): Point | null;
+  /** Overlay px → the page under it, or null over a gap. */
+  pageAt(overlay: Point): {
+    pon: PageObjectNumber;
+    point: Point;
+  } | null;
+  /** Overlay px → a SPECIFIC page's content space, unclamped. */
+  pointOnPage(pon: PageObjectNumber, overlay: Point): Point | null;
+}
+/** One selection boundary, as the handle needs it (a `SelectionEndpoint` slice). */
+interface SelectionHandleEndpoint {
+  pon: PageObjectNumber;
+  /** The boundary glyph's own oriented cell, page content space. */
+  glyphQuad: TextQuad;
+  /** Reading direction of its segment (+1 = the frame's +x) — decides which
+   *  side of the cell is the selection's leading edge. */
+  advance: 1 | -1;
+}
+/** The gesture verbs a handle drag drives — `SelectionHostCapability` satisfies it. */
+interface SelectionHandleTarget {
+  beginAt(pon: PageObjectNumber, point: Point): boolean;
+  extendTo(pon: PageObjectNumber, point: Point): void;
+  end(): void;
+}
+declare const HANDLE_HEAD = 12;
+declare const HANDLE_BAR = 2;
+declare const HANDLE_PAD = 14;
+interface SelectionHandleGeom {
+  /** The projected edge, ascent corner first, overlay px. */
+  bar: {
+    from: Point;
+    to: Point;
+  };
+  /** The glyph's ink height on screen — zoom scaling comes free. */
+  length: number;
+  /** Degrees clockwise; 0 when the text is upright on screen. */
+  rotation: number;
+  /** True within the epsilon of upright: render with NO transform. */
+  upright: boolean;
+  /** Centre of the grab head, overlay px. */
+  head: Point;
+}
+/**
+ * The handle's geometry for one endpoint, in overlay space. Null when the
+ * endpoint's page isn't laid out (or the cell is degenerate) — render nothing.
+ */
+declare function selectionHandleGeom(view: SelectionHandleView, ep: SelectionHandleEndpoint, role: 'start' | 'end'): SelectionHandleGeom | null;
+interface SelectionHandleDragSession {
+  /** Feed the pointer's current overlay position. */
+  move(overlay: Point): void;
+  /** The pointer released (or was cancelled): settle the gesture. */
+  end(): void;
+}
+/**
+ * One armed handle drag. Dragging a handle extends from the OPPOSITE
+ * endpoint: the first movement re-roots the selection gesture at that
+ * endpoint's cell centre, and every position then extends toward the pointer
+ * — snapping to glyphs and crossing pages exactly like a pointer drag,
+ * firing the same change/commit signals. Over a gap the point projects onto
+ * the last page hit (unclamped), so the selection keeps tracking instead of
+ * freezing at a page edge. `end()` commits only if the drag actually
+ * re-rooted; an untouched press settles nothing.
+ */
+declare function createSelectionHandleDrag(selection: SelectionHandleTarget, view: SelectionHandleView, opposite: SelectionHandleEndpoint, draggedPon: PageObjectNumber): SelectionHandleDragSession;
+//#endregion
 //#region src/index.d.ts
 /**
  * The selection capability token, narrowed to the public
@@ -22,5 +93,5 @@ declare const selectionPlugin: () => import("@embedpdf/core").PluginDef<Selectio
  */
 declare const SelectionToken: CapabilityToken<SelectionCapability>;
 //#endregion
-export { type SelectionCapability, type SelectionEndpoint, type SelectionMenuAnchor, type SelectionRangeInput, type SelectionSegment, type SelectionSnapshot, SelectionToken, type TextPosition, type TextRange, selectionPlugin };
+export { HANDLE_BAR, HANDLE_HEAD, HANDLE_PAD, type SelectionCapability, type SelectionEndpoint, type SelectionHandleDragSession, type SelectionHandleEndpoint, type SelectionHandleGeom, type SelectionHandleTarget, type SelectionHandleView, type SelectionMenuAnchor, type SelectionRangeInput, type SelectionSegment, type SelectionSnapshot, SelectionToken, type TextPosition, type TextRange, createSelectionHandleDrag, selectionHandleGeom, selectionPlugin };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-import { a as SelectionHostCapability, c as SelectionRangeInput, f as TextPosition, h as SelectionSegment, i as SelectionEndpoint, l as SelectionSnapshot, n as SelectionAction, o as SelectionMenuAnchor, p as TextRange, r as SelectionCapability, u as SelectionState } from "./types-DtWaZIsm.js";
-import { CapabilityToken } from "@embedpdf/core";
+import { a as SelectionHostCapability, c as SelectionRangeInput, f as TextPosition, h as SelectionSegment, i as SelectionEndpoint, l as SelectionSnapshot, n as SelectionAction, o as SelectionMenuAnchor, p as TextRange, r as SelectionCapability, u as SelectionState } from "./types-BCPuB3iZ.js";
+import { CapabilityToken, PageObjectNumber } from "@embedpdf/core";
+import { Point, TextQuad } from "@embedpdf/core-geometry";
 //#region src/selection.plugin.d.ts
 /**
  * Text selection — document-scoped, requires the interaction hub. In `init` it
@@ -13,6 +14,76 @@ import { CapabilityToken } from "@embedpdf/core";
  */
 declare const selectionPlugin: () => import("@embedpdf/core").PluginDef<SelectionState, SelectionAction, SelectionHostCapability>;
 //#endregion
+//#region src/handles.d.ts
+/** What handle geometry & drags need from the hosting view. */
+interface SelectionHandleView {
+  /** Page content point → overlay px. Must be POINT-exact (compose
+   *  `pageToWorld` with `toScreen`); an AABB projector loses orientation. */
+  toOverlay(pon: PageObjectNumber, pt: Point): Point | null;
+  /** Overlay px → the page under it, or null over a gap. */
+  pageAt(overlay: Point): {
+    pon: PageObjectNumber;
+    point: Point;
+  } | null;
+  /** Overlay px → a SPECIFIC page's content space, unclamped. */
+  pointOnPage(pon: PageObjectNumber, overlay: Point): Point | null;
+}
+/** One selection boundary, as the handle needs it (a `SelectionEndpoint` slice). */
+interface SelectionHandleEndpoint {
+  pon: PageObjectNumber;
+  /** The boundary glyph's own oriented cell, page content space. */
+  glyphQuad: TextQuad;
+  /** Reading direction of its segment (+1 = the frame's +x) — decides which
+   *  side of the cell is the selection's leading edge. */
+  advance: 1 | -1;
+}
+/** The gesture verbs a handle drag drives — `SelectionHostCapability` satisfies it. */
+interface SelectionHandleTarget {
+  beginAt(pon: PageObjectNumber, point: Point): boolean;
+  extendTo(pon: PageObjectNumber, point: Point): void;
+  end(): void;
+}
+declare const HANDLE_HEAD = 12;
+declare const HANDLE_BAR = 2;
+declare const HANDLE_PAD = 14;
+interface SelectionHandleGeom {
+  /** The projected edge, ascent corner first, overlay px. */
+  bar: {
+    from: Point;
+    to: Point;
+  };
+  /** The glyph's ink height on screen — zoom scaling comes free. */
+  length: number;
+  /** Degrees clockwise; 0 when the text is upright on screen. */
+  rotation: number;
+  /** True within the epsilon of upright: render with NO transform. */
+  upright: boolean;
+  /** Centre of the grab head, overlay px. */
+  head: Point;
+}
+/**
+ * The handle's geometry for one endpoint, in overlay space. Null when the
+ * endpoint's page isn't laid out (or the cell is degenerate) — render nothing.
+ */
+declare function selectionHandleGeom(view: SelectionHandleView, ep: SelectionHandleEndpoint, role: 'start' | 'end'): SelectionHandleGeom | null;
+interface SelectionHandleDragSession {
+  /** Feed the pointer's current overlay position. */
+  move(overlay: Point): void;
+  /** The pointer released (or was cancelled): settle the gesture. */
+  end(): void;
+}
+/**
+ * One armed handle drag. Dragging a handle extends from the OPPOSITE
+ * endpoint: the first movement re-roots the selection gesture at that
+ * endpoint's cell centre, and every position then extends toward the pointer
+ * — snapping to glyphs and crossing pages exactly like a pointer drag,
+ * firing the same change/commit signals. Over a gap the point projects onto
+ * the last page hit (unclamped), so the selection keeps tracking instead of
+ * freezing at a page edge. `end()` commits only if the drag actually
+ * re-rooted; an untouched press settles nothing.
+ */
+declare function createSelectionHandleDrag(selection: SelectionHandleTarget, view: SelectionHandleView, opposite: SelectionHandleEndpoint, draggedPon: PageObjectNumber): SelectionHandleDragSession;
+//#endregion
 //#region src/index.d.ts
 /**
  * The selection capability token, narrowed to the public
@@ -22,5 +93,5 @@ declare const selectionPlugin: () => import("@embedpdf/core").PluginDef<Selectio
  */
 declare const SelectionToken: CapabilityToken<SelectionCapability>;
 //#endregion
-export { type SelectionCapability, type SelectionEndpoint, type SelectionMenuAnchor, type SelectionRangeInput, type SelectionSegment, type SelectionSnapshot, SelectionToken, type TextPosition, type TextRange, selectionPlugin };
+export { HANDLE_BAR, HANDLE_HEAD, HANDLE_PAD, type SelectionCapability, type SelectionEndpoint, type SelectionHandleDragSession, type SelectionHandleEndpoint, type SelectionHandleGeom, type SelectionHandleTarget, type SelectionHandleView, type SelectionMenuAnchor, type SelectionRangeInput, type SelectionSegment, type SelectionSnapshot, SelectionToken, type TextPosition, type TextRange, createSelectionHandleDrag, selectionHandleGeom, selectionPlugin };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,6 +1,7 @@
-import { i as createSelectionCapability, l as SelectionToken$1, n as selectionReducer, r as createTextSelectHandler, t as initialSelectionState } from "./reducer-CZG2TZgo.js";
+import { i as createSelectionCapability, l as SelectionToken$1, n as selectionReducer, r as createTextSelectHandler, t as initialSelectionState } from "./reducer-BhLvJwVe.js";
 import { definePlugin } from "@embedpdf/core";
-import { InteractionToken } from "@embedpdf/plugin-interaction";
+import { FeedbackToken, InteractionToken } from "@embedpdf/plugin-interaction";
+import { textQuadEdge } from "@embedpdf/core-geometry";
 //#region src/selection.plugin.ts
 /**
 * Text selection — document-scoped, requires the interaction hub. In `init` it
@@ -17,16 +18,121 @@ const selectionPlugin = () => definePlugin({
 	token: SelectionToken$1,
 	scope: "document",
 	requires: [InteractionToken],
+	optional: [FeedbackToken],
 	initialState: initialSelectionState,
 	reduce: selectionReducer,
 	capability: createSelectionCapability,
 	init: (ctx) => {
 		const interaction = ctx.get(InteractionToken);
 		const selection = ctx.get(SelectionToken$1);
-		interaction.registerHandler(createTextSelectHandler(selection, interaction));
+		const feedback = ctx.tryGet(FeedbackToken);
+		interaction.registerHandler(createTextSelectHandler(selection, interaction, feedback ?? void 0));
 	}
 });
 //#endregion
+//#region src/handles.ts
+/**
+* Selection handles — the pure policy half (the `wheel.ts` convention).
+*
+* A handle IS the boundary glyph's leading (or trailing) edge: a segment
+* between two corners of the glyph's ORIENTED cell, with the grab head just
+* beyond the ascent at the start / past the baseline at the end. Bar length,
+* angle, and head all derive from that one segment, so rotated text and
+* rotated pages are carried by construction — the AABB never enters.
+*
+* Everything here is DOM-free and framework-free: geometry is pure given a
+* projector, and the drag session speaks the selection's own gesture verbs
+* (`beginAt`/`extendTo`/`end` — the same ones the pointer handler uses; a
+* handle drag IS a selection gesture, re-anchored). The framework adapters
+* keep only subscriptions and markup; the DOM listener mechanics live in
+* `@embedpdf/web`'s `attachSelectionHandle`.
+*
+* The view dependency is STRUCTURAL (satisfied by five lines over
+* `StageCapability`) so this plugin stays stage-free — selection also runs
+* in stage-less hosts (`PageView`) — and the math tests run against a fake.
+*/
+const HANDLE_HEAD = 12;
+const HANDLE_BAR = 2;
+const HANDLE_PAD = 14;
+/** Tilts within ~0.05° of upright render untransformed (float-noise guard —
+*  and the dominant case stays pixel-identical to an axis-aligned box). */
+const HANDLE_ROT_EPSILON = .05;
+const midpoint = (a, b) => ({
+	x: (a.x + b.x) / 2,
+	y: (a.y + b.y) / 2
+});
+/**
+* The handle's geometry for one endpoint, in overlay space. Null when the
+* endpoint's page isn't laid out (or the cell is degenerate) — render nothing.
+*/
+function selectionHandleGeom(view, ep, role) {
+	const leading = role === "start" ? ep.advance > 0 : ep.advance < 0;
+	const [upperPage, lowerPage] = textQuadEdge(ep.glyphQuad, leading ? "start" : "end");
+	const upper = view.toOverlay(ep.pon, upperPage);
+	const lower = view.toOverlay(ep.pon, lowerPage);
+	if (!upper || !lower) return null;
+	const dx = lower.x - upper.x;
+	const dy = lower.y - upper.y;
+	const length = Math.hypot(dx, dy);
+	if (length === 0) return null;
+	const rotation = Math.atan2(dy, dx) * 180 / Math.PI - 90;
+	const upright = Math.abs(rotation) < HANDLE_ROT_EPSILON;
+	const ux = dx / length;
+	const uy = dy / length;
+	const head = role === "start" ? {
+		x: upper.x - ux * 12 / 2,
+		y: upper.y - uy * 12 / 2
+	} : {
+		x: lower.x + ux * 12 / 2,
+		y: lower.y + uy * 12 / 2
+	};
+	return {
+		bar: {
+			from: upper,
+			to: lower
+		},
+		length,
+		rotation,
+		upright,
+		head
+	};
+}
+/**
+* One armed handle drag. Dragging a handle extends from the OPPOSITE
+* endpoint: the first movement re-roots the selection gesture at that
+* endpoint's cell centre, and every position then extends toward the pointer
+* — snapping to glyphs and crossing pages exactly like a pointer drag,
+* firing the same change/commit signals. Over a gap the point projects onto
+* the last page hit (unclamped), so the selection keeps tracking instead of
+* freezing at a page edge. `end()` commits only if the drag actually
+* re-rooted; an untouched press settles nothing.
+*/
+function createSelectionHandleDrag(selection, view, opposite, draggedPon) {
+	const q = opposite.glyphQuad;
+	const anchorPoint = midpoint(midpoint(q.upperStart, q.lowerEnd), midpoint(q.upperEnd, q.lowerStart));
+	let begun = false;
+	let lastPon = draggedPon;
+	return {
+		move: (overlay) => {
+			if (!begun) {
+				if (!selection.beginAt(opposite.pon, anchorPoint)) return;
+				begun = true;
+			}
+			const hit = view.pageAt(overlay);
+			if (hit) {
+				lastPon = hit.pon;
+				selection.extendTo(hit.pon, hit.point);
+			} else {
+				const p = view.pointOnPage(lastPon, overlay);
+				if (p) selection.extendTo(lastPon, p);
+			}
+		},
+		end: () => {
+			if (begun) selection.end();
+		}
+	};
+}
+//#endregion
 //#region src/index.ts
 /**
 * The selection capability token, narrowed to the public
@@ -36,6 +142,6 @@ const selectionPlugin = () => definePlugin({
 */
 const SelectionToken = SelectionToken$1;
 //#endregion
-export { SelectionToken, selectionPlugin };
+export { HANDLE_BAR, HANDLE_HEAD, HANDLE_PAD, SelectionToken, createSelectionHandleDrag, selectionHandleGeom, selectionPlugin };
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["SelectionToken","SelectionHostToken"],"sources":["../src/selection.plugin.ts","../src/index.ts"],"sourcesContent":["import { definePlugin } from '@embedpdf/core';\nimport { InteractionToken } from '@embedpdf/plugin-interaction';\nimport { createSelectionCapability } from './capability';\nimport { createTextSelectHandler } from './handler';\nimport { initialSelectionState, selectionReducer } from './reducer';\nimport { SelectionToken } from './types';\nimport type { SelectionAction, SelectionHostCapability, SelectionState } from './types';\n\n/**\n * Text selection — document-scoped, requires the interaction hub. In `init` it\n * registers ITS pointer handler with the hub; the hub owns the pointer stream\n * and arbitration. Works with `<Stage>` or a standalone `<PageView>` — selection\n * only needs the page coordinate context + the engine's text geometry.\n *\n * Registry/content invalidation is wired inside the capability itself\n * (revision watch + document event subscription), so headless/programmatic\n * use gets the same reconciliation as the full viewer.\n */\nexport const selectionPlugin = () =>\n  definePlugin<SelectionState, SelectionAction, SelectionHostCapability>({\n    id: 'selection',\n    token: SelectionToken,\n    scope: 'document',\n    requires: [InteractionToken],\n    initialState: initialSelectionState,\n    reduce: selectionReducer,\n    capability: createSelectionCapability,\n    init: (ctx) => {\n      const interaction = ctx.get(InteractionToken);\n      const selection = ctx.get(SelectionToken); // our own capability (built before init)\n      interaction.registerHandler(createTextSelectHandler(selection, interaction));\n    },\n  });\n","/**\n * @embedpdf/plugin-selection — text selection over the engine's text geometry.\n *\n * The PUBLIC surface: the plugin factory, the capability token (narrowed to\n * the public lens), and the range/read vocabulary. Selection ranges live in\n * CHARACTER space (half-open `TextRange` — the same space search hits\n * address), geometry needs `doc.text.select`, text extraction needs\n * `doc.text.copy`, and neither permission implies the other.\n *\n * Framework/host plumbing (gesture intents, geometry warming, the reducer,\n * the coordinate seam) lives behind `@embedpdf/plugin-selection/internal`.\n * Clipboard writes live in `@embedpdf/web` — this package is DOM-free.\n */\nimport type { CapabilityToken } from '@embedpdf/core';\nimport { SelectionToken as SelectionHostToken } from './types';\nimport type { SelectionCapability } from './types';\n\nexport { selectionPlugin } from './selection.plugin';\nexport type {\n  SelectionCapability,\n  SelectionEndpoint,\n  SelectionMenuAnchor,\n  SelectionRangeInput,\n  SelectionSnapshot,\n  TextPosition,\n  TextRange,\n} from './types';\nexport type { SelectionSegment } from './geometry';\n\n/**\n * The selection capability token, narrowed to the public\n * {@link SelectionCapability} lens. It is the SAME runtime token the plugin\n * provides — the host-only surface (pointer gestures, geometry warming) is\n * reachable only via `@embedpdf/plugin-selection/internal`.\n */\nexport const SelectionToken =\n  SelectionHostToken as unknown as CapabilityToken<SelectionCapability>;\n"],"mappings":";;;;;;;;;;;;;;AAkBA,MAAa,wBACX,aAAuE;CACrE,IAAI;CACJ,OAAOA;CACP,OAAO;CACP,UAAU,CAAC,gBAAgB;CAC3B,cAAc;CACd,QAAQ;CACR,YAAY;CACZ,OAAO,QAAQ;EACb,MAAM,cAAc,IAAI,IAAI,gBAAgB;EAC5C,MAAM,YAAY,IAAI,IAAIA,gBAAc;EACxC,YAAY,gBAAgB,wBAAwB,WAAW,WAAW,CAAC;CAC7E;AACF,CAAC;;;;;;;;;ACGH,MAAa,iBACXC"}
+{"version":3,"file":"index.js","names":["SelectionToken","SelectionHostToken"],"sources":["../src/selection.plugin.ts","../src/handles.ts","../src/index.ts"],"sourcesContent":["import { definePlugin } from '@embedpdf/core';\nimport { FeedbackToken, InteractionToken } from '@embedpdf/plugin-interaction';\nimport { createSelectionCapability } from './capability';\nimport { createTextSelectHandler } from './handler';\nimport { initialSelectionState, selectionReducer } from './reducer';\nimport { SelectionToken } from './types';\nimport type { SelectionAction, SelectionHostCapability, SelectionState } from './types';\n\n/**\n * Text selection — document-scoped, requires the interaction hub. In `init` it\n * registers ITS pointer handler with the hub; the hub owns the pointer stream\n * and arbitration. Works with `<Stage>` or a standalone `<PageView>` — selection\n * only needs the page coordinate context + the engine's text geometry.\n *\n * Registry/content invalidation is wired inside the capability itself\n * (revision watch + document event subscription), so headless/programmatic\n * use gets the same reconciliation as the full viewer.\n */\nexport const selectionPlugin = () =>\n  definePlugin<SelectionState, SelectionAction, SelectionHostCapability>({\n    id: 'selection',\n    token: SelectionToken,\n    scope: 'document',\n    requires: [InteractionToken],\n    // Platform feedback (haptics) is OPTIONAL: absent in headless setups, the\n    // handler simply never buzzes.\n    optional: [FeedbackToken],\n    initialState: initialSelectionState,\n    reduce: selectionReducer,\n    capability: createSelectionCapability,\n    init: (ctx) => {\n      const interaction = ctx.get(InteractionToken);\n      const selection = ctx.get(SelectionToken); // our own capability (built before init)\n      const feedback = ctx.tryGet(FeedbackToken);\n      interaction.registerHandler(\n        createTextSelectHandler(selection, interaction, feedback ?? undefined),\n      );\n    },\n  });\n","/**\n * Selection handles — the pure policy half (the `wheel.ts` convention).\n *\n * A handle IS the boundary glyph's leading (or trailing) edge: a segment\n * between two corners of the glyph's ORIENTED cell, with the grab head just\n * beyond the ascent at the start / past the baseline at the end. Bar length,\n * angle, and head all derive from that one segment, so rotated text and\n * rotated pages are carried by construction — the AABB never enters.\n *\n * Everything here is DOM-free and framework-free: geometry is pure given a\n * projector, and the drag session speaks the selection's own gesture verbs\n * (`beginAt`/`extendTo`/`end` — the same ones the pointer handler uses; a\n * handle drag IS a selection gesture, re-anchored). The framework adapters\n * keep only subscriptions and markup; the DOM listener mechanics live in\n * `@embedpdf/web`'s `attachSelectionHandle`.\n *\n * The view dependency is STRUCTURAL (satisfied by five lines over\n * `StageCapability`) so this plugin stays stage-free — selection also runs\n * in stage-less hosts (`PageView`) — and the math tests run against a fake.\n */\nimport { textQuadEdge } from '@embedpdf/core-geometry';\nimport type { Point, TextQuad } from '@embedpdf/core-geometry';\nimport type { PageObjectNumber } from '@embedpdf/core';\n\n/** What handle geometry & drags need from the hosting view. */\nexport interface SelectionHandleView {\n  /** Page content point → overlay px. Must be POINT-exact (compose\n   *  `pageToWorld` with `toScreen`); an AABB projector loses orientation. */\n  toOverlay(pon: PageObjectNumber, pt: Point): Point | null;\n  /** Overlay px → the page under it, or null over a gap. */\n  pageAt(overlay: Point): { pon: PageObjectNumber; point: Point } | null;\n  /** Overlay px → a SPECIFIC page's content space, unclamped. */\n  pointOnPage(pon: PageObjectNumber, overlay: Point): Point | null;\n}\n\n/** One selection boundary, as the handle needs it (a `SelectionEndpoint` slice). */\nexport interface SelectionHandleEndpoint {\n  pon: PageObjectNumber;\n  /** The boundary glyph's own oriented cell, page content space. */\n  glyphQuad: TextQuad;\n  /** Reading direction of its segment (+1 = the frame's +x) — decides which\n   *  side of the cell is the selection's leading edge. */\n  advance: 1 | -1;\n}\n\n/** The gesture verbs a handle drag drives — `SelectionHostCapability` satisfies it. */\nexport interface SelectionHandleTarget {\n  beginAt(pon: PageObjectNumber, point: Point): boolean;\n  extendTo(pon: PageObjectNumber, point: Point): void;\n  end(): void;\n}\n\n// The iOS caret-handle design, one source for every adapter: a thin BAR that\n// is the selection's edge, capped by a screen-constant circle; PAD is the\n// invisible finger padding around the visual.\nexport const HANDLE_HEAD = 12; // px — the circle\nexport const HANDLE_BAR = 2; // px — the caret bar\nexport const HANDLE_PAD = 14; // px — grab padding\n\n/** Tilts within ~0.05° of upright render untransformed (float-noise guard —\n *  and the dominant case stays pixel-identical to an axis-aligned box). */\nconst HANDLE_ROT_EPSILON = 0.05;\n\nexport interface SelectionHandleGeom {\n  /** The projected edge, ascent corner first, overlay px. */\n  bar: { from: Point; to: Point };\n  /** The glyph's ink height on screen — zoom scaling comes free. */\n  length: number;\n  /** Degrees clockwise; 0 when the text is upright on screen. */\n  rotation: number;\n  /** True within the epsilon of upright: render with NO transform. */\n  upright: boolean;\n  /** Centre of the grab head, overlay px. */\n  head: Point;\n}\n\nconst midpoint = (a: Point, b: Point): Point => ({ x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 });\n\n/**\n * The handle's geometry for one endpoint, in overlay space. Null when the\n * endpoint's page isn't laid out (or the cell is degenerate) — render nothing.\n */\nexport function selectionHandleGeom(\n  view: SelectionHandleView,\n  ep: SelectionHandleEndpoint,\n  role: 'start' | 'end',\n): SelectionHandleGeom | null {\n  // Which SIDE of the cell is this selection's edge is a reading-order\n  // question (`advance`), never a geometric one.\n  const leading = role === 'start' ? ep.advance > 0 : ep.advance < 0;\n  const [upperPage, lowerPage] = textQuadEdge(ep.glyphQuad, leading ? 'start' : 'end');\n  const upper = view.toOverlay(ep.pon, upperPage);\n  const lower = view.toOverlay(ep.pon, lowerPage);\n  if (!upper || !lower) return null;\n  const dx = lower.x - upper.x;\n  const dy = lower.y - upper.y;\n  const length = Math.hypot(dx, dy);\n  if (length === 0) return null;\n  // 0° when the text is upright: the bar runs straight down the screen.\n  const rotation = (Math.atan2(dy, dx) * 180) / Math.PI - 90;\n  const upright = Math.abs(rotation) < HANDLE_ROT_EPSILON;\n  const ux = dx / length;\n  const uy = dy / length;\n  const head =\n    role === 'start'\n      ? { x: upper.x - (ux * HANDLE_HEAD) / 2, y: upper.y - (uy * HANDLE_HEAD) / 2 }\n      : { x: lower.x + (ux * HANDLE_HEAD) / 2, y: lower.y + (uy * HANDLE_HEAD) / 2 };\n  return { bar: { from: upper, to: lower }, length, rotation, upright, head };\n}\n\nexport interface SelectionHandleDragSession {\n  /** Feed the pointer's current overlay position. */\n  move(overlay: Point): void;\n  /** The pointer released (or was cancelled): settle the gesture. */\n  end(): void;\n}\n\n/**\n * One armed handle drag. Dragging a handle extends from the OPPOSITE\n * endpoint: the first movement re-roots the selection gesture at that\n * endpoint's cell centre, and every position then extends toward the pointer\n * — snapping to glyphs and crossing pages exactly like a pointer drag,\n * firing the same change/commit signals. Over a gap the point projects onto\n * the last page hit (unclamped), so the selection keeps tracking instead of\n * freezing at a page edge. `end()` commits only if the drag actually\n * re-rooted; an untouched press settles nothing.\n */\nexport function createSelectionHandleDrag(\n  selection: SelectionHandleTarget,\n  view: SelectionHandleView,\n  opposite: SelectionHandleEndpoint,\n  draggedPon: PageObjectNumber,\n): SelectionHandleDragSession {\n  // The fixed anchor: the opposite endpoint's cell CENTRE — orientation-free\n  // (a parallelogram's diagonal midpoints coincide), so it lands inside the\n  // glyph for rotated text too.\n  const q = opposite.glyphQuad;\n  const anchorPoint = midpoint(midpoint(q.upperStart, q.lowerEnd), midpoint(q.upperEnd, q.lowerStart));\n  let begun = false;\n  let lastPon = draggedPon;\n  return {\n    move: (overlay) => {\n      if (!begun) {\n        if (!selection.beginAt(opposite.pon, anchorPoint)) return;\n        begun = true;\n      }\n      const hit = view.pageAt(overlay);\n      if (hit) {\n        lastPon = hit.pon;\n        selection.extendTo(hit.pon, hit.point);\n      } else {\n        const p = view.pointOnPage(lastPon, overlay);\n        if (p) selection.extendTo(lastPon, p);\n      }\n    },\n    end: () => {\n      if (begun) selection.end(); // settle → menu reappears, onCommit fires\n    },\n  };\n}\n","/**\n * @embedpdf/plugin-selection — text selection over the engine's text geometry.\n *\n * The PUBLIC surface: the plugin factory, the capability token (narrowed to\n * the public lens), and the range/read vocabulary. Selection ranges live in\n * CHARACTER space (half-open `TextRange` — the same space search hits\n * address), geometry needs `doc.text.select`, text extraction needs\n * `doc.text.copy`, and neither permission implies the other.\n *\n * Framework/host plumbing (gesture intents, geometry warming, the reducer,\n * the coordinate seam) lives behind `@embedpdf/plugin-selection/internal`.\n * Clipboard writes live in `@embedpdf/web` — this package is DOM-free.\n */\nimport type { CapabilityToken } from '@embedpdf/core';\nimport { SelectionToken as SelectionHostToken } from './types';\nimport type { SelectionCapability } from './types';\n\nexport { selectionPlugin } from './selection.plugin';\nexport type {\n  SelectionCapability,\n  SelectionEndpoint,\n  SelectionMenuAnchor,\n  SelectionRangeInput,\n  SelectionSnapshot,\n  TextPosition,\n  TextRange,\n} from './types';\nexport type { SelectionSegment } from './geometry';\n// Selection-handle policy (the touch affordance): pure geometry + the drag\n// session, consumed by the framework adapters' handle views.\nexport {\n  HANDLE_BAR,\n  HANDLE_HEAD,\n  HANDLE_PAD,\n  createSelectionHandleDrag,\n  selectionHandleGeom,\n} from './handles';\nexport type {\n  SelectionHandleDragSession,\n  SelectionHandleEndpoint,\n  SelectionHandleGeom,\n  SelectionHandleTarget,\n  SelectionHandleView,\n} from './handles';\n\n/**\n * The selection capability token, narrowed to the public\n * {@link SelectionCapability} lens. It is the SAME runtime token the plugin\n * provides — the host-only surface (pointer gestures, geometry warming) is\n * reachable only via `@embedpdf/plugin-selection/internal`.\n */\nexport const SelectionToken =\n  SelectionHostToken as unknown as CapabilityToken<SelectionCapability>;\n"],"mappings":";;;;;;;;;;;;;;;AAkBA,MAAa,wBACX,aAAuE;CACrE,IAAI;CACJ,OAAOA;CACP,OAAO;CACP,UAAU,CAAC,gBAAgB;CAG3B,UAAU,CAAC,aAAa;CACxB,cAAc;CACd,QAAQ;CACR,YAAY;CACZ,OAAO,QAAQ;EACb,MAAM,cAAc,IAAI,IAAI,gBAAgB;EAC5C,MAAM,YAAY,IAAI,IAAIA,gBAAc;EACxC,MAAM,WAAW,IAAI,OAAO,aAAa;EACzC,YAAY,gBACV,wBAAwB,WAAW,aAAa,YAAY,KAAA,CAAS,CACvE;CACF;AACF,CAAC;;;;;;;;;;;;;;;;;;;;;;;ACiBH,MAAa,cAAc;AAC3B,MAAa,aAAa;AAC1B,MAAa,aAAa;;;AAI1B,MAAM,qBAAqB;AAe3B,MAAM,YAAY,GAAU,OAAqB;CAAE,IAAI,EAAE,IAAI,EAAE,KAAK;CAAG,IAAI,EAAE,IAAI,EAAE,KAAK;AAAE;;;;;AAM1F,SAAgB,oBACd,MACA,IACA,MAC4B;CAG5B,MAAM,UAAU,SAAS,UAAU,GAAG,UAAU,IAAI,GAAG,UAAU;CACjE,MAAM,CAAC,WAAW,aAAa,aAAa,GAAG,WAAW,UAAU,UAAU,KAAK;CACnF,MAAM,QAAQ,KAAK,UAAU,GAAG,KAAK,SAAS;CAC9C,MAAM,QAAQ,KAAK,UAAU,GAAG,KAAK,SAAS;CAC9C,IAAI,CAAC,SAAS,CAAC,OAAO,OAAO;CAC7B,MAAM,KAAK,MAAM,IAAI,MAAM;CAC3B,MAAM,KAAK,MAAM,IAAI,MAAM;CAC3B,MAAM,SAAS,KAAK,MAAM,IAAI,EAAE;CAChC,IAAI,WAAW,GAAG,OAAO;CAEzB,MAAM,WAAY,KAAK,MAAM,IAAI,EAAE,IAAI,MAAO,KAAK,KAAK;CACxD,MAAM,UAAU,KAAK,IAAI,QAAQ,IAAI;CACrC,MAAM,KAAK,KAAK;CAChB,MAAM,KAAK,KAAK;CAChB,MAAM,OACJ,SAAS,UACL;EAAE,GAAG,MAAM,IAAK,KAAA,KAAoB;EAAG,GAAG,MAAM,IAAK,KAAA,KAAoB;CAAE,IAC3E;EAAE,GAAG,MAAM,IAAK,KAAA,KAAoB;EAAG,GAAG,MAAM,IAAK,KAAA,KAAoB;CAAE;CACjF,OAAO;EAAE,KAAK;GAAE,MAAM;GAAO,IAAI;EAAM;EAAG;EAAQ;EAAU;EAAS;CAAK;AAC5E;;;;;;;;;;;AAmBA,SAAgB,0BACd,WACA,MACA,UACA,YAC4B;CAI5B,MAAM,IAAI,SAAS;CACnB,MAAM,cAAc,SAAS,SAAS,EAAE,YAAY,EAAE,QAAQ,GAAG,SAAS,EAAE,UAAU,EAAE,UAAU,CAAC;CACnG,IAAI,QAAQ;CACZ,IAAI,UAAU;CACd,OAAO;EACL,OAAO,YAAY;GACjB,IAAI,CAAC,OAAO;IACV,IAAI,CAAC,UAAU,QAAQ,SAAS,KAAK,WAAW,GAAG;IACnD,QAAQ;GACV;GACA,MAAM,MAAM,KAAK,OAAO,OAAO;GAC/B,IAAI,KAAK;IACP,UAAU,IAAI;IACd,UAAU,SAAS,IAAI,KAAK,IAAI,KAAK;GACvC,OAAO;IACL,MAAM,IAAI,KAAK,YAAY,SAAS,OAAO;IAC3C,IAAI,GAAG,UAAU,SAAS,SAAS,CAAC;GACtC;EACF;EACA,WAAW;GACT,IAAI,OAAO,UAAU,IAAI;EAC3B;CACF;AACF;;;;;;;;;AC5GA,MAAa,iBACXC"}

package/dist/internal.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_reducer = require("./reducer-Dyf8p5h-.cjs");
+const require_reducer = require("./reducer-B6uL_O7s.cjs");
 exports.SelectionToken = require_reducer.SelectionToken;
 exports.buildSelectionPageGeometry = require_reducer.buildSelectionPageGeometry;
 exports.contentPointToPdf = require_reducer.contentPointToPdf;

package/dist/internal.d.cts

@@ -1,6 +1,6 @@
-import { _ as contentPointToPdf, a as SelectionHostCapability, d as SelectionToken, g as buildSelectionPageGeometry, m as SelectionPageGeometry, n as SelectionAction, s as SelectionRange, t as GlyphPointer, u as SelectionState, v as toContentSegment, y as toContentTextQuad } from "./types-DtWaZIsm.cjs";
+import { _ as contentPointToPdf, a as SelectionHostCapability, d as SelectionToken, g as buildSelectionPageGeometry, m as SelectionPageGeometry, n as SelectionAction, s as SelectionRange, t as GlyphPointer, u as SelectionState, v as toContentSegment, y as toContentTextQuad } from "./types-BCPuB3iZ.cjs";
 import { PluginContext } from "@embedpdf/core";
-import { InteractionCapability, InteractionHandler } from "@embedpdf/plugin-interaction";
+import { InteractionCapability, InteractionHandler, PlatformFeedback } from "@embedpdf/plugin-interaction";
 //#region src/capability.d.ts
 /**
  * The selection capability — ONE closure returning the host lens (the
@@ -52,7 +52,7 @@ declare function createSelectionCapability(ctx: PluginContext<SelectionState, Se
  *  - down off-text       → deselect, and DON'T capture (so it can't block)
  *  - hover               → I-beam only when over text, else the pointer cursor
  */
-declare function createTextSelectHandler(selection: SelectionHostCapability, interaction: InteractionCapability): InteractionHandler;
+declare function createTextSelectHandler(selection: SelectionHostCapability, interaction: InteractionCapability, feedback?: PlatformFeedback): InteractionHandler;
 //#endregion
 //#region src/reducer.d.ts
 declare const initialSelectionState: SelectionState;

package/dist/internal.d.ts

@@ -1,6 +1,6 @@
-import { _ as contentPointToPdf, a as SelectionHostCapability, d as SelectionToken, g as buildSelectionPageGeometry, m as SelectionPageGeometry, n as SelectionAction, s as SelectionRange, t as GlyphPointer, u as SelectionState, v as toContentSegment, y as toContentTextQuad } from "./types-DtWaZIsm.js";
+import { _ as contentPointToPdf, a as SelectionHostCapability, d as SelectionToken, g as buildSelectionPageGeometry, m as SelectionPageGeometry, n as SelectionAction, s as SelectionRange, t as GlyphPointer, u as SelectionState, v as toContentSegment, y as toContentTextQuad } from "./types-BCPuB3iZ.js";
 import { PluginContext } from "@embedpdf/core";
-import { InteractionCapability, InteractionHandler } from "@embedpdf/plugin-interaction";
+import { InteractionCapability, InteractionHandler, PlatformFeedback } from "@embedpdf/plugin-interaction";
 //#region src/capability.d.ts
 /**
  * The selection capability — ONE closure returning the host lens (the
@@ -52,7 +52,7 @@ declare function createSelectionCapability(ctx: PluginContext<SelectionState, Se
  *  - down off-text       → deselect, and DON'T capture (so it can't block)
  *  - hover               → I-beam only when over text, else the pointer cursor
  */
-declare function createTextSelectHandler(selection: SelectionHostCapability, interaction: InteractionCapability): InteractionHandler;
+declare function createTextSelectHandler(selection: SelectionHostCapability, interaction: InteractionCapability, feedback?: PlatformFeedback): InteractionHandler;
 //#endregion
 //#region src/reducer.d.ts
 declare const initialSelectionState: SelectionState;

package/dist/internal.js

@@ -1,2 +1,2 @@
-import { a as buildSelectionPageGeometry, c as toContentTextQuad, i as createSelectionCapability, l as SelectionToken, n as selectionReducer, o as contentPointToPdf, r as createTextSelectHandler, s as toContentSegment, t as initialSelectionState } from "./reducer-CZG2TZgo.js";
+import { a as buildSelectionPageGeometry, c as toContentTextQuad, i as createSelectionCapability, l as SelectionToken, n as selectionReducer, o as contentPointToPdf, r as createTextSelectHandler, s as toContentSegment, t as initialSelectionState } from "./reducer-BhLvJwVe.js";
 export { SelectionToken, buildSelectionPageGeometry, contentPointToPdf, createSelectionCapability, createTextSelectHandler, initialSelectionState, selectionReducer, toContentSegment, toContentTextQuad };