@kestack/web-platform 0.0.0-stage → 0.0.1

package/dist/input/gesture/recognizers/swipe/use-swipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-swipe.d.ts","names":["Rules","Direction"],"sources":["../../../../../src/input/gesture/recognizers/swipe/use-swipe.ts"],"mappings":";;;YAMY,aAAaA,QAAM;YACnB,OAAOA,QAAM;YACb,UAAUA,QAAM;YAChB,cAAcA,QAAM;YACpB,eAAeA,QAAM;YAQrB;;WAED;WACA,WAAWC;;WAEX,UAAU;;;;;;WAMV,OAAO;;WAEP,SAAS;;WAET;;WAEA,YAAY,SAAS;;WAErB,YAAY,QAAQ,aAAa,UAAU;;;;;;YAO1C;YAEA;;WAED,QAAQ;;WAER,UAAU;;WAEV,UAAU;;WAEV,YAAY;WACZ,OAAO;;;;;;;;;wBA+BF,SAAS,SAAS,eAAe"}

package/dist/input/gesture/recognizers/swipe/use-swipe.js

@@ -0,0 +1,150 @@
+import { useGesture } from "../../zones/zone/zone.js";
+import { useEffect, useLayoutEffect, useRef, useState } from "react";
+import { useMotionValue } from "motion/react";
+import { Swipe } from "@kestack/use-gesture";
+//#region src/input/gesture/recognizers/swipe/use-swipe.ts
+const down = (pointers) => [...pointers.values()].filter((pointer) => pointer.end === void 0).map((pointer) => ({
+	dx: pointer.dx.get(),
+	dy: pointer.dy.get()
+}));
+const TICK = 16;
+const useLatest = (value) => {
+	const ref = useRef(value);
+	useLayoutEffect(() => {
+		ref.current = value;
+	});
+	return ref;
+};
+/**
+* The Swipe Recognizer: fingers moving one way. It wants its own Direction,
+* or, with `from`, captures touches landing at that edge. It locks once the
+* touch's Direction is read, follows the fingers while Tracking, and
+* decides at the first finger lifting, so a two-finger Swipe is judged as
+* its fingers leave.
+*/
+function useSwipe(options) {
+	const latest = useLatest(options);
+	const offset = useMotionValue(0);
+	const progress = useMotionValue(0);
+	const velocity = useMotionValue(0);
+	const willCommit = useMotionValue(false);
+	const [state, setState] = useState("idle");
+	const run = useRef(void 0);
+	const rule = () => latest.current.commit ?? Swipe.DEFAULT_COMMIT;
+	const stop = (current) => {
+		current.phase = "done";
+		clearInterval(current.timer);
+		velocity.set(0);
+		willCommit.set(false);
+		setState("idle");
+	};
+	const cancel = (current, reason, at) => {
+		stop(current);
+		latest.current.onCancel?.(reason, at);
+	};
+	const measure = (current) => {
+		const speed = current.velocity.at(performance.now(), offset.get());
+		velocity.set(speed);
+		willCommit.set(Swipe.commits(rule(), offset.get(), speed));
+	};
+	const step = (current) => {
+		const { direction, fingers = 1 } = latest.current;
+		const live = down(current.pointers);
+		const move = Swipe.movement(live);
+		if (current.phase === "possible") {
+			if (!current.locked) return;
+			if (!Swipe.fingersMatch(fingers, live.length)) return cancel(current, "fingers");
+			current.phase = "tracking";
+			current.timer = setInterval(() => measure(current), TICK);
+			setState("tracking");
+			latest.current.onStart?.();
+		}
+		if (current.phase !== "tracking") return;
+		const value = Math.max(0, Swipe.along(direction, move));
+		const { distance } = rule();
+		offset.set(value);
+		progress.set(distance === void 0 ? 0 : value / distance);
+		current.velocity.add(performance.now(), value);
+		measure(current);
+	};
+	const end = (current) => {
+		for (const unsubscribe of current.unsubscribes) unsubscribe();
+		clearInterval(current.timer);
+		if (run.current === current) run.current = void 0;
+	};
+	useEffect(() => () => run.current && end(run.current), []);
+	useGesture({
+		enabled: options.enabled !== false,
+		directions: options.from === void 0 ? [options.direction] : [],
+		captures: (point) => {
+			const { from } = latest.current;
+			const viewport = {
+				width: innerWidth,
+				height: innerHeight
+			};
+			return from !== void 0 && Swipe.startsFrom(from, point, viewport);
+		},
+		onStart: (pointers) => {
+			const [first] = pointers.values();
+			const viewport = {
+				width: innerWidth,
+				height: innerHeight
+			};
+			if (first === void 0 || !Swipe.startsFrom(latest.current.from, first.start, viewport)) return;
+			offset.set(0);
+			progress.set(0);
+			run.current = {
+				phase: "possible",
+				locked: false,
+				pointers,
+				velocity: Swipe.createVelocity(),
+				unsubscribes: []
+			};
+			setState("possible");
+		},
+		onDirection: (way) => {
+			const current = run.current;
+			if (current === void 0 || current.phase !== "possible") return;
+			if (way !== latest.current.direction) return cancel(current, "direction");
+			current.locked = true;
+			step(current);
+		},
+		onPointer: (pointer, pointers) => {
+			const current = run.current;
+			if (current === void 0 || current.phase === "done") return;
+			if (pointer.end === void 0) {
+				current.pointers = pointers;
+				current.unsubscribes.push(pointer.dx.on("change", () => step(current)), pointer.dy.on("change", () => step(current)));
+				if (current.phase === "tracking") cancel(current, "fingers");
+				return;
+			}
+			if (current.phase !== "tracking") {
+				current.pointers = pointers;
+				return;
+			}
+			measure(current);
+			const at = Swipe.release(offset.get(), velocity.get());
+			if (willCommit.get()) {
+				stop(current);
+				latest.current.onCommit?.(at);
+			} else cancel(current, "short", at);
+		},
+		onEnd: (_pointers, { interrupted }) => {
+			const current = run.current;
+			if (current === void 0) return;
+			if (current.phase !== "done") cancel(current, interrupted ? "interrupted" : "short");
+			end(current);
+		}
+	});
+	return {
+		offset,
+		progress,
+		velocity,
+		willCommit,
+		state
+	};
+}
+//#endregion
+export { useSwipe };
+
+//# sourceMappingURL=use-swipe.js.map

package/dist/input/gesture/recognizers/swipe/use-swipe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-swipe.js","names":["Rules"],"sources":["../../../../../src/input/gesture/recognizers/swipe/use-swipe.ts"],"sourcesContent":["import { type MotionValue, useMotionValue } from 'motion/react';\nimport { useEffect, useLayoutEffect, useRef, useState } from 'react';\nimport { type Direction, Swipe as Rules } from '@kestack/use-gesture';\nimport { type Pointers, useGesture } from '../../zones/index.ts';\n\nexport type { Direction } from '@kestack/use-gesture';\nexport type CommitRule = Rules.CommitRule;\nexport type Edge = Rules.Edge;\nexport type Fingers = Rules.Fingers;\nexport type SwipeCancel = Rules.SwipeCancel;\nexport type SwipeRelease = Rules.SwipeRelease;\n\n// The fingers still down, each with how far it moved from where it landed.\nconst down = (pointers: Pointers) =>\n  [...pointers.values()]\n    .filter((pointer) => pointer.end === undefined)\n    .map((pointer) => ({ dx: pointer.dx.get(), dy: pointer.dy.get() }));\n\nexport type SwipeOptions = {\n  /** Whether it takes the next Gesture: true by default. Read as its first finger lands. */\n  readonly enabled?: boolean;\n  readonly direction: Direction;\n  /** How many fingers: 1 by default. */\n  readonly fingers?: Fingers;\n  /**\n   * Where the first finger must land; anywhere in the zone by default. A touch\n   * that lands there is the Swipe's even over an element that scrolls, and it\n   * takes no touch that lands anywhere else.\n   */\n  readonly from?: Edge;\n  /** What it needs at release to Commit: `{ distance: 80, velocity: 500 }` by default. */\n  readonly commit?: CommitRule;\n  /** The touch's Direction is `direction`, with the right fingers: it is Tracking. */\n  readonly onStart?: () => void;\n  /** It met its CommitRule as its first finger lifted. */\n  readonly onCommit?: (release: SwipeRelease) => void;\n  /** It gave up; `release` is set when that was at a finger lifting. */\n  readonly onCancel?: (reason: SwipeCancel, release?: SwipeRelease) => void;\n};\n\n/**\n * `possible` from the first finger landing where `from` asks until the\n * touch's Direction is read, then `tracking` until it Commits or Cancels.\n */\nexport type SwipeState = 'idle' | 'possible' | 'tracking';\n\nexport type Swipe = {\n  /** Px moved toward `direction`, never below 0. Reset as the next Gesture lands. */\n  readonly offset: MotionValue<number>;\n  /** `offset` over the CommitRule's `distance`, unclamped; 0 without a `distance`. */\n  readonly progress: MotionValue<number>;\n  /** Px/s toward `direction`, falling to 0 while the fingers rest. */\n  readonly velocity: MotionValue<number>;\n  /** Whether letting go now would Commit. */\n  readonly willCommit: MotionValue<boolean>;\n  readonly state: SwipeState;\n};\n\ntype Run = {\n  phase: 'possible' | 'tracking' | 'done';\n  // Whether the touch's Direction is the Swipe's own.\n  locked: boolean;\n  pointers: Pointers;\n  readonly velocity: ReturnType<typeof Rules.createVelocity>;\n  readonly unsubscribes: Array<() => void>;\n  timer?: ReturnType<typeof setInterval>;\n};\n\n// How often velocity is re-read while the fingers rest.\nconst TICK = 16;\n\nconst useLatest = <T>(value: T) => {\n  const ref = useRef(value);\n  useLayoutEffect(() => {\n    ref.current = value;\n  });\n  return ref;\n};\n\n/**\n * The Swipe Recognizer: fingers moving one way. It wants its own Direction,\n * or, with `from`, captures touches landing at that edge. It locks once the\n * touch's Direction is read, follows the fingers while Tracking, and\n * decides at the first finger lifting, so a two-finger Swipe is judged as\n * its fingers leave.\n */\nexport function useSwipe(options: SwipeOptions): Swipe {\n  const latest = useLatest(options);\n  const offset = useMotionValue(0);\n  const progress = useMotionValue(0);\n  const velocity = useMotionValue(0);\n  const willCommit = useMotionValue(false);\n  const [state, setState] = useState<SwipeState>('idle');\n  const run = useRef<Run | undefined>(undefined);\n\n  const rule = () => latest.current.commit ?? Rules.DEFAULT_COMMIT;\n\n  const stop = (current: Run) => {\n    current.phase = 'done';\n    clearInterval(current.timer);\n    velocity.set(0);\n    willCommit.set(false);\n    setState('idle');\n  };\n\n  const cancel = (current: Run, reason: SwipeCancel, at?: SwipeRelease) => {\n    stop(current);\n    latest.current.onCancel?.(reason, at);\n  };\n\n  // Velocity and what it means for a Commit, re-read on every move and tick.\n  const measure = (current: Run) => {\n    const speed = current.velocity.at(performance.now(), offset.get());\n    velocity.set(speed);\n    willCommit.set(Rules.commits(rule(), offset.get(), speed));\n  };\n\n  const step = (current: Run) => {\n    const { direction, fingers = 1 } = latest.current;\n    const live = down(current.pointers);\n    const move = Rules.movement(live);\n    if (current.phase === 'possible') {\n      if (!current.locked) return;\n      if (!Rules.fingersMatch(fingers, live.length)) {\n        return cancel(current, 'fingers');\n      }\n      current.phase = 'tracking';\n      current.timer = setInterval(() => measure(current), TICK);\n      setState('tracking');\n      latest.current.onStart?.();\n    }\n    if (current.phase !== 'tracking') return;\n    const value = Math.max(0, Rules.along(direction, move));\n    const { distance } = rule();\n    offset.set(value);\n    progress.set(distance === undefined ? 0 : value / distance);\n    current.velocity.add(performance.now(), value);\n    measure(current);\n  };\n\n  const end = (current: Run) => {\n    for (const unsubscribe of current.unsubscribes) unsubscribe();\n    clearInterval(current.timer);\n    if (run.current === current) run.current = undefined;\n  };\n\n  useEffect(() => () => run.current && end(run.current), []);\n\n  useGesture({\n    enabled: options.enabled !== false,\n    directions: options.from === undefined ? [options.direction] : [],\n    // A Swipe from an edge owns touches that start there, over any scroller.\n    captures: (point) => {\n      const { from } = latest.current;\n      const viewport = { width: innerWidth, height: innerHeight };\n      return from !== undefined && Rules.startsFrom(from, point, viewport);\n    },\n    onStart: (pointers) => {\n      const [first] = pointers.values();\n      const viewport = { width: innerWidth, height: innerHeight };\n      if (\n        first === undefined ||\n        !Rules.startsFrom(latest.current.from, first.start, viewport)\n      ) {\n        return;\n      }\n      offset.set(0);\n      progress.set(0);\n      run.current = {\n        phase: 'possible',\n        locked: false,\n        pointers,\n        velocity: Rules.createVelocity(),\n        unsubscribes: [],\n      };\n      setState('possible');\n    },\n    onDirection: (way) => {\n      const current = run.current;\n      if (current === undefined || current.phase !== 'possible') return;\n      if (way !== latest.current.direction) {\n        return cancel(current, 'direction');\n      }\n      current.locked = true;\n      step(current);\n    },\n    onPointer: (pointer, pointers) => {\n      const current = run.current;\n      if (current === undefined || current.phase === 'done') return;\n      if (pointer.end === undefined) {\n        // Followed once: a Gesture's first finger lands here too.\n        current.pointers = pointers;\n        current.unsubscribes.push(\n          pointer.dx.on('change', () => step(current)),\n          pointer.dy.on('change', () => step(current)),\n        );\n        if (current.phase === 'tracking') cancel(current, 'fingers');\n        return;\n      }\n      if (current.phase !== 'tracking') {\n        current.pointers = pointers;\n        return;\n      }\n      measure(current);\n      const at = Rules.release(offset.get(), velocity.get());\n      if (willCommit.get()) {\n        stop(current);\n        latest.current.onCommit?.(at);\n      } else {\n        cancel(current, 'short', at);\n      }\n    },\n    onEnd: (_pointers, { interrupted }) => {\n      const current = run.current;\n      if (current === undefined) return;\n      if (current.phase !== 'done') {\n        cancel(current, interrupted ? 'interrupted' : 'short');\n      }\n      end(current);\n    },\n  });\n\n  return { offset, progress, velocity, willCommit, state };\n}\n"],"mappings":"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"}

package/dist/input/gesture/zones/index.d.ts

@@ -0,0 +1,4 @@
+import { Pointer, Pointers } from "./zone/motion-pointers.js";
+import { Direction, Directions, GestureEnd, GestureOptions, GestureProvider, GestureState, GestureZone, GestureZoneProps, useGesture } from "./zone/zone.js";
+import "./zone/index.js";
+export { type Direction, type Directions, type GestureEnd, type GestureOptions, GestureProvider, type GestureState, GestureZone, type GestureZoneProps, type Pointer, type Pointers, useGesture };

package/dist/input/gesture/zones/index.js

@@ -0,0 +1,2 @@
+import { GestureProvider, GestureZone, useGesture } from "./zone/zone.js";
+export { GestureProvider, GestureZone, useGesture };

package/dist/input/gesture/zones/touch-input/index.d.ts

@@ -0,0 +1,3 @@
+import { ZONE_GESTURE_ATTRIBUTE, ZoneGesture } from "./native-scroll.js";
+import { DOM_ZONES, TRAPPED_ATTRIBUTE, Target, TouchInput, ZONE_SELECTOR, createTouchInput, zoneOf } from "./touch-input.js";
+export { DOM_ZONES, TRAPPED_ATTRIBUTE, type Target, type TouchInput, ZONE_GESTURE_ATTRIBUTE, ZONE_SELECTOR, type ZoneGesture, createTouchInput, zoneOf };

package/dist/input/gesture/zones/touch-input/index.js

@@ -0,0 +1,3 @@
+import { ZONE_GESTURE_ATTRIBUTE } from "./native-scroll.js";
+import { DOM_ZONES, TRAPPED_ATTRIBUTE, ZONE_SELECTOR, createTouchInput, zoneOf } from "./touch-input.js";
+export { DOM_ZONES, TRAPPED_ATTRIBUTE, ZONE_GESTURE_ATTRIBUTE, ZONE_SELECTOR, createTouchInput, zoneOf };

package/dist/input/gesture/zones/touch-input/native-scroll.d.ts

@@ -0,0 +1,28 @@
+//#region src/input/gesture/zones/touch-input/native-scroll.d.ts
+/**
+ * The attribute any element in the zone decides the zone's hold on touch
+ * with, for itself and what it holds; the nearest one decides. `enabled`:
+ * the zone captures every touch there, even over something that scrolls.
+ * `disabled`: the zone never takes a touch there. Without one, the zone
+ * captures a touch only when a listener takes it.
+ */
+export declare const ZONE_GESTURE_ATTRIBUTE = "data-zone-gesture";
+/** How the zone treats a touch that lands on an element. */
+export type ZoneGesture = 'enabled' | 'disabled' | 'auto';
+/**
+ * Whether `target` is in text being edited, which keeps its own touch
+ * handling: selecting and caret dragging. A field that isn't focused is
+ * like any other element: a swipe over it is a Gesture, and a tap still
+ * reaches it, to focus it.
+ */
+export declare const isTextEntry: (target: EventTarget | null) => boolean;
+/** How the zone treats a touch landing on `target`. */
+export declare const zoneGestureOf: (target: EventTarget | null) => ZoneGesture;
+/**
+ * Whether a Native Scroll keeps a finger that landed on `target` and first
+ * moved by dx, dy: some element from it up to `zone` can still scroll that
+ * way.
+ */
+export declare const nativeScrollKeeps: (target: EventTarget | null, zone: Element, dx: number, dy: number) => boolean;
+//#endregion
+//# sourceMappingURL=native-scroll.d.ts.map

package/dist/input/gesture/zones/touch-input/native-scroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-scroll.d.ts","names":[],"sources":["../../../../../src/input/gesture/zones/touch-input/native-scroll.ts"],"mappings":";;;;;;;;qBAOa;;YAGD;;;;;;;qBAUC,cAAW,QAAY;;qBAOvB,gBAAa,QAAY,uBAAqB;;;;;;qBA8B9C,oBAAiB,QACpB,oBAAkB,MACpB,SAAO,YACH"}

package/dist/input/gesture/zones/touch-input/native-scroll.js

@@ -0,0 +1,61 @@
+//#region src/input/gesture/zones/touch-input/native-scroll.ts
+/**
+* The attribute any element in the zone decides the zone's hold on touch
+* with, for itself and what it holds; the nearest one decides. `enabled`:
+* the zone captures every touch there, even over something that scrolls.
+* `disabled`: the zone never takes a touch there. Without one, the zone
+* captures a touch only when a listener takes it.
+*/
+const ZONE_GESTURE_ATTRIBUTE = "data-zone-gesture";
+const TEXT_ENTRY = "input, textarea, select, [contenteditable=\"true\"]";
+/**
+* Whether `target` is in text being edited, which keeps its own touch
+* handling: selecting and caret dragging. A field that isn't focused is
+* like any other element: a swipe over it is a Gesture, and a tap still
+* reaches it, to focus it.
+*/
+const isTextEntry = (target) => {
+	if (!(target instanceof Element)) return false;
+	const entry = target.closest(TEXT_ENTRY);
+	return entry !== null && entry.contains(entry.ownerDocument.activeElement);
+};
+/** How the zone treats a touch landing on `target`. */
+const zoneGestureOf = (target) => {
+	if (!(target instanceof Element) || isTextEntry(target)) return "disabled";
+	const value = target.closest(`[${ZONE_GESTURE_ATTRIBUTE}]`)?.getAttribute(ZONE_GESTURE_ATTRIBUTE);
+	return value === "enabled" || value === "disabled" ? value : "auto";
+};
+const SCROLLS = /* @__PURE__ */ new Set([
+	"auto",
+	"scroll",
+	"overlay"
+]);
+const followsFinger = (element, dx, dy) => {
+	const style = getComputedStyle(element);
+	if (Math.abs(dy) >= Math.abs(dx)) {
+		if (!SCROLLS.has(style.overflowY)) return false;
+		const end = element.scrollHeight - element.clientHeight;
+		return dy < 0 ? element.scrollTop < end - 1 : element.scrollTop > 0;
+	}
+	if (!SCROLLS.has(style.overflowX)) return false;
+	const end = element.scrollWidth - element.clientWidth;
+	const left = Math.abs(element.scrollLeft);
+	return dx < 0 ? left < end - 1 : left > 0;
+};
+/**
+* Whether a Native Scroll keeps a finger that landed on `target` and first
+* moved by dx, dy: some element from it up to `zone` can still scroll that
+* way.
+*/
+const nativeScrollKeeps = (target, zone, dx, dy) => {
+	if (dx === 0 && dy === 0) return false;
+	for (let element = target instanceof Element ? target : null; element !== null; element = element.parentElement) {
+		if (followsFinger(element, dx, dy)) return true;
+		if (element === zone) return false;
+	}
+	return false;
+};
+//#endregion
+export { ZONE_GESTURE_ATTRIBUTE, isTextEntry, nativeScrollKeeps, zoneGestureOf };
+
+//# sourceMappingURL=native-scroll.js.map

package/dist/input/gesture/zones/touch-input/native-scroll.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-scroll.js","names":[],"sources":["../../../../../src/input/gesture/zones/touch-input/native-scroll.ts"],"sourcesContent":["/**\n * The attribute any element in the zone decides the zone's hold on touch\n * with, for itself and what it holds; the nearest one decides. `enabled`:\n * the zone captures every touch there, even over something that scrolls.\n * `disabled`: the zone never takes a touch there. Without one, the zone\n * captures a touch only when a listener takes it.\n */\nexport const ZONE_GESTURE_ATTRIBUTE = 'data-zone-gesture';\n\n/** How the zone treats a touch that lands on an element. */\nexport type ZoneGesture = 'enabled' | 'disabled' | 'auto';\n\nconst TEXT_ENTRY = 'input, textarea, select, [contenteditable=\"true\"]';\n\n/**\n * Whether `target` is in text being edited, which keeps its own touch\n * handling: selecting and caret dragging. A field that isn't focused is\n * like any other element: a swipe over it is a Gesture, and a tap still\n * reaches it, to focus it.\n */\nexport const isTextEntry = (target: EventTarget | null) => {\n  if (!(target instanceof Element)) return false;\n  const entry = target.closest(TEXT_ENTRY);\n  return entry !== null && entry.contains(entry.ownerDocument.activeElement);\n};\n\n/** How the zone treats a touch landing on `target`. */\nexport const zoneGestureOf = (target: EventTarget | null): ZoneGesture => {\n  if (!(target instanceof Element) || isTextEntry(target)) return 'disabled';\n  const value = target\n    .closest(`[${ZONE_GESTURE_ATTRIBUTE}]`)\n    ?.getAttribute(ZONE_GESTURE_ATTRIBUTE);\n  return value === 'enabled' || value === 'disabled' ? value : 'auto';\n};\n\nconst SCROLLS = new Set(['auto', 'scroll', 'overlay']);\n\n// Whether `element` can still scroll to follow a finger moving by dx, dy\n// along its main direction. A finger moving up scrolls the content down.\nconst followsFinger = (element: Element, dx: number, dy: number) => {\n  const style = getComputedStyle(element);\n  if (Math.abs(dy) >= Math.abs(dx)) {\n    if (!SCROLLS.has(style.overflowY)) return false;\n    const end = element.scrollHeight - element.clientHeight;\n    return dy < 0 ? element.scrollTop < end - 1 : element.scrollTop > 0;\n  }\n  if (!SCROLLS.has(style.overflowX)) return false;\n  const end = element.scrollWidth - element.clientWidth;\n  const left = Math.abs(element.scrollLeft);\n  return dx < 0 ? left < end - 1 : left > 0;\n};\n\n/**\n * Whether a Native Scroll keeps a finger that landed on `target` and first\n * moved by dx, dy: some element from it up to `zone` can still scroll that\n * way.\n */\nexport const nativeScrollKeeps = (\n  target: EventTarget | null,\n  zone: Element,\n  dx: number,\n  dy: number,\n) => {\n  if (dx === 0 && dy === 0) return false;\n  for (\n    let element = target instanceof Element ? target : null;\n    element !== null;\n    element = element.parentElement\n  ) {\n    if (followsFinger(element, dx, dy)) return true;\n    if (element === zone) return false;\n  }\n  return false;\n};\n"],"mappings":";;;;;;;;AAOA,MAAa,yBAAyB;AAKtC,MAAM,aAAa;;;;;;;AAQnB,MAAa,eAAe,WAA+B;CACzD,IAAI,EAAE,kBAAkB,UAAU,OAAO;CACzC,MAAM,QAAQ,OAAO,QAAQ,UAAU;CACvC,OAAO,UAAU,QAAQ,MAAM,SAAS,MAAM,cAAc,aAAa;AAC3E;;AAGA,MAAa,iBAAiB,WAA4C;CACxE,IAAI,EAAE,kBAAkB,YAAY,YAAY,MAAM,GAAG,OAAO;CAChE,MAAM,QAAQ,OACX,QAAQ,IAAI,uBAAuB,EAAE,CAAC,EACrC,aAAa,sBAAsB;CACvC,OAAO,UAAU,aAAa,UAAU,aAAa,QAAQ;AAC/D;AAEA,MAAM,0BAAU,IAAI,IAAI;CAAC;CAAQ;CAAU;AAAS,CAAC;AAIrD,MAAM,iBAAiB,SAAkB,IAAY,OAAe;CAClE,MAAM,QAAQ,iBAAiB,OAAO;CACtC,IAAI,KAAK,IAAI,EAAE,KAAK,KAAK,IAAI,EAAE,GAAG;EAChC,IAAI,CAAC,QAAQ,IAAI,MAAM,SAAS,GAAG,OAAO;EAC1C,MAAM,MAAM,QAAQ,eAAe,QAAQ;EAC3C,OAAO,KAAK,IAAI,QAAQ,YAAY,MAAM,IAAI,QAAQ,YAAY;CACpE;CACA,IAAI,CAAC,QAAQ,IAAI,MAAM,SAAS,GAAG,OAAO;CAC1C,MAAM,MAAM,QAAQ,cAAc,QAAQ;CAC1C,MAAM,OAAO,KAAK,IAAI,QAAQ,UAAU;CACxC,OAAO,KAAK,IAAI,OAAO,MAAM,IAAI,OAAO;AAC1C;;;;;;AAOA,MAAa,qBACX,QACA,MACA,IACA,OACG;CACH,IAAI,OAAO,KAAK,OAAO,GAAG,OAAO;CACjC,KACE,IAAI,UAAU,kBAAkB,UAAU,SAAS,MACnD,YAAY,MACZ,UAAU,QAAQ,eAClB;EACA,IAAI,cAAc,SAAS,IAAI,EAAE,GAAG,OAAO;EAC3C,IAAI,YAAY,MAAM,OAAO;CAC/B;CACA,OAAO;AACT"}

package/dist/input/gesture/zones/touch-input/touch-input.d.ts

@@ -0,0 +1,54 @@
+import { PointerSink, ZoneTree } from "@kestack/use-gesture";
+//#region src/input/gesture/zones/touch-input/touch-input.d.ts
+/** How a Gesture Zone's element is marked. */
+export declare const ZONE_SELECTOR = "[data-slot=\"gesture-zone\"]";
+/** Set on a trapped zone: Gestures that start in it go no further up. */
+export declare const TRAPPED_ATTRIBUTE = "data-trapped";
+/** The innermost Gesture Zone around `target`, if any. */
+export declare const zoneOf: (target: EventTarget | null | undefined) => Element | null;
+/** A finger on the page: what it landed on is an element, if anything. */
+export type Target = Element | null;
+/**
+ * How Gesture Zones nest in the page: each is an element marked
+ * ZONE_SELECTOR, inside the zone around it, Trapped while it has
+ * TRAPPED_ATTRIBUTE.
+ */
+export declare const DOM_ZONES: ZoneTree<Element, Target>;
+/**
+ * How far from a side edge, in px, a touch in a zone is kept from the
+ * browser's own edge swipe: back and forward on iOS, in Safari and installed.
+ */
+export declare const EDGE_GUARD_PX = 24;
+/**
+ * Whether a touch landing at `x` on `target` must be kept from the browser's
+ * edge swipe: it lands in a zone, within EDGE_GUARD_PX of a side edge, on
+ * nothing that is turned off for the zone or must still click.
+ */
+export declare const guardsEdge: (target: EventTarget | null, x: number, width: number) => boolean;
+/**
+ * Feeds every touch and pen pointer on the page to `sink`, for one Gesture
+ * Provider; the mouse is left to the browser. It listens on the window in
+ * the capture phase, so nothing inside a zone can hide a finger from it. Fingers where the zone is disabled, and in text
+ * entry, are left alone. Moves and releases of tracked pointers follow
+ * them anywhere. The browser taking a touch, such as for a Native Scroll or
+ * the system back gesture, or the page going away mid-touch, cancels every
+ * pointer.
+ *
+ * Holding the browser back has to happen on each zone's own element, since
+ * a blocking touch listener on the whole page would make every scroll wait:
+ * `bindZone` adds it. A touch's first movement reads its Direction and
+ * decides who owns it: the zone when a listener takes it, or when two
+ * fingers are down; otherwise the browser, which scrolls, while the Gesture
+ * is cancelled and nothing is tracked until every finger lifts.
+ */
+export declare const createTouchInput: (win: Window, sink: PointerSink<Target>) => {
+  /** Starts listening to the page. */
+  start: () => void;
+  /** Stops listening, cancelling any Gesture under way. */
+  stop: () => void;
+  /** Holds the browser back from a zone's element; returns the unbind. */
+  bindZone: (element: Element) => () => void;
+};
+export type TouchInput = ReturnType<typeof createTouchInput>;
+//#endregion
+//# sourceMappingURL=touch-input.d.ts.map

package/dist/input/gesture/zones/touch-input/touch-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"touch-input.d.ts","names":[],"sources":["../../../../../src/input/gesture/zones/touch-input/touch-input.ts"],"mappings":";;;qBAaa;;qBAGA;;qBAGA,SAAM,QAAY,mCAA8B;;YAIjD,SAAS;;;;;;qBAOR,WAAW,SAAS,SAAS;;;;;qBAY7B;;;;;;qBAWA,aAAU,QACb,oBAAkB,WACjB;;;;;;;;;;;;;;;;;qBAsEE,mBAAgB,KAAS,QAAM,MAAQ,YAAY;;EAqJ5D;;EAoBA;;EAcA,WAAQ,SAAY;;YAaZ,aAAa,kBAAkB"}

package/dist/input/gesture/zones/touch-input/touch-input.js

@@ -0,0 +1,243 @@
+import { isTextEntry, nativeScrollKeeps, zoneGestureOf } from "./native-scroll.js";
+import { directionOf } from "@kestack/use-gesture";
+//#region src/input/gesture/zones/touch-input/touch-input.ts
+/** How a Gesture Zone's element is marked. */
+const ZONE_SELECTOR = "[data-slot=\"gesture-zone\"]";
+/** Set on a trapped zone: Gestures that start in it go no further up. */
+const TRAPPED_ATTRIBUTE = "data-trapped";
+/** The innermost Gesture Zone around `target`, if any. */
+const zoneOf = (target) => target instanceof Element ? target.closest(ZONE_SELECTOR) : null;
+/**
+* How Gesture Zones nest in the page: each is an element marked
+* ZONE_SELECTOR, inside the zone around it, Trapped while it has
+* TRAPPED_ATTRIBUTE.
+*/
+const DOM_ZONES = {
+	zoneOf,
+	parentOf: (zone) => zoneOf(zone.parentElement),
+	trapped: (zone) => zone.hasAttribute(TRAPPED_ATTRIBUTE)
+};
+const STYLE_ID = "kui-gesture-zone";
+/**
+* How far from a side edge, in px, a touch in a zone is kept from the
+* browser's own edge swipe: back and forward on iOS, in Safari and installed.
+*/
+const EDGE_GUARD_PX = 24;
+const INTERACTIVE = "a[href], button, input, select, textarea, label, summary, [role=\"button\"], [role=\"link\"], [tabindex]:not([tabindex=\"-1\"])";
+/**
+* Whether a touch landing at `x` on `target` must be kept from the browser's
+* edge swipe: it lands in a zone, within EDGE_GUARD_PX of a side edge, on
+* nothing that is turned off for the zone or must still click.
+*/
+const guardsEdge = (target, x, width) => (x <= 24 || x >= width - 24) && zoneOf(target) !== null && zoneGestureOf(target) !== "disabled" && !(target instanceof Element && target.closest(INTERACTIVE) !== null);
+const RULES = `${ZONE_SELECTOR} { touch-action: pan-x pan-y; }`;
+const installStyle = (doc) => {
+	if (doc.getElementById(STYLE_ID) !== null) return;
+	const style = doc.createElement("style");
+	style.id = STYLE_ID;
+	style.textContent = RULES;
+	doc.head.appendChild(style);
+};
+const sampleOf = (event) => ({
+	id: event.pointerId,
+	x: event.clientX,
+	y: event.clientY,
+	t: event.timeStamp,
+	target: event.target instanceof Element ? event.target : null
+});
+const CLICK_WAIT_MS = 600;
+/**
+* A release over a link or button that must not also click it. The click
+* arrives later than the release, so it is swallowed until it comes, the
+* next finger lands, or CLICK_WAIT_MS passes.
+*/
+const swallowNextClick = (win) => {
+	const stop = () => {
+		win.removeEventListener("click", swallow, { capture: true });
+		win.removeEventListener("pointerdown", stop, { capture: true });
+		win.clearTimeout(timer);
+	};
+	const swallow = (event) => {
+		event.preventDefault();
+		event.stopPropagation();
+		stop();
+	};
+	win.addEventListener("click", swallow, { capture: true });
+	win.addEventListener("pointerdown", stop, { capture: true });
+	const timer = win.setTimeout(stop, CLICK_WAIT_MS);
+};
+/**
+* Feeds every touch and pen pointer on the page to `sink`, for one Gesture
+* Provider; the mouse is left to the browser. It listens on the window in
+* the capture phase, so nothing inside a zone can hide a finger from it. Fingers where the zone is disabled, and in text
+* entry, are left alone. Moves and releases of tracked pointers follow
+* them anywhere. The browser taking a touch, such as for a Native Scroll or
+* the system back gesture, or the page going away mid-touch, cancels every
+* pointer.
+*
+* Holding the browser back has to happen on each zone's own element, since
+* a blocking touch listener on the whole page would make every scroll wait:
+* `bindZone` adds it. A touch's first movement reads its Direction and
+* decides who owns it: the zone when a listener takes it, or when two
+* fingers are down; otherwise the browser, which scrolls, while the Gesture
+* is cancelled and nothing is tracked until every finger lifts.
+*/
+const createTouchInput = (win, sink) => {
+	const doc = win.document;
+	const tracked = /* @__PURE__ */ new Map();
+	const untrack = (id) => {
+		const pointer = tracked.get(id);
+		if (pointer === void 0) return false;
+		pointer.unwatch();
+		tracked.delete(id);
+		return true;
+	};
+	const landed = /* @__PURE__ */ new Map();
+	let owner = "undecided";
+	let swallowing = false;
+	const onDown = (event) => {
+		if (event.pointerType === "mouse") return;
+		if (owner === "browser" || zoneGestureOf(event.target) === "disabled") return;
+		if (!sink.down(sampleOf(event))) return;
+		const target = event.target;
+		target?.addEventListener("pointerup", onUp);
+		target?.addEventListener("pointercancel", onCancel);
+		tracked.set(event.pointerId, {
+			touch: event.pointerType === "touch",
+			unwatch: () => {
+				target?.removeEventListener("pointerup", onUp);
+				target?.removeEventListener("pointercancel", onCancel);
+			}
+		});
+	};
+	const onMove = (event) => {
+		if (!tracked.has(event.pointerId)) return;
+		const undecided = owner === "undecided" && landed.size > 0;
+		sink.move({
+			...sampleOf(event),
+			undecided
+		});
+	};
+	const onUp = (event) => {
+		if (!untrack(event.pointerId)) return;
+		if (!sink.up(sampleOf(event))) return;
+		swallowNextClick(win);
+		swallowing = true;
+	};
+	const onCancel = (event) => {
+		if (tracked.has(event.pointerId)) onAway();
+	};
+	const onAway = () => {
+		for (const id of Array.from(tracked.keys())) untrack(id);
+		sink.cancelAll(performance.now());
+	};
+	const onVisibility = () => {
+		if (doc.visibilityState === "hidden") onAway();
+	};
+	const onContextMenu = (event) => {
+		if (event.pointerType !== "mouse" && zoneOf(event.target) !== null && !isTextEntry(event.target)) event.preventDefault();
+	};
+	const onTouchStart = (event) => {
+		swallowing = false;
+		const fingers = [...tracked.values()].filter((pointer) => pointer.touch);
+		if (event.touches.length < fingers.length) onAway();
+		for (const touch of event.changedTouches) {
+			landed.set(touch.identifier, {
+				x: touch.clientX,
+				y: touch.clientY
+			});
+			const { clientX: x, clientY: y } = touch;
+			if (event.cancelable && guardsEdge(touch.target, x, win.innerWidth) && sink.claimsEdge({
+				x,
+				y
+			}, x <= 24 ? "right" : "left")) event.preventDefault();
+		}
+	};
+	const decide = (event) => {
+		const touches = [...event.touches];
+		const [touch] = touches;
+		const start = touch && landed.get(touch.identifier);
+		const dx = touch && start ? touch.clientX - start.x : 0;
+		const dy = touch && start ? touch.clientY - start.y : 0;
+		const direction = sink.direction() ?? directionOf(dx, dy);
+		const how = sink.pick(direction);
+		const owner = (() => {
+			if (touches.length !== 1 || touch === void 0) return "zone";
+			const zone = zoneOf(touch.target);
+			if (zone === null) return "zone";
+			if (zoneGestureOf(touch.target) === "enabled") return "zone";
+			if (how === "captures") return "zone";
+			if (nativeScrollKeeps(touch.target, zone, dx, dy)) return "browser";
+			return how === "directions" ? "zone" : "browser";
+		})();
+		if (owner === "zone") sink.settle(direction);
+		return owner;
+	};
+	const onTouchMove = (event) => {
+		if (!sink.active()) return;
+		if (owner === "undecided") {
+			owner = decide(event);
+			if (owner === "browser") onAway();
+		}
+		if (owner === "zone" && event.cancelable) event.preventDefault();
+	};
+	const onTouchEnd = (event) => {
+		if (swallowing && event.type === "touchend" && event.cancelable) event.preventDefault();
+		swallowing = false;
+		for (const touch of event.changedTouches) landed.delete(touch.identifier);
+		if (event.touches.length === 0) {
+			landed.clear();
+			owner = "undecided";
+		}
+	};
+	const onSafariGesture = (event) => event.preventDefault();
+	return {
+		/** Starts listening to the page. */
+		start: () => {
+			installStyle(doc);
+			win.addEventListener("pointerdown", onDown, { capture: true });
+			win.addEventListener("pointermove", onMove, { capture: true });
+			win.addEventListener("pointerup", onUp, { capture: true });
+			win.addEventListener("pointercancel", onCancel, { capture: true });
+			win.addEventListener("contextmenu", onContextMenu, { capture: true });
+			win.addEventListener("touchstart", onTouchStart, {
+				capture: true,
+				passive: false
+			});
+			win.addEventListener("touchend", onTouchEnd, {
+				capture: true,
+				passive: false
+			});
+			win.addEventListener("touchcancel", onTouchEnd, { capture: true });
+			win.addEventListener("blur", onAway);
+			doc.addEventListener("visibilitychange", onVisibility);
+		},
+		/** Stops listening, cancelling any Gesture under way. */
+		stop: () => {
+			win.removeEventListener("pointerdown", onDown, { capture: true });
+			win.removeEventListener("pointermove", onMove, { capture: true });
+			win.removeEventListener("pointerup", onUp, { capture: true });
+			win.removeEventListener("pointercancel", onCancel, { capture: true });
+			win.removeEventListener("contextmenu", onContextMenu, { capture: true });
+			win.removeEventListener("touchstart", onTouchStart, { capture: true });
+			win.removeEventListener("touchend", onTouchEnd, { capture: true });
+			win.removeEventListener("touchcancel", onTouchEnd, { capture: true });
+			win.removeEventListener("blur", onAway);
+			doc.removeEventListener("visibilitychange", onVisibility);
+			onAway();
+		},
+		/** Holds the browser back from a zone's element; returns the unbind. */
+		bindZone: (element) => {
+			element.addEventListener("touchmove", onTouchMove, { passive: false });
+			element.addEventListener("gesturestart", onSafariGesture);
+			return () => {
+				element.removeEventListener("touchmove", onTouchMove);
+				element.removeEventListener("gesturestart", onSafariGesture);
+			};
+		}
+	};
+};
+//#endregion
+export { DOM_ZONES, EDGE_GUARD_PX, TRAPPED_ATTRIBUTE, ZONE_SELECTOR, createTouchInput, guardsEdge, zoneOf };
+
+//# sourceMappingURL=touch-input.js.map

package/dist/input/gesture/zones/touch-input/touch-input.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"touch-input.js","names":[],"sources":["../../../../../src/input/gesture/zones/touch-input/touch-input.ts"],"sourcesContent":["import {\n  directionOf,\n  type PointerSample,\n  type PointerSink,\n  type ZoneTree,\n} from '@kestack/use-gesture';\nimport {\n  isTextEntry,\n  nativeScrollKeeps,\n  zoneGestureOf,\n} from './native-scroll.ts';\n\n/** How a Gesture Zone's element is marked. */\nexport const ZONE_SELECTOR = '[data-slot=\"gesture-zone\"]';\n\n/** Set on a trapped zone: Gestures that start in it go no further up. */\nexport const TRAPPED_ATTRIBUTE = 'data-trapped';\n\n/** The innermost Gesture Zone around `target`, if any. */\nexport const zoneOf = (target: EventTarget | null | undefined) =>\n  target instanceof Element ? target.closest(ZONE_SELECTOR) : null;\n\n/** A finger on the page: what it landed on is an element, if anything. */\nexport type Target = Element | null;\n\n/**\n * How Gesture Zones nest in the page: each is an element marked\n * ZONE_SELECTOR, inside the zone around it, Trapped while it has\n * TRAPPED_ATTRIBUTE.\n */\nexport const DOM_ZONES: ZoneTree<Element, Target> = {\n  zoneOf,\n  parentOf: (zone) => zoneOf(zone.parentElement),\n  trapped: (zone) => zone.hasAttribute(TRAPPED_ATTRIBUTE),\n};\n\nconst STYLE_ID = 'kui-gesture-zone';\n\n/**\n * How far from a side edge, in px, a touch in a zone is kept from the\n * browser's own edge swipe: back and forward on iOS, in Safari and installed.\n */\nexport const EDGE_GUARD_PX = 24;\n\n// Taps on these must still click, so their touches are left to the browser.\nconst INTERACTIVE =\n  'a[href], button, input, select, textarea, label, summary, [role=\"button\"], [role=\"link\"], [tabindex]:not([tabindex=\"-1\"])';\n\n/**\n * Whether a touch landing at `x` on `target` must be kept from the browser's\n * edge swipe: it lands in a zone, within EDGE_GUARD_PX of a side edge, on\n * nothing that is turned off for the zone or must still click.\n */\nexport const guardsEdge = (\n  target: EventTarget | null,\n  x: number,\n  width: number,\n) =>\n  (x <= EDGE_GUARD_PX || x >= width - EDGE_GUARD_PX) &&\n  zoneOf(target) !== null &&\n  zoneGestureOf(target) !== 'disabled' &&\n  !(target instanceof Element && target.closest(INTERACTIVE) !== null);\n\n// The browser decides what a touch may do as the finger lands. A zone lets\n// it pan, so the browser can scroll whatever the zone does not take at the\n// first movement. Nothing in a zone zooms the page.\nconst RULES = `${ZONE_SELECTOR} { touch-action: pan-x pan-y; }`;\n\nconst installStyle = (doc: Document) => {\n  if (doc.getElementById(STYLE_ID) !== null) return;\n  const style = doc.createElement('style');\n  style.id = STYLE_ID;\n  style.textContent = RULES;\n  doc.head.appendChild(style);\n};\n\nconst sampleOf = (event: PointerEvent): PointerSample<Target> => ({\n  id: event.pointerId,\n  x: event.clientX,\n  y: event.clientY,\n  t: event.timeStamp,\n  target: event.target instanceof Element ? event.target : null,\n});\n\n// How long a swallowed release waits for its click. Mobile browsers send\n// it a moment after the finger lifts, sometimes after other tasks.\nconst CLICK_WAIT_MS = 600;\n\n/**\n * A release over a link or button that must not also click it. The click\n * arrives later than the release, so it is swallowed until it comes, the\n * next finger lands, or CLICK_WAIT_MS passes.\n */\nconst swallowNextClick = (win: Window) => {\n  const stop = () => {\n    win.removeEventListener('click', swallow, { capture: true });\n    win.removeEventListener('pointerdown', stop, { capture: true });\n    win.clearTimeout(timer);\n  };\n  const swallow = (event: Event) => {\n    event.preventDefault();\n    event.stopPropagation();\n    stop();\n  };\n  win.addEventListener('click', swallow, { capture: true });\n  win.addEventListener('pointerdown', stop, { capture: true });\n  const timer = win.setTimeout(stop, CLICK_WAIT_MS);\n};\n\n/**\n * Feeds every touch and pen pointer on the page to `sink`, for one Gesture\n * Provider; the mouse is left to the browser. It listens on the window in\n * the capture phase, so nothing inside a zone can hide a finger from it. Fingers where the zone is disabled, and in text\n * entry, are left alone. Moves and releases of tracked pointers follow\n * them anywhere. The browser taking a touch, such as for a Native Scroll or\n * the system back gesture, or the page going away mid-touch, cancels every\n * pointer.\n *\n * Holding the browser back has to happen on each zone's own element, since\n * a blocking touch listener on the whole page would make every scroll wait:\n * `bindZone` adds it. A touch's first movement reads its Direction and\n * decides who owns it: the zone when a listener takes it, or when two\n * fingers are down; otherwise the browser, which scrolls, while the Gesture\n * is cancelled and nothing is tracked until every finger lifts.\n */\nexport const createTouchInput = (win: Window, sink: PointerSink<Target>) => {\n  const doc = win.document;\n  // Each tracked pointer, with whether it is a finger and how to stop\n  // listening on the element it landed on.\n  const tracked = new Map<number, { touch: boolean; unwatch: () => void }>();\n  const untrack = (id: number) => {\n    const pointer = tracked.get(id);\n    if (pointer === undefined) return false;\n    pointer.unwatch();\n    tracked.delete(id);\n    return true;\n  };\n  // Where each finger on the screen landed, until the touch is decided.\n  const landed = new Map<number, { x: number; y: number }>();\n  // Who the fingers on the screen belong to, decided at their first movement.\n  let owner: 'undecided' | 'zone' | 'browser' = 'undecided';\n  // A finger's release must not click: cancel the touch's end too, which\n  // stops the browser's click and mouse events for it altogether.\n  let swallowing = false;\n\n  const onDown = (event: PointerEvent) => {\n    // A Gesture is touch or pen: a mouse drag selects text and never\n    // scrolls, so the browser keeps it.\n    if (event.pointerType === 'mouse') return;\n    if (owner === 'browser' || zoneGestureOf(event.target) === 'disabled') {\n      return;\n    }\n    if (!sink.down(sampleOf(event))) return;\n    // iOS sends a finger's release to the element it landed on, even after\n    // that element has left the page, and from there it never reaches the\n    // window. Listening on the element itself still hears it.\n    const target = event.target;\n    target?.addEventListener('pointerup', onUp as EventListener);\n    target?.addEventListener('pointercancel', onCancel as EventListener);\n    tracked.set(event.pointerId, {\n      touch: event.pointerType === 'touch',\n      unwatch: () => {\n        target?.removeEventListener('pointerup', onUp as EventListener);\n        target?.removeEventListener('pointercancel', onCancel as EventListener);\n      },\n    });\n  };\n  const onMove = (event: PointerEvent) => {\n    if (!tracked.has(event.pointerId)) return;\n    // The browser sends a finger's pointermove before its touchmove: until\n    // that decides, the move only moves.\n    const undecided = owner === 'undecided' && landed.size > 0;\n    sink.move({ ...sampleOf(event), undecided });\n  };\n  const onUp = (event: PointerEvent) => {\n    if (!untrack(event.pointerId)) return;\n    if (!sink.up(sampleOf(event))) return;\n    swallowNextClick(win);\n    swallowing = true;\n  };\n  const onCancel = (event: PointerEvent) => {\n    if (tracked.has(event.pointerId)) onAway();\n  };\n  const onAway = () => {\n    // A copy of the ids, as `untrack` deletes from `tracked`.\n    for (const id of Array.from(tracked.keys())) untrack(id);\n    // Pointer events stamp their time on this clock.\n    sink.cancelAll(performance.now());\n  };\n  const onVisibility = () => {\n    if (doc.visibilityState === 'hidden') onAway();\n  };\n  // A long press opens the callout menu on touch; the app owns touch in a zone.\n  const onContextMenu = (event: Event) => {\n    const pointerType = (event as Partial<PointerEvent>).pointerType;\n    if (\n      pointerType !== 'mouse' &&\n      zoneOf(event.target) !== null &&\n      !isTextEntry(event.target)\n    ) {\n      event.preventDefault();\n    }\n  };\n\n  const onTouchStart = (event: TouchEvent) => {\n    // A swallow meant for a touch whose end came first must not reach this one.\n    swallowing = false;\n    // More fingers tracked than are on the screen: a release went unheard,\n    // so the Gesture under way is stale. End it rather than let the next\n    // touch join it.\n    const fingers = [...tracked.values()].filter((pointer) => pointer.touch);\n    if (event.touches.length < fingers.length) onAway();\n    for (const touch of event.changedTouches) {\n      landed.set(touch.identifier, { x: touch.clientX, y: touch.clientY });\n      // iOS starts its back and forward swipe from here, before any touchmove\n      // the zone could hold back; only a touchstart kept from it stops that.\n      const { clientX: x, clientY: y } = touch;\n      if (\n        event.cancelable &&\n        guardsEdge(touch.target, x, win.innerWidth) &&\n        sink.claimsEdge({ x, y }, x <= EDGE_GUARD_PX ? 'right' : 'left')\n      ) {\n        event.preventDefault();\n      }\n    }\n  };\n  // Who owns a touch, from its first movement; first match wins.\n  const decide = (event: TouchEvent) => {\n    const touches = [...event.touches];\n    const [touch] = touches;\n    const start = touch && landed.get(touch.identifier);\n    const dx = touch && start ? touch.clientX - start.x : 0;\n    const dy = touch && start ? touch.clientY - start.y : 0;\n    const direction = sink.direction() ?? directionOf(dx, dy);\n    const how = sink.pick(direction);\n    const owner = ((): 'zone' | 'browser' => {\n      if (touches.length !== 1 || touch === undefined) return 'zone';\n      const zone = zoneOf(touch.target);\n      if (zone === null) return 'zone';\n      if (zoneGestureOf(touch.target) === 'enabled') return 'zone';\n      if (how === 'captures') return 'zone';\n      if (nativeScrollKeeps(touch.target, zone, dx, dy)) return 'browser';\n      return how === 'directions' ? 'zone' : 'browser';\n    })();\n    // Only a touch the zone keeps has a Direction for its listeners: one the\n    // browser scrolls must not start them moving before it cancels them.\n    if (owner === 'zone') sink.settle(direction);\n    return owner;\n  };\n  // From each zone's element: keeps a Gesture's touch from the browser.\n  const onTouchMove = (event: TouchEvent) => {\n    if (!sink.active()) return;\n    if (owner === 'undecided') {\n      owner = decide(event);\n      if (owner === 'browser') onAway();\n    }\n    if (owner === 'zone' && event.cancelable) event.preventDefault();\n  };\n  const onTouchEnd = (event: TouchEvent) => {\n    if (swallowing && event.type === 'touchend' && event.cancelable) {\n      event.preventDefault();\n    }\n    swallowing = false;\n    for (const touch of event.changedTouches) landed.delete(touch.identifier);\n    if (event.touches.length === 0) {\n      landed.clear();\n      owner = 'undecided';\n    }\n  };\n  // iOS Safari pinch-zooms the page from its own gesture events.\n  const onSafariGesture = (event: Event) => event.preventDefault();\n\n  return {\n    /** Starts listening to the page. */\n    start: () => {\n      installStyle(doc);\n      win.addEventListener('pointerdown', onDown, { capture: true });\n      win.addEventListener('pointermove', onMove, { capture: true });\n      win.addEventListener('pointerup', onUp, { capture: true });\n      win.addEventListener('pointercancel', onCancel, { capture: true });\n      win.addEventListener('contextmenu', onContextMenu, { capture: true });\n      win.addEventListener('touchstart', onTouchStart, {\n        capture: true,\n        passive: false,\n      });\n      win.addEventListener('touchend', onTouchEnd, {\n        capture: true,\n        passive: false,\n      });\n      win.addEventListener('touchcancel', onTouchEnd, { capture: true });\n      win.addEventListener('blur', onAway);\n      doc.addEventListener('visibilitychange', onVisibility);\n    },\n    /** Stops listening, cancelling any Gesture under way. */\n    stop: () => {\n      win.removeEventListener('pointerdown', onDown, { capture: true });\n      win.removeEventListener('pointermove', onMove, { capture: true });\n      win.removeEventListener('pointerup', onUp, { capture: true });\n      win.removeEventListener('pointercancel', onCancel, { capture: true });\n      win.removeEventListener('contextmenu', onContextMenu, { capture: true });\n      win.removeEventListener('touchstart', onTouchStart, { capture: true });\n      win.removeEventListener('touchend', onTouchEnd, { capture: true });\n      win.removeEventListener('touchcancel', onTouchEnd, { capture: true });\n      win.removeEventListener('blur', onAway);\n      doc.removeEventListener('visibilitychange', onVisibility);\n      onAway();\n    },\n    /** Holds the browser back from a zone's element; returns the unbind. */\n    bindZone: (element: Element) => {\n      element.addEventListener('touchmove', onTouchMove as EventListener, {\n        passive: false,\n      });\n      element.addEventListener('gesturestart', onSafariGesture);\n      return () => {\n        element.removeEventListener('touchmove', onTouchMove as EventListener);\n        element.removeEventListener('gesturestart', onSafariGesture);\n      };\n    },\n  };\n};\n\nexport type TouchInput = ReturnType<typeof createTouchInput>;\n"],"mappings":"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"}