@wow-two-beta/ui-vue 0.0.5 → 0.0.6

package/dist/foundation/gestures/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../src/foundation/gestures/SwipeDirection.ts","../../../src/foundation/gestures/GestureAxis.ts","../../../src/foundation/gestures/GestureMath.ts","../../../src/foundation/gestures/UseDrag.ts","../../../src/foundation/gestures/UseSwipe.ts","../../../src/foundation/gestures/UseLongPress.ts","../../../src/foundation/gestures/UsePinch.ts"],"sourcesContent":["// The swipe vocabulary, kept in its own file so a consumer can `switch` on `SwipeDirection.Left` without pulling\n// Vue into a pure module — the same value/composable split `foundation/device` uses for `PointerType` vs `UsePointer`.\n//\n// SCREEN AXES, NOT READING ORDER. `Up` means \"toward smaller `clientY`\", which is what the pointer actually did.\n// A right-to-left locale does not flip these; a consumer that wants \"swipe toward the start of the line\" maps\n// `Left`/`Right` through its own direction context. Baking RTL in here would make the same finger motion report\n// two different directions depending on a document attribute the pointer knows nothing about.\n\n/** Which way a swipe travelled, in screen coordinates. */\nexport const SwipeDirection = {\n  /** Toward smaller `clientX` — the pointer moved left across the screen. */\n  Left: 'left',\n  /** Toward larger `clientX` — the pointer moved right across the screen. */\n  Right: 'right',\n  /** Toward smaller `clientY` — the pointer moved up the screen. */\n  Up: 'up',\n  /** Toward larger `clientY` — the pointer moved down the screen. */\n  Down: 'down',\n} as const;\n\n/** One of the {@link SwipeDirection} values. */\nexport type SwipeDirection = (typeof SwipeDirection)[keyof typeof SwipeDirection];\n","// The axis-constraint vocabulary. Separate from the composables for the same reason as `SwipeDirection` — a pure module\n// (and the threshold math in `GestureMath`) needs these values without importing Vue.\n//\n// An axis does TWO things at once, and both matter: it gates RECOGNITION (a vertical twitch must not start an\n// `axis: 'x'` drag, or a horizontal carousel steals the page's scroll) and it constrains the REPORTED delta (the\n// off-axis component is zeroed, so a consumer can bind `dx` straight to a transform without re-clamping it).\n\n/** Which axis a gesture is constrained to. */\nexport const GestureAxis = {\n  /** Horizontal only — vertical movement neither triggers recognition nor appears in the payload. */\n  X: 'x',\n  /** Vertical only — horizontal movement neither triggers recognition nor appears in the payload. */\n  Y: 'y',\n  /** Unconstrained — recognition uses straight-line distance and both deltas are reported. */\n  Both: 'both',\n} as const;\n\n/** One of the {@link GestureAxis} values. */\nexport type GestureAxis = (typeof GestureAxis)[keyof typeof GestureAxis];\n","// The pure core of the gestures slice: every recognition decision — direction, velocity, scale, rotation, and each\n// threshold gate — computed from plain numbers, with no DOM, no Vue, and no time source of its own.\n//\n// WHY THE MATH IS SPLIT OUT AT ALL: gesture bugs are almost never listener bugs, they are ARITHMETIC bugs — a\n// diagonal that resolves to the wrong axis, a velocity that divides by a zero interval, a rotation that jumps 350°\n// instead of reporting -10°. Those are exactly the cases that are miserable to reach through a synthesized pointer\n// stream and trivial to pin as a table of inputs. The composables in this slice are deliberately thin wrappers so that\n// the part which can be exhaustively tested, is.\n//\n// TWO CONVENTIONS TO KNOW BEFORE READING ANY SIGNATURE:\n//\n//  - VELOCITY IS PX PER MILLISECOND, not px/s. Every duration in this slice arrives as `elapsedMs` (that is what\n//    the event timeline hands over), so px/ms keeps the unit chain honest with no hidden ×1000. For calibration:\n//    a deliberate flick lands near 0.5–2 px/ms, a slow drag well under 0.1.\n//\n//  - COORDINATES ARE SCREEN AXES. `y` grows DOWNWARD (the DOM's convention, not the maths class's), so a positive\n//    `dy` is a downward move and `pointerAngle` rotates clockwise. Every function here follows the DOM rather than\n//    silently flipping a sign, because the inputs come from `clientX`/`clientY` and the outputs go back to CSS.\n//\n// NOTHING HERE THROWS. A degenerate input — a zero elapsed time, a pinch that starts with both pointers on the\n// same pixel, a non-finite coordinate from a synthetic event — returns the identity answer (0 velocity, scale 1,\n// no direction) rather than an exception or a `NaN` that poisons a transform downstream. A gesture recognizer\n// firing mid-interaction has no caller in a position to catch anything.\n\nimport { PressExtensions } from '../utils/PressExtensions';\n\nimport { GestureAxis } from './GestureAxis';\nimport { SwipeDirection } from './SwipeDirection';\n\n/** A point in screen coordinates — `clientX` / `clientY` as reported by a pointer event. */\nexport interface GesturePoint {\n  /** Horizontal position in CSS pixels, growing rightward. */\n  readonly x: number;\n  /** Vertical position in CSS pixels, growing DOWNWARD. */\n  readonly y: number;\n}\n\n/** A point plus the moment it was observed — one entry in a gesture's trailing movement history. */\nexport interface GestureSample extends GesturePoint {\n  /** Timestamp in milliseconds, from the source event's `timeStamp`. Only differences are ever used. */\n  readonly t: number;\n}\n\n/** Radians-per-degree conversion, hoisted so the trig helpers don't recompute it per call. */\nconst DEGREES_PER_RADIAN = 180 / Math.PI;\n\n/** Guards a coordinate/delta against `NaN` and `Infinity`, which a synthetic event can carry in. */\nfunction finiteOrZero(value: number): number {\n  return Number.isFinite(value) ? value : 0;\n}\n\n/**\n * Speed along one axis, in CSS pixels per millisecond.\n *\n * Returns `0` for a non-positive or non-finite interval — two pointer events can share a timestamp, and a gesture\n * must not report infinite speed because the clock did not tick.\n *\n * @param delta Distance travelled on the axis, in CSS pixels. Sign is preserved, so the result is signed too.\n * @param elapsedMs Time the movement took, in milliseconds.\n * @returns Signed velocity in px/ms; `0` when `elapsedMs <= 0`.\n */\nexport function gestureVelocity(delta: number, elapsedMs: number): number {\n  if (!Number.isFinite(elapsedMs) || elapsedMs <= 0) return 0;\n  return finiteOrZero(delta) / elapsedMs;\n}\n\n/**\n * Velocity over the tail of a movement history, which is what \"was that a flick\" actually asks.\n *\n * Neither naive reading works. Measuring across the WHOLE gesture reports a fast release that followed a long\n * slow drag as slow. Measuring the LAST PAIR of samples is worse: `pointerup` repeats the final `pointermove`\n * coordinates a few milliseconds later, so a genuine flick would end at exactly zero — the single most common\n * way a swipe recognizer silently stops working. Two rules together fix both:\n *\n *  1. A TRAILING RUN OF STATIONARY SAMPLES IS TRIMMED. A sample at the same position as its predecessor carries\n *     no speed information, so measurement ends at the last point the pointer actually moved.\n *  2. UNLESS THE POINTER REALLY STOPPED. If that last moving sample is further back than the window, the trim is\n *     abandoned and the answer is zero: pressing, flicking, HOLDING, then releasing is not a flick, and rule 1\n *     alone would report the stale speed from before the hold.\n *\n * Between those, the base is the oldest sample still inside the window; when everything earlier has aged out, the\n * immediately-preceding sample is used instead, so a slow drag still reports its real (small) speed.\n *\n * @param samples Chronological history, oldest first; the last entry is treated as \"now\".\n * @param windowMs How far back to reach, in milliseconds.\n * @returns Signed px/ms on each axis; both `0` when fewer than two samples exist or the pointer had come to rest.\n */\nexport function windowedVelocity(\n  samples: readonly GestureSample[],\n  windowMs: number,\n): { readonly velocityX: number; readonly velocityY: number } {\n  const still = { velocityX: 0, velocityY: 0 };\n  const last = samples.at(-1);\n  if (last === undefined) return still;\n\n  const limit = Number.isFinite(windowMs) ? Math.max(0, windowMs) : 0;\n\n  // Rule 1 — walk back over samples that did not move.\n  let tipIndex = samples.length - 1;\n  while (tipIndex > 0) {\n    const current = samples[tipIndex];\n    const previous = samples[tipIndex - 1];\n    if (current === undefined || previous === undefined) break;\n    if (current.x !== previous.x || current.y !== previous.y) break;\n    tipIndex -= 1;\n  }\n  const tip = samples[tipIndex];\n  if (tip === undefined) return still;\n\n  // Rule 2 — the pointer came to rest and stayed there for longer than the window.\n  if (last.t - tip.t > limit) return still;\n\n  // Chronological order means the first entry inside the window is also the oldest one inside it.\n  let baseIndex = tipIndex;\n  for (let index = 0; index <= tipIndex; index += 1) {\n    const candidate = samples[index];\n    if (candidate === undefined) continue;\n    if (tip.t - candidate.t <= limit) {\n      baseIndex = index;\n      break;\n    }\n  }\n  if (baseIndex === tipIndex) baseIndex -= 1; // everything earlier aged out — fall back to the previous sample\n\n  const base = samples[baseIndex];\n  if (base === undefined) return still;\n\n  const elapsed = tip.t - base.t;\n  return {\n    velocityX: gestureVelocity(tip.x - base.x, elapsed),\n    velocityY: gestureVelocity(tip.y - base.y, elapsed),\n  };\n}\n\n/**\n * Resolves a two-axis displacement to the single direction a swipe reads as.\n *\n * The dominant axis wins. An exact diagonal (`|dx| === |dy|`, both non-zero) is broken toward the HORIZONTAL axis\n * — an arbitrary but fixed choice, made so the answer is deterministic rather than dependent on argument order;\n * a caller that needs the other bias should compare the deltas itself.\n *\n * @param dx Horizontal displacement in CSS pixels; negative is leftward.\n * @param dy Vertical displacement in CSS pixels; negative is upward.\n * @returns The dominant {@link SwipeDirection}, or `null` when there was no movement at all.\n */\nexport function swipeDirection(dx: number, dy: number): SwipeDirection | null {\n  const x = finiteOrZero(dx);\n  const y = finiteOrZero(dy);\n  if (x === 0 && y === 0) return null;\n\n  // `>=` is what implements the documented horizontal tie-break.\n  if (Math.abs(x) >= Math.abs(y)) return x < 0 ? SwipeDirection.Left : SwipeDirection.Right;\n  return y < 0 ? SwipeDirection.Up : SwipeDirection.Down;\n}\n\n/**\n * Straight-line distance between two points, in CSS pixels.\n *\n * @param a First point.\n * @param b Second point.\n * @returns The non-negative distance; `0` if either coordinate is non-finite.\n */\nexport function pointerDistance(a: GesturePoint, b: GesturePoint): number {\n  return Math.hypot(finiteOrZero(b.x) - finiteOrZero(a.x), finiteOrZero(b.y) - finiteOrZero(a.y));\n}\n\n/**\n * Angle of the line from `a` to `b`, in degrees.\n *\n * Measured from the positive x-axis and rotating CLOCKWISE, because `y` grows downward on screen: `0` points\n * right, `90` points down, `-90` points up.\n *\n * @param a Origin point.\n * @param b Target point.\n * @returns The angle in degrees, within `[-180, 180]`.\n */\nexport function pointerAngle(a: GesturePoint, b: GesturePoint): number {\n  const dx = finiteOrZero(b.x) - finiteOrZero(a.x);\n  const dy = finiteOrZero(b.y) - finiteOrZero(a.y);\n  return Math.atan2(dy, dx) * DEGREES_PER_RADIAN;\n}\n\n/**\n * Midpoint of two points — the anchor a pinch should scale and rotate about.\n *\n * @param a First point.\n * @param b Second point.\n * @returns The midpoint in the same screen coordinates.\n */\nexport function pointerCenter(a: GesturePoint, b: GesturePoint): GesturePoint {\n  return {\n    x: (finiteOrZero(a.x) + finiteOrZero(b.x)) / 2,\n    y: (finiteOrZero(a.y) + finiteOrZero(b.y)) / 2,\n  };\n}\n\n/**\n * Scale factor of a pinch — how far apart the two pointers are now, relative to where they started.\n *\n * `1` means unchanged, `2` means the fingers doubled their separation, `0.5` means they halved it.\n *\n * Returns `1` for a non-positive starting distance: two pointers that went down on the same pixel define no\n * baseline to scale against, and dividing by it would hand a consumer `Infinity` to write into a transform.\n *\n * @param startDistance Separation when the pinch began, in CSS pixels.\n * @param currentDistance Separation now, in CSS pixels.\n * @returns The multiplicative scale factor; `1` when no valid baseline exists.\n */\nexport function pinchScale(startDistance: number, currentDistance: number): number {\n  if (!Number.isFinite(startDistance) || startDistance <= 0) return 1;\n  return finiteOrZero(currentDistance) / startDistance;\n}\n\n/**\n * Signed rotation of a pinch, in degrees, taking the shortest way round.\n *\n * Crossing the ±180° seam is the whole reason this is not a subtraction: a pointer pair rotating from 170° to\n * -170° turned 20° clockwise, not 340° counter-clockwise.\n *\n * @param startAngle Angle between the pointers when the pinch began, in degrees.\n * @param currentAngle Angle between them now, in degrees.\n * @returns The rotation in degrees within `[-180, 180)`; positive is clockwise on screen.\n */\nexport function pinchRotation(startAngle: number, currentAngle: number): number {\n  return normalizeAngle(finiteOrZero(currentAngle) - finiteOrZero(startAngle));\n}\n\n/**\n * Wraps an arbitrary angle into a single turn.\n *\n * @param degrees Any angle, including multiples of a full turn.\n * @returns The equivalent angle within `[-180, 180)` — note `180` normalizes to `-180`.\n */\nexport function normalizeAngle(degrees: number): number {\n  const value = finiteOrZero(degrees);\n  // Double-modulo: the inner one can go negative in JS, the `+ 360` pass fixes that before re-centring on zero.\n  return ((((value + 180) % 360) + 360) % 360) - 180;\n}\n\n/**\n * Zeroes the component a constrained gesture must not report, so a consumer can bind the payload straight to a\n * transform without re-clamping it.\n *\n * @param dx Horizontal displacement in CSS pixels.\n * @param dy Vertical displacement in CSS pixels.\n * @param axis The axis the gesture is locked to.\n * @returns The displacement with the off-axis component set to `0`.\n */\nexport function constrainToAxis(\n  dx: number,\n  dy: number,\n  axis: GestureAxis,\n): { readonly dx: number; readonly dy: number } {\n  const x = finiteOrZero(dx);\n  const y = finiteOrZero(dy);\n  if (axis === GestureAxis.X) return { dx: x, dy: 0 };\n  if (axis === GestureAxis.Y) return { dx: 0, dy: y };\n  return { dx: x, dy: y };\n}\n\n/**\n * Whether a displacement has travelled far enough to count, measured along the gesture's own axis.\n *\n * This is the gate that stops a drag from stealing a click: below the threshold the pointer is still \"pressing\",\n * not \"dragging\". An unconstrained gesture measures straight-line distance; a constrained one measures only its\n * axis, so a vertical scroll never trips an `axis: 'x'` drag.\n *\n * A threshold of `0` always passes — that is the documented way to recognize on pointer-down.\n *\n * @param dx Horizontal displacement in CSS pixels.\n * @param dy Vertical displacement in CSS pixels.\n * @param threshold Distance in CSS pixels that must be met or exceeded. Non-finite is treated as `0`.\n * @param axis The axis the gesture is locked to.\n * @returns `true` once the displacement reaches the threshold.\n */\nexport function exceedsThreshold(dx: number, dy: number, threshold: number, axis: GestureAxis): boolean {\n  const limit = Number.isFinite(threshold) ? Math.max(0, threshold) : 0;\n  const x = finiteOrZero(dx);\n  const y = finiteOrZero(dy);\n  if (axis === GestureAxis.X) return Math.abs(x) >= limit;\n  if (axis === GestureAxis.Y) return Math.abs(y) >= limit;\n  return Math.hypot(x, y) >= limit;\n}\n\n/**\n * Whether a pointer has stayed still enough for a hold to survive — the inverse gate to {@link exceedsThreshold},\n * and always measured as straight-line distance because a hold is not directional.\n *\n * @param dx Horizontal displacement in CSS pixels since the press began.\n * @param dy Vertical displacement in CSS pixels since the press began.\n * @param tolerance Slack in CSS pixels, to absorb the finger tremor every real touch carries. Non-finite is `0`.\n * @returns `true` while the pointer remains within tolerance.\n */\nexport function withinTolerance(dx: number, dy: number, tolerance: number): boolean {\n  const limit = Number.isFinite(tolerance) ? Math.max(0, tolerance) : 0;\n  return Math.hypot(finiteOrZero(dx), finiteOrZero(dy)) <= limit;\n}\n\n/**\n * Applies a `pointerTypes` allowlist to one pointer.\n *\n * `undefined` means no filter — every input device is accepted. An EMPTY array is read literally as \"accept\n * nothing\" rather than being quietly upgraded to \"accept everything\": an allowlist that arrived empty from a\n * caller's own filtering should visibly disable the gesture, not silently widen it.\n *\n * @param pointerType The event's `pointerType` — conventionally `'mouse'`, `'touch'`, or `'pen'`.\n * @param allowed The allowlist, or `undefined` for no filtering.\n * @returns `true` when this pointer may drive the gesture.\n */\nexport function acceptsPointerType(pointerType: string, allowed: readonly string[] | undefined): boolean {\n  if (allowed === undefined) return true;\n  return allowed.includes(pointerType);\n}\n\n/**\n * Clamps a long-press delay into the shared `PressExtensions.longPressDelay` bounds.\n *\n * The bounds are NOT redefined here — they are the same `min` / `max` / `default` every other press-driven\n * component in the library already honours, so a hold configured on a `Button` and a hold configured through\n * `useLongPress` can never disagree about what counts as \"too fast to be deliberate\".\n *\n * @param delayMs The requested delay in milliseconds; `undefined` or non-finite falls back to the shared default.\n * @returns A delay within `[min, max]`.\n */\nexport function clampLongPressDelay(delayMs: number | undefined): number {\n  const bounds = PressExtensions.longPressDelay;\n  if (delayMs === undefined || !Number.isFinite(delayMs)) return bounds.default;\n  return Math.min(bounds.max, Math.max(bounds.min, delayMs));\n}\n","// `useDrag` — the single-pointer engine the rest of this slice is built on. `useSwipe` is a thin reading of this\n// composable's end payload rather than a second recognizer, so the two can never disagree about where a pointer\n// went.\n//\n// WHY POINTER EVENTS AND NOTHING ELSE: a mouse/touch pair means writing the gesture twice, then discovering the\n// two disagree — touch fires a compatibility mouse sequence after every tap, `touchmove` has no capture model,\n// and a stylus is a third case both miss. `PointerEvent` is one stream for mouse, touch, and pen, carries the\n// device in `pointerType` (so an allowlist is a field read, not a UA sniff), and is the only one of the three with\n// `setPointerCapture`. There is no legacy fallback here on purpose: every browser this library targets ships it.\n//\n// WHY CAPTURE **AND** WINDOW LISTENERS — the non-obvious part. `setPointerCapture` keeps the element as the event\n// TARGET once the pointer wanders off it, which is what a consumer reading `event.target` expects and what stops\n// another element's hit-testing from interfering mid-drag. What it does not do is survive its own absence: if the\n// call fails (a stale pointer id, a test DOM without the method), events would simply stop arriving and the drag\n// would freeze mid-gesture with a consumer stuck in its dragging state. So the move/up/cancel listeners are bound\n// to `window` for the lifetime of the gesture — they arrive with or without capture — and capture is requested on\n// top for its targeting. Belt and braces, one set of listeners, no double-fire.\n//\n// SSR: the effect is post-flush and bails on a null element, so nothing here runs on the server — there is no\n// element to bind to. `window` is only ever touched from inside a `pointerdown` handler, which by construction\n// cannot fire outside a browser.\n//\n// TOUCH NEEDS `touch-action` — the one thing a consumer must do. The browser claims a touch pointer for scrolling\n// and then fires `pointercancel`, killing the drag mid-stroke. Set `touch-action: none` on the draggable element\n// (or `pan-y` / `pan-x` when only one axis is yours). This slice deliberately does not write the style itself: it\n// is headless, and silently blocking page scroll on a consumer's element is not a decision a composable should\n// make.\n//\n// NOTHING HERE ANIMATES, so nothing here consults `useReducedMotion` — these composables report where a pointer\n// went, which is a fact, not a motion preference. A consumer that TWEENS the reported delta (spring-back,\n// momentum, snap) owns that call and should read `foundation/hooks`' `useReducedMotion` at its own layer.\n\nimport { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\nimport { GestureAxis } from './GestureAxis';\nimport {\n  acceptsPointerType,\n  constrainToAxis,\n  exceedsThreshold,\n  windowedVelocity,\n  type GestureSample,\n} from './GestureMath';\n\n/** How many trailing samples to retain for the velocity window — see `VELOCITY_WINDOW_MS`. */\nconst MAX_SAMPLES = 16;\n\n/**\n * Velocity is measured over the last ~80ms of movement, not over the whole gesture and not over the single last\n * event. Whole-gesture would report a flick that followed a long slow drag as slow. The single last event is\n * worse: `pointerup` usually repeats the final `pointermove` coordinates a few milliseconds later, so a genuine\n * flick would release at a velocity of zero. A short trailing window is what makes \"was that a flick\" answerable.\n */\nconst VELOCITY_WINDOW_MS = 80;\n\n/** What a drag handler receives — the full state of the gesture at the moment of the call. */\nexport interface DragPayload {\n  /** Horizontal distance from the press origin, in CSS pixels. Zeroed when `axis` is `'y'`. */\n  readonly dx: number;\n  /** Vertical distance from the press origin, in CSS pixels. Zeroed when `axis` is `'x'`. */\n  readonly dy: number;\n  /** Current pointer position — the event's `clientX`, viewport-relative and never axis-constrained. */\n  readonly x: number;\n  /** Current pointer position — the event's `clientY`, viewport-relative and never axis-constrained. */\n  readonly y: number;\n  /** Horizontal speed in px/ms over the recent movement window, NOT over the whole drag. Signed. */\n  readonly velocityX: number;\n  /** Vertical speed in px/ms over the recent movement window, NOT over the whole drag. Signed. */\n  readonly velocityY: number;\n  /** Milliseconds since the pointer went down — the whole gesture, unlike the velocity fields. */\n  readonly elapsedMs: number;\n  /** The DOM pointer event that produced this payload, for `preventDefault`, modifier keys, or `pointerType`. */\n  readonly event: PointerEvent;\n}\n\n/** The callbacks a drag can fire. Every one is optional. */\nexport interface DragHandlers {\n  /**\n   * Fired once the drag is recognized — immediately on pointer-down when `threshold` is `0`, otherwise on the\n   * first move that clears it.\n   */\n  readonly onDragStart?: (payload: DragPayload) => void;\n  /** Fired on each subsequent pointer move while the drag is active. */\n  readonly onDragMove?: (payload: DragPayload) => void;\n  /**\n   * Fired on pointer-up or pointer-cancel, but ONLY if the drag was recognized — a press that never cleared the\n   * threshold produces no start and therefore no end. Read `event.type` to tell a completion from a cancellation.\n   */\n  readonly onDragEnd?: (payload: DragPayload) => void;\n}\n\n/** Tunes how a drag is recognized. */\nexport interface DragOptions {\n  /**\n   * CSS pixels the pointer must travel before the drag is recognized. Defaults to `0` — recognized on\n   * pointer-down.\n   *\n   * Raise it to a few pixels whenever the same element is also clickable: below the threshold the interaction\n   * stays a press, so a click survives the hand tremor that accompanies every real tap.\n   */\n  readonly threshold?: number;\n\n  /** Axis the drag is locked to — gates recognition AND zeroes the off-axis delta. Defaults to `'both'`. */\n  readonly axis?: GestureAxis;\n\n  /**\n   * Whether the drag is inert. Checked when the pointer goes DOWN; a gesture already in flight completes normally\n   * rather than stranding a consumer mid-drag with no `onDragEnd`.\n   */\n  readonly disabled?: boolean;\n\n  /**\n   * Input devices allowed to drive the drag — conventionally `'mouse'`, `'touch'`, `'pen'`. Omit for no filter.\n   * An empty array accepts nothing, which is the literal reading and makes an accidentally-empty list obvious.\n   */\n  readonly pointerTypes?: readonly string[];\n}\n\n/** Mutable state of one in-flight drag; `null` between gestures. */\ninterface DragState {\n  pointerId: number;\n  originX: number;\n  originY: number;\n  startTime: number;\n  recognized: boolean;\n  samples: GestureSample[];\n}\n\n/**\n * Tracks a single-pointer drag on `target`, reporting distance, position, and recent velocity.\n *\n * Takes the element as a ref or getter rather than handing one back, so the caller keeps ownership of its\n * `useTemplateRef`. Options are read through `toValue` at call time, so a reactive `disabled` or `axis` takes\n * effect without re-attaching the listener; only the element identity re-binds. When the scope is disposed every\n * listener is detached and any held pointer capture released.\n *\n * Nothing throws: a missing element, an unavailable `setPointerCapture`, or a pointer that vanishes without an\n * up event all resolve quietly.\n *\n * @param target The element to watch. A `null` value simply binds nothing.\n * @param handlers Drag lifecycle callbacks.\n * @param options Recognition tuning — threshold, axis, disabled, pointer-type filter.\n */\nexport function useDrag(\n  target: MaybeRefOrGetter<HTMLElement | null | undefined>,\n  handlers: DragHandlers,\n  options?: MaybeRefOrGetter<DragOptions | undefined>,\n): void {\n  watchPostEffect((onCleanup) => {\n    const current = toValue(target);\n    if (!current) return;\n    // Re-bound with an explicit type: TypeScript does not carry a narrowing into a hoisted function DECLARATION\n    // (it cannot prove the declaration is not called before the guard), and every handler below is one. The alias\n    // is what keeps the listeners free of `element!` and repeated null checks.\n    const element: HTMLElement = current;\n\n    let state: DragState | null = null;\n    // Held so both the gesture's own end and the watcher's cleanup can detach the window listeners exactly once.\n    let detachWindow: (() => void) | null = null;\n\n    /** Builds the payload shared by every handler call, applying the axis constraint to deltas and velocity. */\n    function toPayload(active: DragState, event: PointerEvent): DragPayload {\n      const axis = toValue(options)?.axis ?? GestureAxis.Both;\n      const { dx, dy } = constrainToAxis(event.clientX - active.originX, event.clientY - active.originY, axis);\n      const velocity = windowedVelocity(active.samples, VELOCITY_WINDOW_MS);\n      const constrainedVelocity = constrainToAxis(velocity.velocityX, velocity.velocityY, axis);\n      return {\n        dx,\n        dy,\n        x: event.clientX,\n        y: event.clientY,\n        velocityX: constrainedVelocity.dx,\n        velocityY: constrainedVelocity.dy,\n        elapsedMs: event.timeStamp - active.startTime,\n        event,\n      };\n    }\n\n    /** Appends a sample, dropping the oldest once the window can no longer need it. */\n    function sample(active: DragState, event: PointerEvent): void {\n      active.samples.push({ x: event.clientX, y: event.clientY, t: event.timeStamp });\n      if (active.samples.length > MAX_SAMPLES) active.samples.shift();\n    }\n\n    /** Releases capture defensively — the pointer may already be gone, which is not an error worth throwing on. */\n    function releaseCapture(pointerId: number): void {\n      try {\n        if (element.hasPointerCapture(pointerId)) element.releasePointerCapture(pointerId);\n      } catch {\n        // Capture was never held, or the pointer id is stale. Either way there is nothing to release.\n      }\n    }\n\n    /** Tears down one gesture: window listeners off, capture released, state cleared. */\n    function finish(): void {\n      if (detachWindow !== null) {\n        detachWindow();\n        detachWindow = null;\n      }\n      if (state !== null) releaseCapture(state.pointerId);\n      state = null;\n    }\n\n    function onPointerMove(event: PointerEvent): void {\n      if (state === null || event.pointerId !== state.pointerId) return;\n      sample(state, event);\n\n      if (!state.recognized) {\n        const axis = toValue(options)?.axis ?? GestureAxis.Both;\n        const threshold = toValue(options)?.threshold ?? 0;\n        const rawDx = event.clientX - state.originX;\n        const rawDy = event.clientY - state.originY;\n        if (!exceedsThreshold(rawDx, rawDy, threshold, axis)) return;\n        state.recognized = true;\n        handlers.onDragStart?.(toPayload(state, event));\n        return; // The move that starts a drag is the start, not also a move.\n      }\n\n      handlers.onDragMove?.(toPayload(state, event));\n    }\n\n    function onPointerEnd(event: PointerEvent): void {\n      if (state === null || event.pointerId !== state.pointerId) return;\n      sample(state, event);\n      const recognized = state.recognized;\n      const payload = toPayload(state, event);\n      finish();\n      // Fired after teardown so a handler that starts a new gesture (or unmounts) finds clean state.\n      if (recognized) handlers.onDragEnd?.(payload);\n    }\n\n    function onPointerDown(event: PointerEvent): void {\n      const opts = toValue(options);\n      if (opts?.disabled === true) return;\n      if (!acceptsPointerType(event.pointerType, opts?.pointerTypes)) return;\n      if (state !== null) return; // Single-pointer gesture — a second finger belongs to `usePinch`, not here.\n\n      state = {\n        pointerId: event.pointerId,\n        originX: event.clientX,\n        originY: event.clientY,\n        startTime: event.timeStamp,\n        recognized: false,\n        samples: [{ x: event.clientX, y: event.clientY, t: event.timeStamp }],\n      };\n\n      // Requested at DOWN, not at recognition: a fast flick can leave the element before the threshold is even\n      // cleared, and capture has to already be in place for the element to stay the target when it does.\n      try {\n        element.setPointerCapture(event.pointerId);\n      } catch {\n        // No capture available (stale pointer, or a DOM without the method). The window listeners below still\n        // deliver every move, so the drag degrades to \"works, but `event.target` may not be this element\".\n      }\n\n      window.addEventListener('pointermove', onPointerMove);\n      window.addEventListener('pointerup', onPointerEnd);\n      window.addEventListener('pointercancel', onPointerEnd);\n      detachWindow = () => {\n        window.removeEventListener('pointermove', onPointerMove);\n        window.removeEventListener('pointerup', onPointerEnd);\n        window.removeEventListener('pointercancel', onPointerEnd);\n      };\n\n      const threshold = opts?.threshold ?? 0;\n      // A zero threshold means \"recognized on contact\" — fire the start now rather than waiting for a move that\n      // a tap-and-hold would never produce.\n      if (threshold <= 0) {\n        state.recognized = true;\n        handlers.onDragStart?.(toPayload(state, event));\n      }\n    }\n\n    element.addEventListener('pointerdown', onPointerDown);\n    onCleanup(() => {\n      element.removeEventListener('pointerdown', onPointerDown);\n      finish(); // Torn down mid-drag: window listeners off and capture released, no dangling gesture.\n    });\n  });\n}\n","// `useSwipe` — a flick recognizer that is deliberately NOT its own pointer implementation. It runs `useDrag` with\n// a zero threshold and reads the end payload; every listener, the capture handling, the pointer-type filter, and\n// the velocity window all come from there. A second listener stack would be a second set of edge cases (a pointer\n// that cancels, a drag that outlives its element) resolved slightly differently, and the two recognizers would\n// eventually disagree about where the same finger went.\n//\n// A SWIPE IS DISTANCE **AND** SPEED, both required. Distance alone promotes a slow deliberate drag into a flick,\n// which is how a carousel ends up advancing when the user was carefully positioning something. Speed alone\n// promotes a 3px twitch. Requiring both is what makes the gesture mean \"thrown\", and it is why the two thresholds\n// are separate knobs rather than one blended score a consumer could not reason about.\n//\n// ONE DIRECTION PER GESTURE, resolved at release from the total displacement — not accumulated per move. A finger\n// that arcs out and back reports where it ENDED relative to where it began, which is the thing the user meant.\n\nimport { toValue, type MaybeRefOrGetter } from 'vue';\n\nimport { GestureAxis } from './GestureAxis';\nimport { swipeDirection } from './GestureMath';\nimport { SwipeDirection } from './SwipeDirection';\nimport { useDrag, type DragPayload } from './UseDrag';\n\n/** Default travel required before a flick counts, in CSS pixels — roughly a thumb's comfortable arc. */\nconst DEFAULT_SWIPE_THRESHOLD = 50;\n\n/** Default speed required, in px/ms (300 px/s) — above a deliberate drag, below a hurried one. */\nconst DEFAULT_VELOCITY_THRESHOLD = 0.3;\n\n/** What `onSwipe` receives once a flick is recognized. */\nexport interface SwipePayload {\n  /** Which way the flick went, from the total displacement between press and release. */\n  readonly direction: SwipeDirection;\n  /** How far it travelled ALONG that direction's axis, in CSS pixels. Always positive. */\n  readonly distance: number;\n  /** Release speed along that same axis, in px/ms, over the recent movement window. Always positive. */\n  readonly velocity: number;\n  /** The pointer event that ended the gesture — `pointerup`, or `pointercancel` if the browser took the pointer. */\n  readonly event: PointerEvent;\n}\n\n/** The callbacks a swipe can fire. */\nexport interface SwipeHandlers {\n  /** Fired once per gesture, at release, only when both the distance and velocity thresholds are met. */\n  readonly onSwipe?: (payload: SwipePayload) => void;\n}\n\n/** Tunes how a flick is recognized. */\nexport interface SwipeOptions {\n  /** CSS pixels the pointer must travel along the swipe axis. Defaults to `50`. */\n  readonly threshold?: number;\n\n  /** Speed in px/ms the pointer must still carry at release. Defaults to `0.3` (300 px/s). */\n  readonly velocityThreshold?: number;\n\n  /**\n   * Axis to restrict recognition to. `'x'` reports only `'left'` / `'right'`, `'y'` only `'up'` / `'down'`.\n   * Defaults to `'both'`.\n   */\n  readonly axis?: GestureAxis;\n\n  /** Whether the gesture is inert. Checked when the pointer goes down. */\n  readonly disabled?: boolean;\n\n  /** Input devices allowed to drive the swipe. Omit for no filter; see {@link useDrag} for the empty-array rule. */\n  readonly pointerTypes?: readonly string[];\n}\n\n/**\n * Recognizes a directional flick on `target`.\n *\n * Built on {@link useDrag}, so it inherits pointer capture, the pointer-type filter, and the same cleanup\n * guarantees: on scope disposal every listener is detached and any capture released. Nothing throws.\n *\n * @param target The element to watch, as a ref or getter.\n * @param handlers Swipe callbacks.\n * @param options Distance / velocity thresholds, axis, disabled, pointer-type filter.\n */\nexport function useSwipe(\n  target: MaybeRefOrGetter<HTMLElement | null | undefined>,\n  handlers: SwipeHandlers,\n  options?: MaybeRefOrGetter<SwipeOptions | undefined>,\n): void {\n  useDrag(\n    target,\n    {\n      onDragEnd: (payload: DragPayload): void => {\n        const opts = toValue(options);\n        const direction = swipeDirection(payload.dx, payload.dy);\n        if (direction === null) return; // Pressed and released without moving — not a swipe.\n\n        const horizontal = direction === SwipeDirection.Left || direction === SwipeDirection.Right;\n        const distance = Math.abs(horizontal ? payload.dx : payload.dy);\n        const velocity = Math.abs(horizontal ? payload.velocityX : payload.velocityY);\n\n        const threshold = opts?.threshold ?? DEFAULT_SWIPE_THRESHOLD;\n        const velocityThreshold = opts?.velocityThreshold ?? DEFAULT_VELOCITY_THRESHOLD;\n        if (distance < threshold || velocity < velocityThreshold) return;\n\n        handlers.onSwipe?.({ direction, distance, velocity, event: payload.event });\n      },\n    },\n    // A getter, so the drag re-reads the swipe's own axis / disabled / pointer-type values live rather than\n    // pinning whatever they were at setup.\n    () => ({\n      // Zero threshold so the underlying drag tracks from first contact: the swipe's own distance gate is what\n      // decides, and a drag-level threshold would only subtract from the displacement measured here.\n      threshold: 0,\n      axis: toValue(options)?.axis ?? GestureAxis.Both,\n      disabled: toValue(options)?.disabled,\n      pointerTypes: toValue(options)?.pointerTypes,\n    }),\n  );\n}\n","// `useLongPress` — fires once the pointer has been held still for long enough.\n//\n// THE DELAY IS NOT THIS SLICE'S TO INVENT. `PressExtensions.longPressDelay` already defines the `min` / `max` /\n// `default` every press-driven component in the library honours, and `clampLongPressDelay` in `GestureMath` is the\n// only place a requested delay meets those bounds. A second 500 here would be a second source of truth that drifts\n// the first time one of them is tuned — a hold on a `Button` and a hold through this composable must mean the\n// same thing.\n//\n// WHY A MOVE TOLERANCE RATHER THAN \"ANY MOVEMENT CANCELS\": no real touch is still. A finger resting on glass\n// wanders a few pixels from tremor alone and a stylus is worse, so a zero-slack rule makes long-press fire for\n// mice and almost never for the touchscreens it exists to serve. The tolerance is straight-line, not per-axis —\n// a hold has no direction to be lenient about.\n//\n// NO POINTER CAPTURE HERE, deliberately, unlike `useDrag`. Capture exists to keep tracking a pointer that LEAVES\n// the element; a hold that leaves the element is a hold that has been abandoned, and should cancel. The move and\n// release listeners go on `window` precisely so that departure is observed rather than missed.\n//\n// SSR: the effect is post-flush and bails on a null element, so nothing here runs on the server, and `window` is\n// only ever touched from inside a `pointerdown` handler.\n\nimport { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\nimport { acceptsPointerType, clampLongPressDelay, withinTolerance } from './GestureMath';\n\n/** Default slack in CSS pixels — wide enough for finger tremor, tight enough that a deliberate drag cancels. */\nconst DEFAULT_MOVE_TOLERANCE = 10;\n\n/** What the long-press handler receives when the hold completes. */\nexport interface LongPressPayload {\n  /** Where the press began — `clientX` of the pointer-down, not of the moment the timer elapsed. */\n  readonly x: number;\n  /** Where the press began — `clientY` of the pointer-down. */\n  readonly y: number;\n  /**\n   * The `pointerdown` event that opened the hold. There is no event for the completion itself: a timer fired, and\n   * inventing a synthetic one would misreport `timeStamp` and `target`.\n   */\n  readonly event: PointerEvent;\n}\n\n/** Tunes how a hold is recognized. */\nexport interface LongPressOptions {\n  /**\n   * Hold duration in milliseconds before the handler fires. Defaults to `PressExtensions.longPressDelay.default`\n   * and is clamped into that same shared `[min, max]` range — this composable defines no bounds of its own.\n   */\n  readonly delayMs?: number;\n\n  /** CSS pixels the pointer may drift before the hold is abandoned. Defaults to `10`. */\n  readonly moveTolerance?: number;\n\n  /** Whether the gesture is inert. Checked when the pointer goes down. */\n  readonly disabled?: boolean;\n\n  /** Input devices allowed to drive the hold. Omit for no filter; an empty array accepts nothing. */\n  readonly pointerTypes?: readonly string[];\n}\n\n/** Mutable state of one in-flight hold; `null` between presses. */\ninterface LongPressState {\n  pointerId: number;\n  originX: number;\n  originY: number;\n  timer: ReturnType<typeof setTimeout>;\n}\n\n/**\n * Fires `handler` after the pointer has been held on `target` for `delayMs` without drifting beyond\n * `moveTolerance`.\n *\n * Cancels on pointer-up, on pointer-cancel, and on any move past the tolerance. The pending timer is cleared when\n * the scope is disposed, so a component that disappears mid-hold can never fire into a dead tree.\n *\n * Takes the element as a ref or getter rather than handing one back. Options are read through `toValue` at call\n * time, so a reactive `disabled` or `delayMs` takes effect without re-attaching. Nothing throws.\n *\n * @param target The element to watch.\n * @param handler Called once when the hold completes.\n * @param options Delay, move tolerance, disabled, pointer-type filter.\n */\nexport function useLongPress(\n  target: MaybeRefOrGetter<HTMLElement | null | undefined>,\n  handler: (payload: LongPressPayload) => void,\n  options?: MaybeRefOrGetter<LongPressOptions | undefined>,\n): void {\n  watchPostEffect((onCleanup) => {\n    const current = toValue(target);\n    if (!current) return;\n    // Re-bound with an explicit type: TypeScript does not carry a narrowing into a hoisted function DECLARATION,\n    // and every handler below is one. See the same note in `UseDrag`.\n    const element: HTMLElement = current;\n\n    let state: LongPressState | null = null;\n    // Held so both a cancelled hold and the watcher's cleanup detach the window listeners exactly once.\n    let detachWindow: (() => void) | null = null;\n\n    /** Clears the pending timer and window listeners. The single teardown path for every outcome. */\n    function cancel(): void {\n      if (state !== null) {\n        clearTimeout(state.timer);\n        state = null;\n      }\n      if (detachWindow !== null) {\n        detachWindow();\n        detachWindow = null;\n      }\n    }\n\n    function onPointerMove(event: PointerEvent): void {\n      if (state === null || event.pointerId !== state.pointerId) return;\n      const tolerance = toValue(options)?.moveTolerance ?? DEFAULT_MOVE_TOLERANCE;\n      if (withinTolerance(event.clientX - state.originX, event.clientY - state.originY, tolerance)) return;\n      cancel(); // Drifted too far — this is a drag, not a hold.\n    }\n\n    function onPointerEnd(): void {\n      // Released (or cancelled) before the timer elapsed. If it had elapsed, `state` is already `null`.\n      cancel();\n    }\n\n    function onPointerDown(event: PointerEvent): void {\n      const opts = toValue(options);\n      if (opts?.disabled === true) return;\n      if (!acceptsPointerType(event.pointerType, opts?.pointerTypes)) return;\n      if (state !== null) return; // A hold is already in flight; a second pointer does not restart it.\n\n      const delay = clampLongPressDelay(opts?.delayMs);\n      const timer = setTimeout(() => {\n        const payload: LongPressPayload = { x: event.clientX, y: event.clientY, event };\n        // Cleared BEFORE the handler runs: the hold is complete, so a later pointer-up must find nothing to\n        // cancel, and a handler that unmounts the tree must not leave a live timer behind it.\n        cancel();\n        handler(payload);\n      }, delay);\n\n      state = { pointerId: event.pointerId, originX: event.clientX, originY: event.clientY, timer };\n\n      window.addEventListener('pointermove', onPointerMove);\n      window.addEventListener('pointerup', onPointerEnd);\n      window.addEventListener('pointercancel', onPointerEnd);\n      detachWindow = () => {\n        window.removeEventListener('pointermove', onPointerMove);\n        window.removeEventListener('pointerup', onPointerEnd);\n        window.removeEventListener('pointercancel', onPointerEnd);\n      };\n    }\n\n    element.addEventListener('pointerdown', onPointerDown);\n    onCleanup(() => {\n      element.removeEventListener('pointerdown', onPointerDown);\n      cancel(); // Torn down mid-hold: timer cleared, listeners detached.\n    });\n  });\n}\n","// `usePinch` — two-pointer scale and rotation, the one gesture in this slice that cannot reuse `useDrag`: that\n// composable is single-pointer by construction (a second `pointerdown` is ignored), and a pinch is defined by the\n// RELATION between two pointers rather than by either one's path.\n//\n// WHY A MAP KEYED BY `pointerId`: pointer events arrive interleaved and independently — two fingers produce two\n// separate `pointermove` streams that share no ordering guarantee, and either may cancel alone. Tracking \"finger\n// one and finger two\" as variables desynchronizes the moment they arrive out of order. The map is the only\n// structure that answers \"where is pointer 7 right now\" without caring when pointer 3 last moved.\n//\n// SCALE AND ROTATION ARE MEASURED FROM THE PINCH'S OWN ORIGIN, not from the previous frame. Per-frame deltas\n// compound their own rounding error, so a finger returning to exactly where it started would not return the\n// consumer's transform to 1.0. Anchoring both to the separation and angle captured at pinch-start means the\n// gesture is always reversible.\n//\n// A THIRD FINGER IS TRACKED BUT NOT PROMOTED. The active pair is fixed when the pinch starts; extra pointers sit\n// in the map unused. When one of the pair lifts, the pinch ENDS — and immediately re-arms on the two pointers\n// still down, so a hand rolling across the surface produces clean end/start pairs instead of a transform that\n// teleports as the anchors silently swap underneath it.\n//\n// SSR: the effect is post-flush and bails on a null element, so nothing here runs on the server, and `window` is\n// only ever touched from inside a `pointerdown` handler.\n\nimport { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\nimport {\n  acceptsPointerType,\n  pinchRotation,\n  pinchScale,\n  pointerAngle,\n  pointerCenter,\n  pointerDistance,\n  type GesturePoint,\n} from './GestureMath';\n\n/** What a pinch handler receives — the gesture's state relative to where the pinch began. */\nexport interface PinchPayload {\n  /** Separation now, over separation at pinch-start: `1` unchanged, `2` doubled, `0.5` halved. */\n  readonly scale: number;\n  /** Degrees turned since pinch-start, within `[-180, 180)`. Positive is clockwise on screen. */\n  readonly rotation: number;\n  /** Midpoint of the two active pointers, in viewport coordinates — the anchor to transform about. */\n  readonly center: GesturePoint;\n  /** The pointer event that produced this payload. */\n  readonly event: PointerEvent;\n}\n\n/** The callbacks a pinch can fire. All optional. */\nexport interface PinchHandlers {\n  /** Fired when a second pointer goes down, with `scale: 1` and `rotation: 0` — the gesture's own origin. */\n  readonly onPinchStart?: (payload: PinchPayload) => void;\n  /** Fired when either pointer of the active pair moves. */\n  readonly onPinchMove?: (payload: PinchPayload) => void;\n  /** Fired when either pointer of the active pair lifts or cancels, carrying the last computed values. */\n  readonly onPinchEnd?: (payload: PinchPayload) => void;\n}\n\n/** Tunes how a pinch is recognized. */\nexport interface PinchOptions {\n  /** Whether the gesture is inert. Checked when each pointer goes down. */\n  readonly disabled?: boolean;\n\n  /**\n   * Input devices allowed to drive the pinch — in practice `'touch'` or `'pen'`, since a mouse has one pointer.\n   * Omit for no filter; an empty array accepts nothing.\n   */\n  readonly pointerTypes?: readonly string[];\n}\n\n/** The fixed anchors of one in-flight pinch; `null` when fewer than two pointers are down. */\ninterface PinchState {\n  readonly idA: number;\n  readonly idB: number;\n  readonly startDistance: number;\n  readonly startAngle: number;\n}\n\n/**\n * Tracks a two-pointer pinch on `target`, reporting scale, rotation, and the pinch centre.\n *\n * Ignored entirely while fewer than two pointers are down. Takes the element as a ref or getter rather than\n * handing one back; options are read through `toValue` at call time. When the scope is disposed every listener is\n * detached and every held pointer capture released. Nothing throws.\n *\n * Touch pinches need `touch-action: none` on the element, or the browser claims the pointers for page zoom and\n * fires `pointercancel` mid-gesture.\n *\n * @param target The element to watch.\n * @param handlers Pinch lifecycle callbacks.\n * @param options Disabled flag and pointer-type filter.\n */\nexport function usePinch(\n  target: MaybeRefOrGetter<HTMLElement | null | undefined>,\n  handlers: PinchHandlers,\n  options?: MaybeRefOrGetter<PinchOptions | undefined>,\n): void {\n  watchPostEffect((onCleanup) => {\n    const current = toValue(target);\n    if (!current) return;\n    // Re-bound with an explicit type: TypeScript does not carry a narrowing into a hoisted function DECLARATION,\n    // and every handler below is one. See the same note in `UseDrag`.\n    const element: HTMLElement = current;\n\n    /** Live position of every pointer currently down on the element, in insertion order. */\n    const pointers = new Map<number, GesturePoint>();\n    let state: PinchState | null = null;\n    let detachWindow: (() => void) | null = null;\n\n    /** Releases capture defensively — a pointer that already went away is not an error worth throwing on. */\n    function releaseCapture(pointerId: number): void {\n      try {\n        if (element.hasPointerCapture(pointerId)) element.releasePointerCapture(pointerId);\n      } catch {\n        // Capture was never held, or the pointer id is stale. Nothing to release.\n      }\n    }\n\n    /** Detaches the window listeners once no pointer remains. */\n    function detachIfIdle(): void {\n      if (pointers.size > 0 || detachWindow === null) return;\n      detachWindow();\n      detachWindow = null;\n    }\n\n    /** The two oldest live pointers, or `null` when fewer than two are down. */\n    function activePair(): readonly [number, number] | null {\n      const iterator = pointers.keys();\n      const first = iterator.next();\n      const second = iterator.next();\n      if (!first.done && !second.done) return [first.value, second.value];\n      return null;\n    }\n\n    /** Builds a payload from the active pair's current positions, or `null` if either has gone. */\n    function toPayload(active: PinchState, event: PointerEvent): PinchPayload | null {\n      const a = pointers.get(active.idA);\n      const b = pointers.get(active.idB);\n      if (a === undefined || b === undefined) return null;\n      return {\n        scale: pinchScale(active.startDistance, pointerDistance(a, b)),\n        rotation: pinchRotation(active.startAngle, pointerAngle(a, b)),\n        center: pointerCenter(a, b),\n        event,\n      };\n    }\n\n    /** Arms a pinch on the two oldest live pointers, if two are down and none is already armed. */\n    function tryStart(event: PointerEvent): void {\n      if (state !== null) return;\n      const pair = activePair();\n      if (pair === null) return;\n      const a = pointers.get(pair[0]);\n      const b = pointers.get(pair[1]);\n      if (a === undefined || b === undefined) return;\n\n      state = {\n        idA: pair[0],\n        idB: pair[1],\n        startDistance: pointerDistance(a, b),\n        startAngle: pointerAngle(a, b),\n      };\n      const payload = toPayload(state, event);\n      if (payload !== null) handlers.onPinchStart?.(payload);\n    }\n\n    function onPointerMove(event: PointerEvent): void {\n      if (!pointers.has(event.pointerId)) return;\n      pointers.set(event.pointerId, { x: event.clientX, y: event.clientY });\n      if (state === null) return;\n      if (event.pointerId !== state.idA && event.pointerId !== state.idB) return; // A spectator finger moved.\n\n      const payload = toPayload(state, event);\n      if (payload !== null) handlers.onPinchMove?.(payload);\n    }\n\n    function onPointerEnd(event: PointerEvent): void {\n      if (!pointers.has(event.pointerId)) return;\n      const wasAnchor = state !== null && (event.pointerId === state.idA || event.pointerId === state.idB);\n\n      // The payload is computed BEFORE the pointer leaves the map, so the end call carries the last real geometry\n      // rather than a hole where one anchor used to be.\n      const payload = wasAnchor && state !== null ? toPayload(state, event) : null;\n\n      releaseCapture(event.pointerId);\n      pointers.delete(event.pointerId);\n\n      if (wasAnchor) {\n        state = null;\n        if (payload !== null) handlers.onPinchEnd?.(payload);\n        tryStart(event); // Re-arm on whatever is still down, so a rolling hand gets clean end/start pairs.\n      }\n      detachIfIdle();\n    }\n\n    function onPointerDown(event: PointerEvent): void {\n      const opts = toValue(options);\n      if (opts?.disabled === true) return;\n      if (!acceptsPointerType(event.pointerType, opts?.pointerTypes)) return;\n\n      pointers.set(event.pointerId, { x: event.clientX, y: event.clientY });\n\n      try {\n        element.setPointerCapture(event.pointerId);\n      } catch {\n        // No capture available. The window listeners below still deliver every move.\n      }\n\n      if (detachWindow === null) {\n        window.addEventListener('pointermove', onPointerMove);\n        window.addEventListener('pointerup', onPointerEnd);\n        window.addEventListener('pointercancel', onPointerEnd);\n        detachWindow = () => {\n          window.removeEventListener('pointermove', onPointerMove);\n          window.removeEventListener('pointerup', onPointerEnd);\n          window.removeEventListener('pointercancel', onPointerEnd);\n        };\n      }\n\n      tryStart(event);\n    }\n\n    element.addEventListener('pointerdown', onPointerDown);\n    onCleanup(() => {\n      element.removeEventListener('pointerdown', onPointerDown);\n      for (const pointerId of pointers.keys()) releaseCapture(pointerId);\n      pointers.clear();\n      state = null;\n      detachIfIdle();\n    });\n  });\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../../../src/foundation/gestures/enums/SwipeDirection.ts","../../../src/foundation/gestures/enums/GestureAxis.ts","../../../src/foundation/gestures/GestureMath.ts","../../../src/foundation/gestures/hooks/UseDrag.ts","../../../src/foundation/gestures/hooks/UseSwipe.ts","../../../src/foundation/gestures/hooks/UseLongPress.ts","../../../src/foundation/gestures/hooks/UsePinch.ts"],"sourcesContent":["// The swipe vocabulary, kept in its own file so a consumer can `switch` on `SwipeDirection.Left` without pulling\n// Vue into a pure module — the same value/composable split `foundation/device` uses for `PointerType` vs `UsePointer`.\n//\n// SCREEN AXES, NOT READING ORDER. `Up` means \"toward smaller `clientY`\", which is what the pointer actually did.\n// A right-to-left locale does not flip these; a consumer that wants \"swipe toward the start of the line\" maps\n// `Left`/`Right` through its own direction context. Baking RTL in here would make the same finger motion report\n// two different directions depending on a document attribute the pointer knows nothing about.\n\n/** Which way a swipe travelled, in screen coordinates. */\nexport const SwipeDirection = {\n  /** Toward smaller `clientX` — the pointer moved left across the screen. */\n  Left: 'left',\n  /** Toward larger `clientX` — the pointer moved right across the screen. */\n  Right: 'right',\n  /** Toward smaller `clientY` — the pointer moved up the screen. */\n  Up: 'up',\n  /** Toward larger `clientY` — the pointer moved down the screen. */\n  Down: 'down',\n} as const;\n\n/** One of the {@link SwipeDirection} values. */\nexport type SwipeDirection = (typeof SwipeDirection)[keyof typeof SwipeDirection];\n","// The axis-constraint vocabulary. Separate from the composables for the same reason as `SwipeDirection` — a pure module\n// (and the threshold math in `GestureMath`) needs these values without importing Vue.\n//\n// An axis does TWO things at once, and both matter: it gates RECOGNITION (a vertical twitch must not start an\n// `axis: 'x'` drag, or a horizontal carousel steals the page's scroll) and it constrains the REPORTED delta (the\n// off-axis component is zeroed, so a consumer can bind `dx` straight to a transform without re-clamping it).\n\n/** Which axis a gesture is constrained to. */\nexport const GestureAxis = {\n  /** Horizontal only — vertical movement neither triggers recognition nor appears in the payload. */\n  X: 'x',\n  /** Vertical only — horizontal movement neither triggers recognition nor appears in the payload. */\n  Y: 'y',\n  /** Unconstrained — recognition uses straight-line distance and both deltas are reported. */\n  Both: 'both',\n} as const;\n\n/** One of the {@link GestureAxis} values. */\nexport type GestureAxis = (typeof GestureAxis)[keyof typeof GestureAxis];\n","// The pure core of the gestures slice: every recognition decision — direction, velocity, scale, rotation, and each\n// threshold gate — computed from plain numbers, with no DOM, no Vue, and no time source of its own.\n//\n// WHY THE MATH IS SPLIT OUT AT ALL: gesture bugs are almost never listener bugs, they are ARITHMETIC bugs — a\n// diagonal that resolves to the wrong axis, a velocity that divides by a zero interval, a rotation that jumps 350°\n// instead of reporting -10°. Those are exactly the cases that are miserable to reach through a synthesized pointer\n// stream and trivial to pin as a table of inputs. The composables in this slice are deliberately thin wrappers so that\n// the part which can be exhaustively tested, is.\n//\n// TWO CONVENTIONS TO KNOW BEFORE READING ANY SIGNATURE:\n//\n//  - VELOCITY IS PX PER MILLISECOND, not px/s. Every duration in this slice arrives as `elapsedMs` (that is what\n//    the event timeline hands over), so px/ms keeps the unit chain honest with no hidden ×1000. For calibration:\n//    a deliberate flick lands near 0.5–2 px/ms, a slow drag well under 0.1.\n//\n//  - COORDINATES ARE SCREEN AXES. `y` grows DOWNWARD (the DOM's convention, not the maths class's), so a positive\n//    `dy` is a downward move and `pointerAngle` rotates clockwise. Every function here follows the DOM rather than\n//    silently flipping a sign, because the inputs come from `clientX`/`clientY` and the outputs go back to CSS.\n//\n// NOTHING HERE THROWS. A degenerate input — a zero elapsed time, a pinch that starts with both pointers on the\n// same pixel, a non-finite coordinate from a synthetic event — returns the identity answer (0 velocity, scale 1,\n// no direction) rather than an exception or a `NaN` that poisons a transform downstream. A gesture recognizer\n// firing mid-interaction has no caller in a position to catch anything.\n\nimport { PressExtensions } from '../dom/PressExtensions';\n\nimport { GestureAxis } from './enums/GestureAxis';\nimport { SwipeDirection } from './enums/SwipeDirection';\n\n/** A point in screen coordinates — `clientX` / `clientY` as reported by a pointer event. */\nexport interface GesturePoint {\n  /** Horizontal position in CSS pixels, growing rightward. */\n  readonly x: number;\n  /** Vertical position in CSS pixels, growing DOWNWARD. */\n  readonly y: number;\n}\n\n/** A point plus the moment it was observed — one entry in a gesture's trailing movement history. */\nexport interface GestureSample extends GesturePoint {\n  /** Timestamp in milliseconds, from the source event's `timeStamp`. Only differences are ever used. */\n  readonly t: number;\n}\n\n/** Radians-per-degree conversion, hoisted so the trig helpers don't recompute it per call. */\nconst DegreesPerRadian = 180 / Math.PI;\n\n/** Guards a coordinate/delta against `NaN` and `Infinity`, which a synthetic event can carry in. */\nfunction finiteOrZero(value: number): number {\n  return Number.isFinite(value) ? value : 0;\n}\n\n/**\n * Speed along one axis, in CSS pixels per millisecond.\n *\n * Returns `0` for a non-positive or non-finite interval — two pointer events can share a timestamp, and a gesture\n * must not report infinite speed because the clock did not tick.\n *\n * @param delta Distance travelled on the axis, in CSS pixels. Sign is preserved, so the result is signed too.\n * @param elapsedMs Time the movement took, in milliseconds.\n * @returns Signed velocity in px/ms; `0` when `elapsedMs <= 0`.\n */\nexport function gestureVelocity(delta: number, elapsedMs: number): number {\n  if (!Number.isFinite(elapsedMs) || elapsedMs <= 0) return 0;\n  return finiteOrZero(delta) / elapsedMs;\n}\n\n/**\n * Velocity over the tail of a movement history, which is what \"was that a flick\" actually asks.\n *\n * Neither naive reading works. Measuring across the WHOLE gesture reports a fast release that followed a long\n * slow drag as slow. Measuring the LAST PAIR of samples is worse: `pointerup` repeats the final `pointermove`\n * coordinates a few milliseconds later, so a genuine flick would end at exactly zero — the single most common\n * way a swipe recognizer silently stops working. Two rules together fix both:\n *\n *  1. A TRAILING RUN OF STATIONARY SAMPLES IS TRIMMED. A sample at the same position as its predecessor carries\n *     no speed information, so measurement ends at the last point the pointer actually moved.\n *  2. UNLESS THE POINTER REALLY STOPPED. If that last moving sample is further back than the window, the trim is\n *     abandoned and the answer is zero: pressing, flicking, HOLDING, then releasing is not a flick, and rule 1\n *     alone would report the stale speed from before the hold.\n *\n * Between those, the base is the oldest sample still inside the window; when everything earlier has aged out, the\n * immediately-preceding sample is used instead, so a slow drag still reports its real (small) speed.\n *\n * @param samples Chronological history, oldest first; the last entry is treated as \"now\".\n * @param windowMs How far back to reach, in milliseconds.\n * @returns Signed px/ms on each axis; both `0` when fewer than two samples exist or the pointer had come to rest.\n */\nexport function windowedVelocity(\n  samples: ReadonlyArray<GestureSample>,\n  windowMs: number,\n): { readonly velocityX: number; readonly velocityY: number } {\n  const still = { velocityX: 0, velocityY: 0 };\n  const last = samples.at(-1);\n  if (last === undefined) return still;\n\n  const limit = Number.isFinite(windowMs) ? Math.max(0, windowMs) : 0;\n\n  // Rule 1 — walk back over samples that did not move.\n  let tipIndex = samples.length - 1;\n  while (tipIndex > 0) {\n    const current = samples[tipIndex];\n    const previous = samples[tipIndex - 1];\n    if (current === undefined || previous === undefined) break;\n    if (current.x !== previous.x || current.y !== previous.y) break;\n    tipIndex -= 1;\n  }\n  const tip = samples[tipIndex];\n  if (tip === undefined) return still;\n\n  // Rule 2 — the pointer came to rest and stayed there for longer than the window.\n  if (last.t - tip.t > limit) return still;\n\n  // Chronological order means the first entry inside the window is also the oldest one inside it.\n  let baseIndex = tipIndex;\n  for (let index = 0; index <= tipIndex; index += 1) {\n    const candidate = samples[index];\n    if (candidate === undefined) continue;\n    if (tip.t - candidate.t <= limit) {\n      baseIndex = index;\n      break;\n    }\n  }\n  if (baseIndex === tipIndex) baseIndex -= 1; // everything earlier aged out — fall back to the previous sample\n\n  const base = samples[baseIndex];\n  if (base === undefined) return still;\n\n  const elapsed = tip.t - base.t;\n  return {\n    velocityX: gestureVelocity(tip.x - base.x, elapsed),\n    velocityY: gestureVelocity(tip.y - base.y, elapsed),\n  };\n}\n\n/**\n * Resolves a two-axis displacement to the single direction a swipe reads as.\n *\n * The dominant axis wins. An exact diagonal (`|dx| === |dy|`, both non-zero) is broken toward the HORIZONTAL axis\n * — an arbitrary but fixed choice, made so the answer is deterministic rather than dependent on argument order;\n * a caller that needs the other bias should compare the deltas itself.\n *\n * @param dx Horizontal displacement in CSS pixels; negative is leftward.\n * @param dy Vertical displacement in CSS pixels; negative is upward.\n * @returns The dominant {@link SwipeDirection}, or `null` when there was no movement at all.\n */\nexport function swipeDirection(dx: number, dy: number): SwipeDirection | null {\n  const x = finiteOrZero(dx);\n  const y = finiteOrZero(dy);\n  if (x === 0 && y === 0) return null;\n\n  // `>=` is what implements the documented horizontal tie-break.\n  if (Math.abs(x) >= Math.abs(y)) return x < 0 ? SwipeDirection.Left : SwipeDirection.Right;\n  return y < 0 ? SwipeDirection.Up : SwipeDirection.Down;\n}\n\n/**\n * Straight-line distance between two points, in CSS pixels.\n *\n * @param a First point.\n * @param b Second point.\n * @returns The non-negative distance; `0` if either coordinate is non-finite.\n */\nexport function pointerDistance(a: GesturePoint, b: GesturePoint): number {\n  return Math.hypot(finiteOrZero(b.x) - finiteOrZero(a.x), finiteOrZero(b.y) - finiteOrZero(a.y));\n}\n\n/**\n * Angle of the line from `a` to `b`, in degrees.\n *\n * Measured from the positive x-axis and rotating CLOCKWISE, because `y` grows downward on screen: `0` points\n * right, `90` points down, `-90` points up.\n *\n * @param a Origin point.\n * @param b Target point.\n * @returns The angle in degrees, within `[-180, 180]`.\n */\nexport function pointerAngle(a: GesturePoint, b: GesturePoint): number {\n  const dx = finiteOrZero(b.x) - finiteOrZero(a.x);\n  const dy = finiteOrZero(b.y) - finiteOrZero(a.y);\n  return Math.atan2(dy, dx) * DegreesPerRadian;\n}\n\n/**\n * Midpoint of two points — the anchor a pinch should scale and rotate about.\n *\n * @param a First point.\n * @param b Second point.\n * @returns The midpoint in the same screen coordinates.\n */\nexport function pointerCenter(a: GesturePoint, b: GesturePoint): GesturePoint {\n  return {\n    x: (finiteOrZero(a.x) + finiteOrZero(b.x)) / 2,\n    y: (finiteOrZero(a.y) + finiteOrZero(b.y)) / 2,\n  };\n}\n\n/**\n * Scale factor of a pinch — how far apart the two pointers are now, relative to where they started.\n *\n * `1` means unchanged, `2` means the fingers doubled their separation, `0.5` means they halved it.\n *\n * Returns `1` for a non-positive starting distance: two pointers that went down on the same pixel define no\n * baseline to scale against, and dividing by it would hand a consumer `Infinity` to write into a transform.\n *\n * @param startDistance Separation when the pinch began, in CSS pixels.\n * @param currentDistance Separation now, in CSS pixels.\n * @returns The multiplicative scale factor; `1` when no valid baseline exists.\n */\nexport function pinchScale(startDistance: number, currentDistance: number): number {\n  if (!Number.isFinite(startDistance) || startDistance <= 0) return 1;\n  return finiteOrZero(currentDistance) / startDistance;\n}\n\n/**\n * Signed rotation of a pinch, in degrees, taking the shortest way round.\n *\n * Crossing the ±180° seam is the whole reason this is not a subtraction: a pointer pair rotating from 170° to\n * -170° turned 20° clockwise, not 340° counter-clockwise.\n *\n * @param startAngle Angle between the pointers when the pinch began, in degrees.\n * @param currentAngle Angle between them now, in degrees.\n * @returns The rotation in degrees within `[-180, 180)`; positive is clockwise on screen.\n */\nexport function pinchRotation(startAngle: number, currentAngle: number): number {\n  return normalizeAngle(finiteOrZero(currentAngle) - finiteOrZero(startAngle));\n}\n\n/**\n * Wraps an arbitrary angle into a single turn.\n *\n * @param degrees Any angle, including multiples of a full turn.\n * @returns The equivalent angle within `[-180, 180)` — note `180` normalizes to `-180`.\n */\nexport function normalizeAngle(degrees: number): number {\n  const value = finiteOrZero(degrees);\n  // Double-modulo: the inner one can go negative in JS, the `+ 360` pass fixes that before re-centring on zero.\n  return ((((value + 180) % 360) + 360) % 360) - 180;\n}\n\n/**\n * Zeroes the component a constrained gesture must not report, so a consumer can bind the payload straight to a\n * transform without re-clamping it.\n *\n * @param dx Horizontal displacement in CSS pixels.\n * @param dy Vertical displacement in CSS pixels.\n * @param axis The axis the gesture is locked to.\n * @returns The displacement with the off-axis component set to `0`.\n */\nexport function constrainToAxis(\n  dx: number,\n  dy: number,\n  axis: GestureAxis,\n): { readonly dx: number; readonly dy: number } {\n  const x = finiteOrZero(dx);\n  const y = finiteOrZero(dy);\n  if (axis === GestureAxis.X) return { dx: x, dy: 0 };\n  if (axis === GestureAxis.Y) return { dx: 0, dy: y };\n  return { dx: x, dy: y };\n}\n\n/**\n * Whether a displacement has travelled far enough to count, measured along the gesture's own axis.\n *\n * This is the gate that stops a drag from stealing a click: below the threshold the pointer is still \"pressing\",\n * not \"dragging\". An unconstrained gesture measures straight-line distance; a constrained one measures only its\n * axis, so a vertical scroll never trips an `axis: 'x'` drag.\n *\n * A threshold of `0` always passes — that is the documented way to recognize on pointer-down.\n *\n * @param dx Horizontal displacement in CSS pixels.\n * @param dy Vertical displacement in CSS pixels.\n * @param threshold Distance in CSS pixels that must be met or exceeded. Non-finite is treated as `0`.\n * @param axis The axis the gesture is locked to.\n * @returns `true` once the displacement reaches the threshold.\n */\nexport function exceedsThreshold(dx: number, dy: number, threshold: number, axis: GestureAxis): boolean {\n  const limit = Number.isFinite(threshold) ? Math.max(0, threshold) : 0;\n  const x = finiteOrZero(dx);\n  const y = finiteOrZero(dy);\n  if (axis === GestureAxis.X) return Math.abs(x) >= limit;\n  if (axis === GestureAxis.Y) return Math.abs(y) >= limit;\n  return Math.hypot(x, y) >= limit;\n}\n\n/**\n * Whether a pointer has stayed still enough for a hold to survive — the inverse gate to {@link exceedsThreshold},\n * and always measured as straight-line distance because a hold is not directional.\n *\n * @param dx Horizontal displacement in CSS pixels since the press began.\n * @param dy Vertical displacement in CSS pixels since the press began.\n * @param tolerance Slack in CSS pixels, to absorb the finger tremor every real touch carries. Non-finite is `0`.\n * @returns `true` while the pointer remains within tolerance.\n */\nexport function withinTolerance(dx: number, dy: number, tolerance: number): boolean {\n  const limit = Number.isFinite(tolerance) ? Math.max(0, tolerance) : 0;\n  return Math.hypot(finiteOrZero(dx), finiteOrZero(dy)) <= limit;\n}\n\n/**\n * Applies a `pointerTypes` allowlist to one pointer.\n *\n * `undefined` means no filter — every input device is accepted. An EMPTY array is read literally as \"accept\n * nothing\" rather than being quietly upgraded to \"accept everything\": an allowlist that arrived empty from a\n * caller's own filtering should visibly disable the gesture, not silently widen it.\n *\n * @param pointerType The event's `pointerType` — conventionally `'mouse'`, `'touch'`, or `'pen'`.\n * @param allowed The allowlist, or `undefined` for no filtering.\n * @returns `true` when this pointer may drive the gesture.\n */\nexport function acceptsPointerType(pointerType: string, allowed: ReadonlyArray<string> | undefined): boolean {\n  if (allowed === undefined) return true;\n  return allowed.includes(pointerType);\n}\n\n/**\n * Clamps a long-press delay into the shared `PressExtensions.longPressDelay` bounds.\n *\n * The bounds are NOT redefined here — they are the same `min` / `max` / `default` every other press-driven\n * component in the library already honours, so a hold configured on a `Button` and a hold configured through\n * `useLongPress` can never disagree about what counts as \"too fast to be deliberate\".\n *\n * @param delayMs The requested delay in milliseconds; `undefined` or non-finite falls back to the shared default.\n * @returns A delay within `[min, max]`.\n */\nexport function clampLongPressDelay(delayMs: number | undefined): number {\n  const bounds = PressExtensions.longPressDelay;\n  if (delayMs === undefined || !Number.isFinite(delayMs)) return bounds.default;\n  return Math.min(bounds.max, Math.max(bounds.min, delayMs));\n}\n","// `useDrag` — the single-pointer engine the rest of this slice is built on. `useSwipe` is a thin reading of this\n// composable's end payload rather than a second recognizer, so the two can never disagree about where a pointer\n// went.\n//\n// WHY POINTER EVENTS AND NOTHING ELSE: a mouse/touch pair means writing the gesture twice, then discovering the\n// two disagree — touch fires a compatibility mouse sequence after every tap, `touchmove` has no capture model,\n// and a stylus is a third case both miss. `PointerEvent` is one stream for mouse, touch, and pen, carries the\n// device in `pointerType` (so an allowlist is a field read, not a UA sniff), and is the only one of the three with\n// `setPointerCapture`. There is no legacy fallback here on purpose: every browser this library targets ships it.\n//\n// WHY CAPTURE **AND** WINDOW LISTENERS — the non-obvious part. `setPointerCapture` keeps the element as the event\n// TARGET once the pointer wanders off it, which is what a consumer reading `event.target` expects and what stops\n// another element's hit-testing from interfering mid-drag. What it does not do is survive its own absence: if the\n// call fails (a stale pointer id, a test DOM without the method), events would simply stop arriving and the drag\n// would freeze mid-gesture with a consumer stuck in its dragging state. So the move/up/cancel listeners are bound\n// to `window` for the lifetime of the gesture — they arrive with or without capture — and capture is requested on\n// top for its targeting. Belt and braces, one set of listeners, no double-fire.\n//\n// SSR: the effect is post-flush and bails on a null element, so nothing here runs on the server — there is no\n// element to bind to. `window` is only ever touched from inside a `pointerdown` handler, which by construction\n// cannot fire outside a browser.\n//\n// TOUCH NEEDS `touch-action` — the one thing a consumer must do. The browser claims a touch pointer for scrolling\n// and then fires `pointercancel`, killing the drag mid-stroke. Set `touch-action: none` on the draggable element\n// (or `pan-y` / `pan-x` when only one axis is yours). This slice deliberately does not write the style itself: it\n// is headless, and silently blocking page scroll on a consumer's element is not a decision a composable should\n// make.\n//\n// NOTHING HERE ANIMATES, so nothing here consults `useReducedMotion` — these composables report where a pointer\n// went, which is a fact, not a motion preference. A consumer that TWEENS the reported delta (spring-back,\n// momentum, snap) owns that call and should read `foundation/device`' `useReducedMotion` at its own layer.\n\nimport { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\nimport { GestureAxis } from '../enums/GestureAxis';\nimport {\n  acceptsPointerType,\n  constrainToAxis,\n  exceedsThreshold,\n  windowedVelocity,\n  type GestureSample,\n} from '../GestureMath';\n\n/** How many trailing samples to retain for the velocity window — see `VelocityWindowMs`. */\nconst MaxSamples = 16;\n\n/**\n * Velocity is measured over the last ~80ms of movement, not over the whole gesture and not over the single last\n * event. Whole-gesture would report a flick that followed a long slow drag as slow. The single last event is\n * worse: `pointerup` usually repeats the final `pointermove` coordinates a few milliseconds later, so a genuine\n * flick would release at a velocity of zero. A short trailing window is what makes \"was that a flick\" answerable.\n */\nconst VelocityWindowMs = 80;\n\n/** What a drag handler receives — the full state of the gesture at the moment of the call. */\nexport interface DragPayload {\n  /** Horizontal distance from the press origin, in CSS pixels. Zeroed when `axis` is `'y'`. */\n  readonly dx: number;\n  /** Vertical distance from the press origin, in CSS pixels. Zeroed when `axis` is `'x'`. */\n  readonly dy: number;\n  /** Current pointer position — the event's `clientX`, viewport-relative and never axis-constrained. */\n  readonly x: number;\n  /** Current pointer position — the event's `clientY`, viewport-relative and never axis-constrained. */\n  readonly y: number;\n  /** Horizontal speed in px/ms over the recent movement window, NOT over the whole drag. Signed. */\n  readonly velocityX: number;\n  /** Vertical speed in px/ms over the recent movement window, NOT over the whole drag. Signed. */\n  readonly velocityY: number;\n  /** Milliseconds since the pointer went down — the whole gesture, unlike the velocity fields. */\n  readonly elapsedMs: number;\n  /** The DOM pointer event that produced this payload, for `preventDefault`, modifier keys, or `pointerType`. */\n  readonly event: PointerEvent;\n}\n\n/** The callbacks a drag can fire. Every one is optional. */\nexport interface DragHandlers {\n  /**\n   * Fired once the drag is recognized — immediately on pointer-down when `threshold` is `0`, otherwise on the\n   * first move that clears it.\n   */\n  readonly onDragStart?: (payload: DragPayload) => void;\n  /** Fired on each subsequent pointer move while the drag is active. */\n  readonly onDragMove?: (payload: DragPayload) => void;\n  /**\n   * Fired on pointer-up or pointer-cancel, but ONLY if the drag was recognized — a press that never cleared the\n   * threshold produces no start and therefore no end. Read `event.type` to tell a completion from a cancellation.\n   */\n  readonly onDragEnd?: (payload: DragPayload) => void;\n}\n\n/** Tunes how a drag is recognized. */\nexport interface DragOptions {\n  /**\n   * CSS pixels the pointer must travel before the drag is recognized. Defaults to `0` — recognized on\n   * pointer-down.\n   *\n   * Raise it to a few pixels whenever the same element is also clickable: below the threshold the interaction\n   * stays a press, so a click survives the hand tremor that accompanies every real tap.\n   */\n  readonly threshold?: number;\n\n  /** Axis the drag is locked to — gates recognition AND zeroes the off-axis delta. Defaults to `'both'`. */\n  readonly axis?: GestureAxis;\n\n  /**\n   * Whether the drag is inert. Checked when the pointer goes DOWN; a gesture already in flight completes normally\n   * rather than stranding a consumer mid-drag with no `onDragEnd`.\n   */\n  readonly disabled?: boolean;\n\n  /**\n   * Input devices allowed to drive the drag — conventionally `'mouse'`, `'touch'`, `'pen'`. Omit for no filter.\n   * An empty array accepts nothing, which is the literal reading and makes an accidentally-empty list obvious.\n   */\n  readonly pointerTypes?: ReadonlyArray<string>;\n}\n\n/** Mutable state of one in-flight drag; `null` between gestures. */\ninterface DragState {\n  pointerId: number;\n  originX: number;\n  originY: number;\n  startTime: number;\n  recognized: boolean;\n  samples: GestureSample[];\n}\n\n/**\n * Tracks a single-pointer drag on `target`, reporting distance, position, and recent velocity.\n *\n * Takes the element as a ref or getter rather than handing one back, so the caller keeps ownership of its\n * `useTemplateRef`. Options are read through `toValue` at call time, so a reactive `disabled` or `axis` takes\n * effect without re-attaching the listener; only the element identity re-binds. When the scope is disposed every\n * listener is detached and any held pointer capture released.\n *\n * Nothing throws: a missing element, an unavailable `setPointerCapture`, or a pointer that vanishes without an\n * up event all resolve quietly.\n *\n * @param target The element to watch. A `null` value simply binds nothing.\n * @param handlers Drag lifecycle callbacks.\n * @param options Recognition tuning — threshold, axis, disabled, pointer-type filter.\n */\nexport function useDrag(\n  target: MaybeRefOrGetter<HTMLElement | null | undefined>,\n  handlers: DragHandlers,\n  options?: MaybeRefOrGetter<DragOptions | undefined>,\n): void {\n  watchPostEffect((onCleanup) => {\n    const current = toValue(target);\n    if (!current) return;\n    // Re-bound with an explicit type: TypeScript does not carry a narrowing into a hoisted function DECLARATION\n    // (it cannot prove the declaration is not called before the guard), and every handler below is one. The alias\n    // is what keeps the listeners free of `element!` and repeated null checks.\n    const element: HTMLElement = current;\n\n    let state: DragState | null = null;\n    // Held so both the gesture's own end and the watcher's cleanup can detach the window listeners exactly once.\n    let detachWindow: (() => void) | null = null;\n\n    /** Builds the payload shared by every handler call, applying the axis constraint to deltas and velocity. */\n    function toPayload(active: DragState, event: PointerEvent): DragPayload {\n      const axis = toValue(options)?.axis ?? GestureAxis.Both;\n      const { dx, dy } = constrainToAxis(event.clientX - active.originX, event.clientY - active.originY, axis);\n      const velocity = windowedVelocity(active.samples, VelocityWindowMs);\n      const constrainedVelocity = constrainToAxis(velocity.velocityX, velocity.velocityY, axis);\n      return {\n        dx,\n        dy,\n        x: event.clientX,\n        y: event.clientY,\n        velocityX: constrainedVelocity.dx,\n        velocityY: constrainedVelocity.dy,\n        elapsedMs: event.timeStamp - active.startTime,\n        event,\n      };\n    }\n\n    /** Appends a sample, dropping the oldest once the window can no longer need it. */\n    function sample(active: DragState, event: PointerEvent): void {\n      active.samples.push({ x: event.clientX, y: event.clientY, t: event.timeStamp });\n      if (active.samples.length > MaxSamples) active.samples.shift();\n    }\n\n    /** Releases capture defensively — the pointer may already be gone, which is not an error worth throwing on. */\n    function releaseCapture(pointerId: number): void {\n      try {\n        if (element.hasPointerCapture(pointerId)) element.releasePointerCapture(pointerId);\n      } catch {\n        // Capture was never held, or the pointer id is stale. Either way there is nothing to release.\n      }\n    }\n\n    /** Tears down one gesture: window listeners off, capture released, state cleared. */\n    function finish(): void {\n      if (detachWindow !== null) {\n        detachWindow();\n        detachWindow = null;\n      }\n      if (state !== null) releaseCapture(state.pointerId);\n      state = null;\n    }\n\n    function onPointerMove(event: PointerEvent): void {\n      if (state === null || event.pointerId !== state.pointerId) return;\n      sample(state, event);\n\n      if (!state.recognized) {\n        const axis = toValue(options)?.axis ?? GestureAxis.Both;\n        const threshold = toValue(options)?.threshold ?? 0;\n        const rawDx = event.clientX - state.originX;\n        const rawDy = event.clientY - state.originY;\n        if (!exceedsThreshold(rawDx, rawDy, threshold, axis)) return;\n        state.recognized = true;\n        handlers.onDragStart?.(toPayload(state, event));\n        return; // The move that starts a drag is the start, not also a move.\n      }\n\n      handlers.onDragMove?.(toPayload(state, event));\n    }\n\n    function onPointerEnd(event: PointerEvent): void {\n      if (state === null || event.pointerId !== state.pointerId) return;\n      sample(state, event);\n      const recognized = state.recognized;\n      const payload = toPayload(state, event);\n      finish();\n      // Fired after teardown so a handler that starts a new gesture (or unmounts) finds clean state.\n      if (recognized) handlers.onDragEnd?.(payload);\n    }\n\n    function onPointerDown(event: PointerEvent): void {\n      const opts = toValue(options);\n      if (opts?.disabled === true) return;\n      if (!acceptsPointerType(event.pointerType, opts?.pointerTypes)) return;\n      if (state !== null) return; // Single-pointer gesture — a second finger belongs to `usePinch`, not here.\n\n      state = {\n        pointerId: event.pointerId,\n        originX: event.clientX,\n        originY: event.clientY,\n        startTime: event.timeStamp,\n        recognized: false,\n        samples: [{ x: event.clientX, y: event.clientY, t: event.timeStamp }],\n      };\n\n      // Requested at DOWN, not at recognition: a fast flick can leave the element before the threshold is even\n      // cleared, and capture has to already be in place for the element to stay the target when it does.\n      try {\n        element.setPointerCapture(event.pointerId);\n      } catch {\n        // No capture available (stale pointer, or a DOM without the method). The window listeners below still\n        // deliver every move, so the drag degrades to \"works, but `event.target` may not be this element\".\n      }\n\n      window.addEventListener('pointermove', onPointerMove);\n      window.addEventListener('pointerup', onPointerEnd);\n      window.addEventListener('pointercancel', onPointerEnd);\n      detachWindow = () => {\n        window.removeEventListener('pointermove', onPointerMove);\n        window.removeEventListener('pointerup', onPointerEnd);\n        window.removeEventListener('pointercancel', onPointerEnd);\n      };\n\n      const threshold = opts?.threshold ?? 0;\n      // A zero threshold means \"recognized on contact\" — fire the start now rather than waiting for a move that\n      // a tap-and-hold would never produce.\n      if (threshold <= 0) {\n        state.recognized = true;\n        handlers.onDragStart?.(toPayload(state, event));\n      }\n    }\n\n    element.addEventListener('pointerdown', onPointerDown);\n    onCleanup(() => {\n      element.removeEventListener('pointerdown', onPointerDown);\n      finish(); // Torn down mid-drag: window listeners off and capture released, no dangling gesture.\n    });\n  });\n}\n","// `useSwipe` — a flick recognizer that is deliberately NOT its own pointer implementation. It runs `useDrag` with\n// a zero threshold and reads the end payload; every listener, the capture handling, the pointer-type filter, and\n// the velocity window all come from there. A second listener stack would be a second set of edge cases (a pointer\n// that cancels, a drag that outlives its element) resolved slightly differently, and the two recognizers would\n// eventually disagree about where the same finger went.\n//\n// A SWIPE IS DISTANCE **AND** SPEED, both required. Distance alone promotes a slow deliberate drag into a flick,\n// which is how a carousel ends up advancing when the user was carefully positioning something. Speed alone\n// promotes a 3px twitch. Requiring both is what makes the gesture mean \"thrown\", and it is why the two thresholds\n// are separate knobs rather than one blended score a consumer could not reason about.\n//\n// ONE DIRECTION PER GESTURE, resolved at release from the total displacement — not accumulated per move. A finger\n// that arcs out and back reports where it ENDED relative to where it began, which is the thing the user meant.\n\nimport { toValue, type MaybeRefOrGetter } from 'vue';\n\nimport { GestureAxis } from '../enums/GestureAxis';\nimport { swipeDirection } from '../GestureMath';\nimport { SwipeDirection } from '../enums/SwipeDirection';\nimport { useDrag, type DragPayload } from './UseDrag';\n\n/** Default travel required before a flick counts, in CSS pixels — roughly a thumb's comfortable arc. */\nconst DefaultSwipeThreshold = 50;\n\n/** Default speed required, in px/ms (300 px/s) — above a deliberate drag, below a hurried one. */\nconst DefaultVelocityThreshold = 0.3;\n\n/** What `onSwipe` receives once a flick is recognized. */\nexport interface SwipePayload {\n  /** Which way the flick went, from the total displacement between press and release. */\n  readonly direction: SwipeDirection;\n  /** How far it travelled ALONG that direction's axis, in CSS pixels. Always positive. */\n  readonly distance: number;\n  /** Release speed along that same axis, in px/ms, over the recent movement window. Always positive. */\n  readonly velocity: number;\n  /** The pointerup event that completed the gesture; cancelled pointers never produce a swipe. */\n  readonly event: PointerEvent;\n}\n\n/** The callbacks a swipe can fire. */\nexport interface SwipeHandlers {\n  /** Fired once per gesture, at release, only when both the distance and velocity thresholds are met. */\n  readonly onSwipe?: (payload: SwipePayload) => void;\n}\n\n/** Tunes how a flick is recognized. */\nexport interface SwipeOptions {\n  /** CSS pixels the pointer must travel along the swipe axis. Defaults to `50`. */\n  readonly threshold?: number;\n\n  /** Speed in px/ms the pointer must still carry at release. Defaults to `0.3` (300 px/s). */\n  readonly velocityThreshold?: number;\n\n  /**\n   * Axis to restrict recognition to. `'x'` reports only `'left'` / `'right'`, `'y'` only `'up'` / `'down'`.\n   * Defaults to `'both'`.\n   */\n  readonly axis?: GestureAxis;\n\n  /** Whether the gesture is inert. Checked when the pointer goes down. */\n  readonly disabled?: boolean;\n\n  /** Input devices allowed to drive the swipe. Omit for no filter; see {@link useDrag} for the empty-array rule. */\n  readonly pointerTypes?: ReadonlyArray<string>;\n}\n\n/**\n * Recognizes a directional flick on `target`.\n *\n * Built on {@link useDrag}, so it inherits pointer capture, the pointer-type filter, and the same cleanup\n * guarantees: on scope disposal every listener is detached and any capture released. Nothing throws.\n *\n * @param target The element to watch, as a ref or getter.\n * @param handlers Swipe callbacks.\n * @param options Distance / velocity thresholds, axis, disabled, pointer-type filter.\n */\nexport function useSwipe(\n  target: MaybeRefOrGetter<HTMLElement | null | undefined>,\n  handlers: SwipeHandlers,\n  options?: MaybeRefOrGetter<SwipeOptions | undefined>,\n): void {\n  useDrag(\n    target,\n    {\n      onDragEnd: (payload: DragPayload): void => {\n        if (payload.event.type === 'pointercancel') return;\n        const opts = toValue(options);\n        const direction = swipeDirection(payload.dx, payload.dy);\n        if (direction === null) return; // Pressed and released without moving — not a swipe.\n\n        const horizontal = direction === SwipeDirection.Left || direction === SwipeDirection.Right;\n        const distance = Math.abs(horizontal ? payload.dx : payload.dy);\n        const velocity = Math.abs(horizontal ? payload.velocityX : payload.velocityY);\n\n        const threshold = opts?.threshold ?? DefaultSwipeThreshold;\n        const velocityThreshold = opts?.velocityThreshold ?? DefaultVelocityThreshold;\n        if (distance < threshold || velocity < velocityThreshold) return;\n\n        handlers.onSwipe?.({ direction, distance, velocity, event: payload.event });\n      },\n    },\n    // A getter, so the drag re-reads the swipe's own axis / disabled / pointer-type values live rather than\n    // pinning whatever they were at setup.\n    () => ({\n      // Zero threshold so the underlying drag tracks from first contact: the swipe's own distance gate is what\n      // decides, and a drag-level threshold would only subtract from the displacement measured here.\n      threshold: 0,\n      axis: toValue(options)?.axis ?? GestureAxis.Both,\n      disabled: toValue(options)?.disabled,\n      pointerTypes: toValue(options)?.pointerTypes,\n    }),\n  );\n}\n","// `useLongPress` — fires once the pointer has been held still for long enough.\n//\n// THE DELAY IS NOT THIS SLICE'S TO INVENT. `PressExtensions.longPressDelay` already defines the `min` / `max` /\n// `default` every press-driven component in the library honours, and `clampLongPressDelay` in `GestureMath` is the\n// only place a requested delay meets those bounds. A second 500 here would be a second source of truth that drifts\n// the first time one of them is tuned — a hold on a `Button` and a hold through this composable must mean the\n// same thing.\n//\n// WHY A MOVE TOLERANCE RATHER THAN \"ANY MOVEMENT CANCELS\": no real touch is still. A finger resting on glass\n// wanders a few pixels from tremor alone and a stylus is worse, so a zero-slack rule makes long-press fire for\n// mice and almost never for the touchscreens it exists to serve. The tolerance is straight-line, not per-axis —\n// a hold has no direction to be lenient about.\n//\n// NO POINTER CAPTURE HERE, deliberately, unlike `useDrag`. Capture exists to keep tracking a pointer that LEAVES\n// the element; a hold that leaves the element is a hold that has been abandoned, and should cancel. The move and\n// release listeners go on `window` precisely so that departure is observed rather than missed.\n//\n// SSR: the effect is post-flush and bails on a null element, so nothing here runs on the server, and `window` is\n// only ever touched from inside a `pointerdown` handler.\n\nimport { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\nimport { acceptsPointerType, clampLongPressDelay, withinTolerance } from '../GestureMath';\n\n/** Default slack in CSS pixels — wide enough for finger tremor, tight enough that a deliberate drag cancels. */\nconst DefaultMoveTolerance = 10;\n\n/** What the long-press handler receives when the hold completes. */\nexport interface LongPressPayload {\n  /** Where the press began — `clientX` of the pointer-down, not of the moment the timer elapsed. */\n  readonly x: number;\n  /** Where the press began — `clientY` of the pointer-down. */\n  readonly y: number;\n  /**\n   * The `pointerdown` event that opened the hold. There is no event for the completion itself: a timer fired, and\n   * inventing a synthetic one would misreport `timeStamp` and `target`.\n   */\n  readonly event: PointerEvent;\n}\n\n/** Tunes how a hold is recognized. */\nexport interface LongPressOptions {\n  /**\n   * Hold duration in milliseconds before the handler fires. Defaults to `PressExtensions.longPressDelay.default`\n   * and is clamped into that same shared `[min, max]` range — this composable defines no bounds of its own.\n   */\n  readonly delayMs?: number;\n\n  /** CSS pixels the pointer may drift before the hold is abandoned. Defaults to `10`. */\n  readonly moveTolerance?: number;\n\n  /** Whether the gesture is inert. Checked when the pointer goes down. */\n  readonly disabled?: boolean;\n\n  /** Input devices allowed to drive the hold. Omit for no filter; an empty array accepts nothing. */\n  readonly pointerTypes?: ReadonlyArray<string>;\n}\n\n/** Mutable state of one in-flight hold; `null` between presses. */\ninterface LongPressState {\n  pointerId: number;\n  originX: number;\n  originY: number;\n  timer: ReturnType<typeof setTimeout>;\n}\n\n/**\n * Fires `handler` after the pointer has been held on `target` for `delayMs` without drifting beyond\n * `moveTolerance`.\n *\n * Cancels on pointer-up, on pointer-cancel, and on any move past the tolerance. The pending timer is cleared when\n * the scope is disposed, so a component that disappears mid-hold can never fire into a dead tree.\n *\n * Takes the element as a ref or getter rather than handing one back. Options are read through `toValue` at call\n * time, so a reactive `disabled` or `delayMs` takes effect without re-attaching. Nothing throws.\n *\n * @param target The element to watch.\n * @param handler Called once when the hold completes.\n * @param options Delay, move tolerance, disabled, pointer-type filter.\n */\nexport function useLongPress(\n  target: MaybeRefOrGetter<HTMLElement | null | undefined>,\n  handler: (payload: LongPressPayload) => void,\n  options?: MaybeRefOrGetter<LongPressOptions | undefined>,\n): void {\n  watchPostEffect((onCleanup) => {\n    const current = toValue(target);\n    if (!current) return;\n    // Re-bound with an explicit type: TypeScript does not carry a narrowing into a hoisted function DECLARATION,\n    // and every handler below is one. See the same note in `UseDrag`.\n    const element: HTMLElement = current;\n\n    let state: LongPressState | null = null;\n    // Held so both a cancelled hold and the watcher's cleanup detach the window listeners exactly once.\n    let detachWindow: (() => void) | null = null;\n\n    /** Clears the pending timer and window listeners. The single teardown path for every outcome. */\n    function cancel(): void {\n      if (state !== null) {\n        clearTimeout(state.timer);\n        state = null;\n      }\n      if (detachWindow !== null) {\n        detachWindow();\n        detachWindow = null;\n      }\n    }\n\n    function onPointerMove(event: PointerEvent): void {\n      if (state === null || event.pointerId !== state.pointerId) return;\n      const tolerance = toValue(options)?.moveTolerance ?? DefaultMoveTolerance;\n      if (withinTolerance(event.clientX - state.originX, event.clientY - state.originY, tolerance)) return;\n      cancel(); // Drifted too far — this is a drag, not a hold.\n    }\n\n    function onPointerEnd(event: PointerEvent): void {\n      if (state?.pointerId === event.pointerId) cancel();\n    }\n\n    function onPointerDown(event: PointerEvent): void {\n      const opts = toValue(options);\n      if (opts?.disabled === true) return;\n      if (!acceptsPointerType(event.pointerType, opts?.pointerTypes)) return;\n      if (state !== null) return; // A hold is already in flight; a second pointer does not restart it.\n\n      const delay = clampLongPressDelay(opts?.delayMs);\n      const timer = setTimeout(() => {\n        const payload: LongPressPayload = { x: event.clientX, y: event.clientY, event };\n        // Cleared BEFORE the handler runs: the hold is complete, so a later pointer-up must find nothing to\n        // cancel, and a handler that unmounts the tree must not leave a live timer behind it.\n        cancel();\n        handler(payload);\n      }, delay);\n\n      state = { pointerId: event.pointerId, originX: event.clientX, originY: event.clientY, timer };\n\n      window.addEventListener('pointermove', onPointerMove);\n      window.addEventListener('pointerup', onPointerEnd);\n      window.addEventListener('pointercancel', onPointerEnd);\n      detachWindow = () => {\n        window.removeEventListener('pointermove', onPointerMove);\n        window.removeEventListener('pointerup', onPointerEnd);\n        window.removeEventListener('pointercancel', onPointerEnd);\n      };\n    }\n\n    element.addEventListener('pointerdown', onPointerDown);\n    onCleanup(() => {\n      element.removeEventListener('pointerdown', onPointerDown);\n      cancel(); // Torn down mid-hold: timer cleared, listeners detached.\n    });\n  });\n}\n","// `usePinch` — two-pointer scale and rotation, the one gesture in this slice that cannot reuse `useDrag`: that\n// composable is single-pointer by construction (a second `pointerdown` is ignored), and a pinch is defined by the\n// RELATION between two pointers rather than by either one's path.\n//\n// WHY A MAP KEYED BY `pointerId`: pointer events arrive interleaved and independently — two fingers produce two\n// separate `pointermove` streams that share no ordering guarantee, and either may cancel alone. Tracking \"finger\n// one and finger two\" as variables desynchronizes the moment they arrive out of order. The map is the only\n// structure that answers \"where is pointer 7 right now\" without caring when pointer 3 last moved.\n//\n// SCALE AND ROTATION ARE MEASURED FROM THE PINCH'S OWN ORIGIN, not from the previous frame. Per-frame deltas\n// compound their own rounding error, so a finger returning to exactly where it started would not return the\n// consumer's transform to 1.0. Anchoring both to the separation and angle captured at pinch-start means the\n// gesture is always reversible.\n//\n// A THIRD FINGER IS TRACKED BUT NOT PROMOTED. The active pair is fixed when the pinch starts; extra pointers sit\n// in the map unused. When one of the pair lifts, the pinch ENDS — and immediately re-arms on the two pointers\n// still down, so a hand rolling across the surface produces clean end/start pairs instead of a transform that\n// teleports as the anchors silently swap underneath it.\n//\n// SSR: the effect is post-flush and bails on a null element, so nothing here runs on the server, and `window` is\n// only ever touched from inside a `pointerdown` handler.\n\nimport { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\nimport {\n  acceptsPointerType,\n  pinchRotation,\n  pinchScale,\n  pointerAngle,\n  pointerCenter,\n  pointerDistance,\n  type GesturePoint,\n} from '../GestureMath';\n\n/** What a pinch handler receives — the gesture's state relative to where the pinch began. */\nexport interface PinchPayload {\n  /** Separation now, over separation at pinch-start: `1` unchanged, `2` doubled, `0.5` halved. */\n  readonly scale: number;\n  /** Degrees turned since pinch-start, within `[-180, 180)`. Positive is clockwise on screen. */\n  readonly rotation: number;\n  /** Midpoint of the two active pointers, in viewport coordinates — the anchor to transform about. */\n  readonly center: GesturePoint;\n  /** The pointer event that produced this payload. */\n  readonly event: PointerEvent;\n}\n\n/** The callbacks a pinch can fire. All optional. */\nexport interface PinchHandlers {\n  /** Fired when a second pointer goes down, with `scale: 1` and `rotation: 0` — the gesture's own origin. */\n  readonly onPinchStart?: (payload: PinchPayload) => void;\n  /** Fired when either pointer of the active pair moves. */\n  readonly onPinchMove?: (payload: PinchPayload) => void;\n  /** Fired when either pointer of the active pair lifts or cancels, carrying the last computed values. */\n  readonly onPinchEnd?: (payload: PinchPayload) => void;\n}\n\n/** Tunes how a pinch is recognized. */\nexport interface PinchOptions {\n  /** Whether the gesture is inert. Checked when each pointer goes down. */\n  readonly disabled?: boolean;\n\n  /**\n   * Input devices allowed to drive the pinch — in practice `'touch'` or `'pen'`, since a mouse has one pointer.\n   * Omit for no filter; an empty array accepts nothing.\n   */\n  readonly pointerTypes?: ReadonlyArray<string>;\n}\n\n/** The fixed anchors of one in-flight pinch; `null` when fewer than two pointers are down. */\ninterface PinchState {\n  readonly idA: number;\n  readonly idB: number;\n  readonly startDistance: number;\n  readonly startAngle: number;\n}\n\n/**\n * Tracks a two-pointer pinch on `target`, reporting scale, rotation, and the pinch centre.\n *\n * Ignored entirely while fewer than two pointers are down. Takes the element as a ref or getter rather than\n * handing one back; options are read through `toValue` at call time. When the scope is disposed every listener is\n * detached and every held pointer capture released. Nothing throws.\n *\n * Touch pinches need `touch-action: none` on the element, or the browser claims the pointers for page zoom and\n * fires `pointercancel` mid-gesture.\n *\n * @param target The element to watch.\n * @param handlers Pinch lifecycle callbacks.\n * @param options Disabled flag and pointer-type filter.\n */\nexport function usePinch(\n  target: MaybeRefOrGetter<HTMLElement | null | undefined>,\n  handlers: PinchHandlers,\n  options?: MaybeRefOrGetter<PinchOptions | undefined>,\n): void {\n  watchPostEffect((onCleanup) => {\n    const current = toValue(target);\n    if (!current) return;\n    // Re-bound with an explicit type: TypeScript does not carry a narrowing into a hoisted function DECLARATION,\n    // and every handler below is one. See the same note in `UseDrag`.\n    const element: HTMLElement = current;\n\n    /** Live position of every pointer currently down on the element, in insertion order. */\n    const pointers = new Map<number, GesturePoint>();\n    let state: PinchState | null = null;\n    let detachWindow: (() => void) | null = null;\n\n    /** Releases capture defensively — a pointer that already went away is not an error worth throwing on. */\n    function releaseCapture(pointerId: number): void {\n      try {\n        if (element.hasPointerCapture(pointerId)) element.releasePointerCapture(pointerId);\n      } catch {\n        // Capture was never held, or the pointer id is stale. Nothing to release.\n      }\n    }\n\n    /** Detaches the window listeners once no pointer remains. */\n    function detachIfIdle(): void {\n      if (pointers.size > 0 || detachWindow === null) return;\n      detachWindow();\n      detachWindow = null;\n    }\n\n    /** The two oldest live pointers, or `null` when fewer than two are down. */\n    function activePair(): readonly [number, number] | null {\n      const iterator = pointers.keys();\n      const first = iterator.next();\n      const second = iterator.next();\n      if (!first.done && !second.done) return [first.value, second.value];\n      return null;\n    }\n\n    /** Builds a payload from the active pair's current positions, or `null` if either has gone. */\n    function toPayload(active: PinchState, event: PointerEvent): PinchPayload | null {\n      const a = pointers.get(active.idA);\n      const b = pointers.get(active.idB);\n      if (a === undefined || b === undefined) return null;\n      return {\n        scale: pinchScale(active.startDistance, pointerDistance(a, b)),\n        rotation: pinchRotation(active.startAngle, pointerAngle(a, b)),\n        center: pointerCenter(a, b),\n        event,\n      };\n    }\n\n    /** Arms a pinch on the two oldest live pointers, if two are down and none is already armed. */\n    function tryStart(event: PointerEvent): void {\n      if (state !== null) return;\n      const pair = activePair();\n      if (pair === null) return;\n      const a = pointers.get(pair[0]);\n      const b = pointers.get(pair[1]);\n      if (a === undefined || b === undefined) return;\n\n      state = {\n        idA: pair[0],\n        idB: pair[1],\n        startDistance: pointerDistance(a, b),\n        startAngle: pointerAngle(a, b),\n      };\n      const payload = toPayload(state, event);\n      if (payload !== null) handlers.onPinchStart?.(payload);\n    }\n\n    function onPointerMove(event: PointerEvent): void {\n      if (!pointers.has(event.pointerId)) return;\n      pointers.set(event.pointerId, { x: event.clientX, y: event.clientY });\n      if (state === null) return;\n      if (event.pointerId !== state.idA && event.pointerId !== state.idB) return; // A spectator finger moved.\n\n      const payload = toPayload(state, event);\n      if (payload !== null) handlers.onPinchMove?.(payload);\n    }\n\n    function onPointerEnd(event: PointerEvent): void {\n      if (!pointers.has(event.pointerId)) return;\n      const wasAnchor = state !== null && (event.pointerId === state.idA || event.pointerId === state.idB);\n\n      // The payload is computed BEFORE the pointer leaves the map, so the end call carries the last real geometry\n      // rather than a hole where one anchor used to be.\n      const payload = wasAnchor && state !== null ? toPayload(state, event) : null;\n\n      releaseCapture(event.pointerId);\n      pointers.delete(event.pointerId);\n\n      if (wasAnchor) {\n        state = null;\n        if (payload !== null) handlers.onPinchEnd?.(payload);\n        tryStart(event); // Re-arm on whatever is still down, so a rolling hand gets clean end/start pairs.\n      }\n      detachIfIdle();\n    }\n\n    function onPointerDown(event: PointerEvent): void {\n      const opts = toValue(options);\n      if (opts?.disabled === true) return;\n      if (!acceptsPointerType(event.pointerType, opts?.pointerTypes)) return;\n\n      pointers.set(event.pointerId, { x: event.clientX, y: event.clientY });\n\n      try {\n        element.setPointerCapture(event.pointerId);\n      } catch {\n        // No capture available. The window listeners below still deliver every move.\n      }\n\n      if (detachWindow === null) {\n        window.addEventListener('pointermove', onPointerMove);\n        window.addEventListener('pointerup', onPointerEnd);\n        window.addEventListener('pointercancel', onPointerEnd);\n        detachWindow = () => {\n          window.removeEventListener('pointermove', onPointerMove);\n          window.removeEventListener('pointerup', onPointerEnd);\n          window.removeEventListener('pointercancel', onPointerEnd);\n        };\n      }\n\n      tryStart(event);\n    }\n\n    element.addEventListener('pointerdown', onPointerDown);\n    onCleanup(() => {\n      element.removeEventListener('pointerdown', onPointerDown);\n      for (const pointerId of pointers.keys()) releaseCapture(pointerId);\n      pointers.clear();\n      state = null;\n      detachIfIdle();\n    });\n  });\n}\n"],"names":[],"mappings":"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"}

package/dist/foundation/history/HistoryCore.d.ts

@@ -0,0 +1,92 @@
+/** Notified after any change to a history — push, undo, redo, or clear. Carries no payload; re-read the store. */
+export type HistoryListener = () => void;
+/** Identifies which direction of travel threw, so an `onError` handler can word its message. */
+export declare const HistoryPhase: {
+    /** The failure came from an entry's `undo` work. */
+    readonly Undo: "undo";
+    /** The failure came from an entry's `do` work, replayed by `redo()`. */
+    readonly Redo: "redo";
+};
+export type HistoryPhase = (typeof HistoryPhase)[keyof typeof HistoryPhase];
+/** Receives an error thrown while travelling the stack, alongside the direction that threw. */
+export type HistoryErrorHandler = (error: unknown, phase: HistoryPhase) => void;
+/** The default coalescing window — roughly one typing burst, so a typed word collapses into one undo step. */
+export declare const DefaultCoalesceMs = 500;
+/** Tunes a history at creation. Every field is optional; the default is an unbounded, 500 ms-coalescing history. */
+export interface HistoryOptions {
+    /**
+     * Caps how many entries are retained. Exceeding it discards the OLDEST entry, so recent work always survives.
+     * Omitted → unbounded.
+     */
+    readonly limit?: number;
+    /**
+     * How long after an entry a same-keyed push still merges into it, in milliseconds.
+     * Defaults to {@link DefaultCoalesceMs}. Only pushes carrying a `coalesceKey` are ever candidates.
+     */
+    readonly coalesceMs?: number;
+    /** Where an error thrown by an entry's `do` / `undo` work is reported. Omitted → the failure is swallowed. */
+    readonly onError?: HistoryErrorHandler;
+    /** The clock coalescing measures against. Defaults to `Date.now`; inject one to make the window deterministic. */
+    readonly now?: () => number;
+}
+/** The minimum surface a keybinding, toolbar, or menu needs — satisfied by both history flavors. */
+export interface UndoRedoTarget {
+    /** Reverses the most recent entry. Returns whether anything was undone (`false` at the bottom, or on failure). */
+    readonly undo: () => boolean;
+    /** Re-applies the next entry on the redo branch. Returns whether anything was redone. */
+    readonly redo: () => boolean;
+    /** Whether an entry is available to undo. */
+    readonly canUndo: boolean;
+    /** Whether an entry is available to redo. */
+    readonly canRedo: boolean;
+}
+/** Everything both flavors share — travel, grouping, introspection, and change notification. */
+export interface HistoryStore extends UndoRedoTarget {
+    /**
+     * Groups every push made inside `fn` into ONE reversible entry labelled `label`, and returns `fn`'s result.
+     * Nested calls flatten into the outermost group. A throwing `fn` still commits what it buffered, then rethrows.
+     */
+    readonly transact: <TResult>(label: string | undefined, fn: () => TResult) => TResult;
+    /** Drops every entry (both directions). State already applied stays applied — this forgets, it does not revert. */
+    readonly clear: () => void;
+    /** Subscribes to changes; returns an unsubscribe. */
+    readonly subscribe: (listener: HistoryListener) => () => void;
+    /** A monotonic counter bumped on every change — the identity-stable snapshot the composables subscribe to. */
+    readonly version: () => number;
+    /** How many entries are retained across both directions — what a history panel lists. */
+    readonly size: number;
+    /** The label of the entry `undo()` would reverse — the text for an "Undo {label}" menu item. */
+    readonly undoLabel: string | undefined;
+    /** The label of the entry `redo()` would re-apply. */
+    readonly redoLabel: string | undefined;
+}
+/** One entry as handed to the core — the flavor supplies the payload, the core owns everything else. */
+export interface HistoryPushRequest<TPayload> {
+    /** Human label for menus and history panels. */
+    readonly label?: string;
+    /** The flavor-specific work or state this entry carries. */
+    readonly payload: TPayload;
+    /** Merges this push into the previous entry when they share the key and land inside the coalescing window. */
+    readonly coalesceKey?: string;
+}
+/** The core store — a {@link HistoryStore} plus the payload-level `push` each flavor wraps in its own API. */
+export interface HistoryCore<TPayload> extends HistoryStore {
+    /** Records one entry, applying the truncate / evict / coalesce / buffer rules. Never runs the payload. */
+    readonly push: (request: HistoryPushRequest<TPayload>) => void;
+}
+/** How a flavor teaches the core to travel over, and merge, its own payload type. */
+export interface HistoryCoreConfig<TPayload> {
+    /** Moves the world forward over a payload — the redo direction. May throw; the core keeps the cursor put. */
+    readonly applyForward: (payload: TPayload) => void;
+    /** Moves the world backward over a payload — the undo direction. May throw; the core keeps the cursor put. */
+    readonly applyBackward: (payload: TPayload) => void;
+    /** Fuses two adjacent payloads into one that travels like both — used by coalescing and by `transact`. */
+    readonly mergePayloads: (previous: TPayload, next: TPayload) => TPayload;
+    /** The creation-time options, read live on every use so a flavor can pass its caller's object straight through. */
+    readonly options: HistoryOptions | undefined;
+}
+/**
+ * Builds the shared engine. Not exported from the slice barrel — consumers take `createUndoHistory` or
+ * `createSnapshotHistory`, which are this core plus a payload type.
+ */
+export declare function createHistoryCore<TPayload>(config: HistoryCoreConfig<TPayload>): HistoryCore<TPayload>;

package/dist/foundation/history/hooks/UseUndoHistory.d.ts

@@ -0,0 +1,66 @@
+import { MaybeRefOrGetter, ShallowRef, WritableComputedRef } from 'vue';
+import { HistoryOptions, HistoryStore } from '../HistoryCore';
+import { SnapshotHistory, SnapshotRecordOptions } from '../SnapshotHistory';
+import { UndoHistory } from '../UndoHistory';
+/**
+ * Subscribes to a history's changes and returns its version counter, updating on every push, undo, redo, and
+ * clear. Use it directly when the history is owned outside a component (a module-scope editor store) and read
+ * it inside a `computed` to make that computed track the history.
+ */
+export declare function useHistoryVersion(store: HistoryStore): Readonly<ShallowRef<number>>;
+/** What {@link useUndoHistory} returns — the history plus the cursor that makes it reactive. */
+export interface UndoHistoryControls {
+    /** The history itself. Stable — pass it down, or to {@link useUndoShortcuts}, unchanged. */
+    readonly history: UndoHistory;
+    /**
+     * The mutation cursor. Its members are getters, so read them inside a `computed` that also touches this —
+     * `computed(() => (version.value, history.canUndo))` — and the computed re-evaluates on every change.
+     */
+    readonly version: Readonly<ShallowRef<number>>;
+    /** Whether an undo is available. The pre-derived form of the `version` idiom above. */
+    readonly canUndo: Readonly<ShallowRef<boolean>>;
+    /** Whether a redo is available. */
+    readonly canRedo: Readonly<ShallowRef<boolean>>;
+}
+/**
+ * Owns a command-based {@link UndoHistory} for the scope's lifetime and exposes its reactivity.
+ *
+ * Returns the history alongside the version cursor and the two flags a toolbar actually renders. The history
+ * object never changes identity — pass it down, or to {@link useUndoShortcuts}, without wrapping.
+ *
+ * @param options History configuration. `limit` / `coalesceMs` are read once; `onError` / `now` stay live.
+ */
+export declare function useUndoHistory(options?: MaybeRefOrGetter<HistoryOptions | undefined>): UndoHistoryControls;
+/** Publishes the next state — a value or an updater, plus how this particular change should be recorded. */
+export type UndoableStateSetter<TState> = (next: TState | ((previous: TState) => TState), options?: SnapshotRecordOptions) => void;
+/** What {@link useUndoableState} returns — the value, its setter, and the history behind them. */
+export interface UndoableState<TState> {
+    /**
+     * The current state. Writable, so it drops straight into `v-model`; a `v-model` write records with no options,
+     * and `setState` is the way to pass `{ label, coalesceKey }`.
+     */
+    readonly state: WritableComputedRef<TState>;
+    /** Records the next state — a value or an updater — with optional per-call record options. */
+    readonly setState: UndoableStateSetter<TState>;
+    /** The full {@link SnapshotHistory}: `undo` / `redo` / `canUndo` / `transact`, and the target for shortcuts. */
+    readonly history: SnapshotHistory<TState>;
+    /** The mutation cursor, for deriving anything the two flags below do not cover. */
+    readonly version: Readonly<ShallowRef<number>>;
+    /** Whether an undo is available. */
+    readonly canUndo: Readonly<ShallowRef<boolean>>;
+    /** Whether a redo is available. */
+    readonly canRedo: Readonly<ShallowRef<boolean>>;
+}
+/**
+ * A `ref` with a history behind it — the snapshot flavor as a drop-in for small, immutable state.
+ *
+ * ```ts
+ * const { state, setState, history } = useUndoableState('');
+ * setState((prev) => prev + 'a', { label: 'Typing', coalesceKey: 'text' });
+ * useUndoShortcuts(history);
+ * ```
+ *
+ * `state` is a writable computed over the history's `present`, so travel is visible immediately and a `v-model`
+ * write records an entry. An updater is the only way to store a function-typed state.
+ */
+export declare function useUndoableState<TState>(initial: TState, options?: MaybeRefOrGetter<HistoryOptions | undefined>): UndoableState<TState>;

package/dist/foundation/history/hooks/UseUndoShortcuts.d.ts

@@ -0,0 +1,20 @@
+import { MaybeRefOrGetter } from 'vue';
+import { HotkeyOptions } from '../../shortcuts';
+import { UndoRedoTarget } from '../HistoryCore';
+/** Tunes {@link useUndoShortcuts}; every {@link HotkeyOptions} field (`enabled`, `target`, …) applies as usual. */
+export interface UndoShortcutOptions extends HotkeyOptions {
+    /** Chord(s) that trigger `undo()`. Defaults to `'mod+z'`. */
+    readonly undoChords?: MaybeRefOrGetter<string | ReadonlyArray<string>>;
+    /** Chord(s) that trigger `redo()`. Defaults to `['mod+shift+z', 'mod+y']`. */
+    readonly redoChords?: MaybeRefOrGetter<string | ReadonlyArray<string>>;
+}
+/**
+ * Binds the conventional undo / redo chords to a history. Opt-in — nothing is bound unless a surface calls this.
+ *
+ * ```ts
+ * const { history } = useUndoHistory();
+ * useUndoShortcuts(history);                            // ⌘Z · ⌘⇧Z · ⌘Y
+ * useUndoShortcuts(history, { enabled: () => !isModalOpen.value }); // suspended while a dialog owns the keyboard
+ * ```
+ */
+export declare function useUndoShortcuts(target: UndoRedoTarget, options?: UndoShortcutOptions): void;

package/dist/foundation/history/index.d.ts

@@ -0,0 +1,5 @@
+export { DefaultCoalesceMs, HistoryPhase, type HistoryErrorHandler, type HistoryListener, type HistoryOptions, type HistoryStore, type UndoRedoTarget, } from './HistoryCore';
+export { createUndoHistory, type UndoableAction, type UndoHistory } from './UndoHistory';
+export { createSnapshotHistory, type SnapshotHistory, type SnapshotRecordOptions } from './SnapshotHistory';
+export { useHistoryVersion, useUndoableState, useUndoHistory, type UndoHistoryControls, type UndoableState, type UndoableStateSetter, } from './hooks/UseUndoHistory';
+export { useUndoShortcuts, type UndoShortcutOptions } from './hooks/UseUndoShortcuts';