@weasel-js/gestures 1.10.1 → 1.11.1

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { MenuShortcut } from '@weasel-js/menu';
+
 /**
  * Declarative gesture taxonomy. Single source of truth for:
  *   - which gestures hit-test (have a `.target` slot in the route string)
@@ -7,7 +9,7 @@
  * Reflection, matcher, and inspector UI all read this table. Adding a new
  * gesture name in one place updates every consumer.
  */
-type GestureName = 'click' | 'pointerDown' | 'hover' | 'dblTap' | 'drag' | 'wheel' | 'pinch' | 'keyDown' | 'keyUp' | 'keyHeld' | 'contextMenu' | 'longPress' | 'multiTouch' | 'multiTouchTap' | 'drop' | 'paste';
+type GestureName = 'click' | 'pointerDown' | 'hover' | 'dblTap' | 'drag' | 'wheel' | 'pinch' | 'keyDown' | 'keyUp' | 'keyHeld' | 'contextMenu' | 'longPress' | 'multiTouch' | 'multiTouchTap' | 'drop' | 'carry' | 'paste';
 /**
  * Gesture kinds an affordance claim can bar, in the spec vocabulary bindings
  * are written in. `'pointer'` is one token because `pointerDown` / `click` /
@@ -79,10 +81,13 @@ type RoutePhase = 'initial' | 'engaged';
  *   argSlot     = '(' argValue ')'                     -- whitespace inside parens is significant
  *   targetSlot  = '=>' WS targetValue                  -- omitted slot defaults to '*' for hasTarget
  *   modSlot     = modAtom (WS modAtom)*
- *   modAtom     = sigil modName
+ *   modAtom     = sigil (modName | 'held')
  *   sigil       = '+' | '?'                            -- ! @ # $ % ^ & * reserved as id-prefix
  *   modName     = 'mod' | 'shift' | 'alt' | 'ctrl' | 'meta'
  *
+ * `held` is a pressed button, read as a modifier is: `?held` a button may be
+ * held, `+held` one must be, absent none may. Only `hover` takes it.
+ *
  * The truly-loose form (any channel, any phase) is `[*:*]`.
  *
  * Examples:
@@ -150,6 +155,9 @@ interface ParsedRoute {
     target: string | undefined;
     /** Structured modifier requirements; empty map = "no modifiers held". */
     modifiers: ParsedModifiers;
+    /** Whether a pressed button may or must be held. Absent, none may. Only on
+     *  `hover`. */
+    held?: ModRequirement;
 }
 /** Parse a route string into its slots, filling in the shorthand defaults the
  *  grammar defines (bare phases mean channel `&`; an omitted arg or target
@@ -336,7 +344,8 @@ interface PointerDownSpec {
 }
 /**
  * The pointer moving over the surface with no button pressed. Fires on every
- * such move; a held pointer's moves belong to its drag and fire nothing here.
+ * such move; a held pointer's moves belong to its drag and fire nothing here,
+ * unless `held` says otherwise.
  *
  * With `motion: 'leave'` it fires instead when the pointer passes out of what
  * the binding targets: onto something its `target` does not match, or off the
@@ -347,11 +356,16 @@ interface PointerDownSpec {
  * runs, not only the best one, and the move still reaches the hover-cursor
  * pump. There is no press to own, so bind an immediate action, not an ongoing
  * one. Its params carry `worldX` / `worldY`, `clientX` / `clientY`,
- * `affordance`, `bodyTarget`, and `mods`.
+ * `affordance`, `bodyTarget`, `mods`, and `held`.
  */
 interface HoverSpec {
     kind: 'hover';
     motion?: 'move' | 'leave';
+    /** Whether a pressed button may (`'optional'`) or must (`true`) be held, as
+     *  `mods` says of a modifier; omitted, a held pointer's moves are not hovers.
+     *  Such a binding still claims nothing, so the drag keeps its moves. Leaving
+     *  the surface is a leave whether or not a button is held. */
+    held?: true | 'optional';
     target?: TargetSpec;
     mods?: ModSpec;
     phase?: PhaseSpec;
@@ -397,6 +411,29 @@ interface DropSpec {
     mods?: ModSpec;
     phase?: PhaseSpec;
 }
+/**
+ * A press that began elsewhere on the page, carried over the canvas: a palette
+ * item dragged in, a row dragged out of a list. The in-app sibling of
+ * {@link DropSpec}, which is the OS's drag. A carry is begun with `startCarry`.
+ * `types` filters by the payload's `type`, as globs; omitted or empty matches
+ * any carry.
+ *
+ * An ongoing action bound here starts when the carry comes over the surface:
+ * its moves update it, the release commits it, and leaving the surface or
+ * canceling the press cancels it. An immediate action fires once, on the
+ * release.
+ *
+ * `target` is matched against what is under the carry. With one, an ongoing
+ * action starts on the first step that is over its target, as the carry comes
+ * over or as it moves on, and an immediate action fires only on a release over it.
+ */
+interface CarrySpec {
+    kind: 'carry';
+    types?: string[];
+    target?: TargetSpec;
+    mods?: ModSpec;
+    phase?: PhaseSpec;
+}
 /** System-clipboard paste of external content. Same `types` semantics as
  *  {@link DropSpec} — omitted or empty = matches any paste. */
 interface PasteSpec {
@@ -406,7 +443,7 @@ interface PasteSpec {
     phase?: PhaseSpec;
 }
 /** The full union of supported gesture spec kinds. */
-type GestureSpec = KeySpec | KeyHeldSpec | WheelSpec | PinchSpec | ClickSpec | DoubleClickSpec | ContextMenuSpec | DragSpec | PointerDownSpec | HoverSpec | LongPressSpec | MultiTouchSpec | MultiTouchTapSpec | DropSpec | PasteSpec;
+type GestureSpec = KeySpec | KeyHeldSpec | WheelSpec | PinchSpec | ClickSpec | DoubleClickSpec | ContextMenuSpec | DragSpec | PointerDownSpec | HoverSpec | LongPressSpec | MultiTouchSpec | MultiTouchTapSpec | DropSpec | CarrySpec | PasteSpec;
 
 /**
  * Mini-grammar for the `arg` slot of `keyDown` / `keyUp` routes.
@@ -447,7 +484,7 @@ declare function keyRouteToSpec(r: ParsedKeyRoute): KeySpec;
  * Wildcards become omitted fields: a `*` target, direction or MIME list, and a
  * `[*:*]` phase slot. `[*]` is `[&:*]`, which an ambient binding never
  * matches, so it stays a phase atom. A `keyDown` / `keyHeld` arg is read as a
- * key route, so `keyDown(z?shift)` yields `mods.shift: 'optional'`; a drop or
+ * key route, so `keyDown(z?shift)` yields `mods.shift: 'optional'`; a drop, carry, or
  * paste arg is a `|`-separated MIME list.
  *
  * Throws on a route no spec can express: `keyUp`, a key or finger-count
@@ -519,13 +556,6 @@ declare function modifierComboToParsed(key: ModifierCombo): ParsedModifiers;
  *  `name=req` pairs joined by `&`. */
 declare function canonicalModifiers(mods: ParsedModifiers): string;
 
-/** Keyboard/pointer modifier flags carried by every {@link InputEvent} arm. */
-interface EventModifiers {
-    altKey: boolean;
-    ctrlKey: boolean;
-    metaKey: boolean;
-    shiftKey: boolean;
-}
 /**
  * Body-target classification from the scene hit-test. Populated by
  * `useGestureDispatcher` when a `classifyTarget` thunk is supplied to its
@@ -552,6 +582,28 @@ interface BodyClassification {
     /** Semantic kind of the hit body. Undefined on empty canvas, and undefined
      *  on a body whose kind the scene can't name — never guessed. */
     kind?: BodyKind;
+    /** The node classified. Matching ignores it. */
+    id?: string;
+    /** What a double-click at this point names, where that is not the body hit: the group a hit
+     *  member belongs to. A double click's targets match against it. Absent, the hit is named. */
+    doubleClick?: {
+        body: BodyTarget;
+        kind?: BodyKind;
+        id?: string;
+    };
+}
+/** The body a double-click names, as a press carries it to the double click it composes. */
+interface DoubleClickBody {
+    bodyTarget: BodyTarget;
+    bodyKind?: BodyKind;
+}
+
+/** Keyboard/pointer modifier flags carried by every {@link InputEvent} arm. */
+interface EventModifiers {
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    shiftKey: boolean;
 }
 /** A keystroke. */
 interface KeyEvent extends EventModifiers {
@@ -760,6 +812,8 @@ interface HoverEvent extends EventModifiers {
     from?: HoverWhere;
     /** The pointer has left the surface. Where it is and what it is over are its last move's. */
     off?: boolean;
+    /** A button was held through this move. Never set on `off`. */
+    held?: boolean;
     /** World-space position of the pointer. */
     x: number;
     y: number;
@@ -850,6 +904,25 @@ interface DropEvent extends EventModifiers {
     clientX?: number;
     clientY?: number;
 }
+/** A carry over the canvas (`startCarry`). `stage` is what it did here: came
+ *  over, moved, was released, or left — off the surface, or canceled on it. */
+interface CarryEvent extends EventModifiers {
+    kind: 'carry';
+    stage: 'enter' | 'move' | 'drop' | 'leave';
+    pointerId?: number;
+    /** The payload's type, which a spec's `types` globs filter, and the payload. */
+    type: string;
+    value: unknown;
+    /** World-space position (post view transform). */
+    x: number;
+    y: number;
+    clientX: number;
+    clientY: number;
+    /** What is under the carry, classified as a press there would be. */
+    affordance?: unknown;
+    bodyTarget?: BodyTarget;
+    bodyKind?: BodyKind;
+}
 /** External content pasted from the system clipboard. Carries no point. */
 interface PasteEvent extends EventModifiers {
     kind: 'paste';
@@ -864,7 +937,7 @@ interface PasteEvent extends EventModifiers {
  * The `affordance?` field on {@link PointerDownEvent} is widened to `unknown`
  * in this package — the kit narrows it back to `AffordanceHit` at consumption.
  */
-type InputEvent = KeyEvent | KeyHeldEvent | WheelEvent | PinchEvent | PointerDownEvent | PointerMoveEvent | HoverEvent | PointerUpEvent | PointerCancelEvent | ClickEvent | DoubleClickEvent | ContextMenuEvent | LongPressEvent | MultiTouchEvent | MultiTouchTapEvent | DropEvent | PasteEvent;
+type InputEvent = KeyEvent | KeyHeldEvent | WheelEvent | PinchEvent | PointerDownEvent | PointerMoveEvent | HoverEvent | PointerUpEvent | PointerCancelEvent | ClickEvent | DoubleClickEvent | ContextMenuEvent | LongPressEvent | MultiTouchEvent | MultiTouchTapEvent | DropEvent | CarryEvent | PasteEvent;
 
 /**
  * The stylus fields `src` carries, as a spread-able partial: a sample that
@@ -998,6 +1071,134 @@ declare function matchIngestTypes(items: readonly {
  */
 declare function isApplePlatform(): boolean;
 
+/** One key of a shortcut as a keyboard prints it. */
+interface KeyLegend {
+    /** Glyph drawn for the key (modifier or key). */
+    label: string;
+    /** When true, the key may be held but is not required to trigger the action
+     *  (e.g. an optional modifier). Defaults to false. */
+    optional?: boolean;
+}
+/** Logical modifier name. Matches the kit's `ModifierKey` in shape — kept as a
+ *  local type so `weasel-ui` stays independent of `@weasel-js/core`. */
+type LogicalMod = 'mod' | 'shift' | 'alt' | 'ctrl' | 'meta';
+/** Detected (or overridden) platform. `'mod'` resolves to ⌘ on macOS,
+ *  Ctrl on Windows / Linux. */
+type Platform = 'macos' | 'windows' | 'linux';
+/** Visual form of a modifier or named-key label.
+ *
+ *  - `'auto'` (default): the per-entry, per-platform default — whatever
+ *    label is actually printed on the physical key. macOS keys show the
+ *    Apple glyphs (⌘ ⌥ ⌃ ⇧ ⎋ ↵ ⇥). Windows keys mostly show text
+ *    (Ctrl, Alt, Shift) BUT the Win key shows its logo (⊞) and the
+ *    context-menu key shows ▤. Linux mirrors Windows with Super (⊞).
+ *  - `'symbol'` forces a glyph wherever the key has one: Apple's on macOS,
+ *    ISO/IEC 9995-7's elsewhere (⎈ Ctrl, ⎇ Alt, ⎋ Esc). A key with no
+ *    symbol still falls back to text.
+ *  - `'text'` always spells the label out (Cmd / Option / Esc / Enter). */
+type LegendStyle = 'auto' | 'symbol' | 'text';
+/** A modifier to render, named platform-independently. */
+interface LogicalModSpec {
+    name: LogicalMod;
+    /** Marks this modifier as optional (may be held but isn't required).
+     *  Forwarded as the resulting `KeyLegend.optional`. */
+    optional?: boolean;
+}
+/** Options for {@link keySpecsFromMods}. */
+interface KeySpecsFromModsOptions {
+    /** Override OS detection. Defaults to {@link detectPlatform}. */
+    platform?: Platform;
+    /** Defaults to `'auto'`. Pass `'symbol'` or `'text'` to force a specific
+     *  style regardless of platform. */
+    legend?: LegendStyle;
+    /** Labels that replace the platform and legend tables', by a modifier's
+     *  logical name (`mod`, `shift`, `alt`, `ctrl`, `meta`) or a key's
+     *  `KeyboardEvent.key` (`Escape`, `Home`, `z`): a whole keyboard's worth
+     *  for a layout, a locale, or a keyboard of one's own. */
+    labels?: KeyLabels;
+}
+/** Key labels by modifier name or `KeyboardEvent.key`. See {@link KeySpecsFromModsOptions.labels}. */
+type KeyLabels = Readonly<Record<string, string>>;
+/** Every label {@link keySpecsFromMods} can produce, on any platform and legend. */
+declare const MODIFIER_LABELS: ReadonlySet<string>;
+/** The platform whose key legends to draw. Whether `mod` is ⌘ comes from
+ *  `isApplePlatform`, the same read the dispatcher
+ *  matches `mod` with, so a keycap names the key that fires. With no
+ *  `navigator` (a server render) it answers `'macos'`, the kit's docs
+ *  convention; an unrecognized browser reads as `'linux'`. */
+declare function detectPlatform(): Platform;
+/**
+ * Map a list of **logical** modifiers (`'mod'`, `'shift'`, …) to **visual**
+ * `KeyLegend`s appropriate for the current platform — `'mod'` means "Cmd on
+ * Mac, Ctrl on Win/Linux".
+ *
+ * ```ts
+ * <KeySequence
+ *   keys={keySpecsFromMods([{ name: 'mod' }, { name: 'shift', optional: true }])}
+ * />
+ * ```
+ */
+declare function keySpecsFromMods(mods: readonly LogicalModSpec[], opts?: KeySpecsFromModsOptions): readonly KeyLegend[];
+/**
+ * Render a raw `KeyboardEvent.key` value as a platform-appropriate
+ * `KeyLegend`. Named non-modifier keys (Esc, Enter, Tab, Space, Backspace,
+ * Delete, arrows) get the platform's conventional form. Letter / digit /
+ * other keys pass through upper-cased.
+ *
+ * ```ts
+ * keySpecFromKey('Escape', { platform: 'macos' })   // { label: '⎋' }
+ * keySpecFromKey('Escape', { platform: 'windows' }) // { label: 'Esc' }
+ * keySpecFromKey('p')                               // { label: 'P' }
+ * ```
+ *
+ * Symbol mode off macOS draws ISO/IEC 9995-7's symbols where the key
+ * has one, though Windows and Linux keyboards print the text form.
+ */
+declare function keySpecFromKey(raw: string, opts?: KeySpecsFromModsOptions & {
+    optional?: boolean;
+}): KeyLegend;
+
+/** A keyboard shortcut as the formatters read it: `@weasel-js/menu`'s `MenuShortcut`. */
+type ShortcutInput = MenuShortcut;
+/** Options for {@link formatShortcut} and {@link formatShortcutParts}. */
+interface FormatShortcutOptions {
+    /** Defaults to the detected platform. */
+    platform?: Platform;
+}
+/** Format a shortcut as an array of display chips, one per key: the
+ *  modifiers, then the key, each as the platform's keyboard prints it, so
+ *  `mod` is `⌘` on macOS and `Ctrl` elsewhere. UIs that want a boxed per-key
+ *  look render each chip in its own element. `shift: 'optional'` is treated
+ *  as falsy. */
+declare function formatShortcutParts(b: ShortcutInput | undefined, opts?: FormatShortcutOptions): readonly string[] | undefined;
+/** Format a shortcut as a single display string. Order: mod, shift, alt,
+ *  key. On macOS the glyphs run together (`⌘⇧Z`); elsewhere the keys are
+ *  spelled out and joined with `+` (`Ctrl+Shift+Z`). Returns `undefined` for
+ *  `undefined` input so callers can `??` a fallback. When `key` is an array,
+ *  the first element is used. `shift: 'optional'` is treated as falsy. */
+declare function formatShortcut(b: ShortcutInput | undefined, opts?: FormatShortcutOptions): string | undefined;
+
+/**
+ * A shortcut as key legends, one per key, as `@weasel-js/ui`'s `KeySequence` draws them: mod, shift, alt, then the
+ * key, each in the platform's own legend (`⌘` on macOS, `Ctrl` elsewhere).
+ * `formatShortcutParts` is these labels as strings. `shift: 'optional'`
+ * becomes an optional key; a key list
+ * renders its first key. Returns `undefined` for no shortcut.
+ *
+ * ```tsx
+ * <KeySequence keys={keySpecsFromShortcut({ key: 'z', mod: true, shift: true })} />
+ * ```
+ */
+declare function keySpecsFromShortcut(shortcut: ShortcutInput | undefined, opts?: KeySpecsFromModsOptions): readonly KeyLegend[] | undefined;
+
+/**
+ * The legend of the physical key a `KeyboardEvent.code` names (`KeyA`, `ShiftLeft`, `ArrowUp`), as
+ * {@link keySpecFromKey} prints that key on the platform: `MetaLeft` is `⌘` on macOS and `⊞` on
+ * Windows. Letters and punctuation print as a US keyboard prints them. `opts.labels` answers by code
+ * first, then as it does for {@link keySpecFromKey} and {@link keySpecsFromMods}.
+ */
+declare function keySpecFromCode(code: string, opts?: KeySpecsFromModsOptions): KeyLegend;
+
 /**
  * The nearest element `from` sits inside that can host a portalled overlay,
  * or `null` when there is none and the body is the only answer.
@@ -1027,7 +1228,7 @@ declare function fixedSeat(from: Element | null | undefined): FixedSeat;
  *    [1] mods   — count of required modifier keys (shift/alt/ctrl/meta/mod).
  *                 `'optional'` does NOT count.
  *    [2] phase  — how much the spec's `phase` narrows; see `phaseRank`.
- *    [3] exact  — per-kind tiebreak: 2 for a drop/paste spec with a
+ *    [3] exact  — per-kind tiebreak: 2 for a drop/carry/paste spec with a
  *                 non-empty `types` MIME filter, else 1.
  *
  *  Identical tuples fall back to registration order in the matcher's
@@ -1102,6 +1303,8 @@ interface PressFacts extends EventModifiers {
     affordance?: unknown;
     bodyTarget?: BodyTarget;
     bodyKind?: BodyKind;
+    /** Replayed onto the double click in place of `bodyTarget` and `bodyKind`. */
+    doubleClickBody?: DoubleClickBody;
 }
 /** Where and how a press was released, for the click it turned out to be. */
 interface ReleaseFacts extends EventModifiers {
@@ -1184,6 +1387,13 @@ interface PointerSample extends EventModifiers, PointerSampleStylus {
     clientY: number;
     /** What the originating event was aimed at. */
     target?: unknown;
+    /**
+     * When the input happened, on the recognizer clock's timeline: a DOM event's
+     * `timeStamp` beside `performance.now()`. The windows between two inputs are
+     * measured on it, so a long task that delays an event's handling does not
+     * widen them. Read as the clock's `now()` when absent, 0, or ahead of it.
+     */
+    timeStamp?: number;
 }
 /** A pointer going down, with what the host found under it. */
 interface PressSample extends PointerSample {
@@ -1195,6 +1405,8 @@ interface PressSample extends PointerSample {
     affordance?: unknown;
     bodyTarget?: BodyTarget;
     bodyKind?: BodyKind;
+    /** What a double click this press completes lands on, where not the body hit. */
+    doubleClickBody?: DoubleClickBody;
 }
 
 /**
@@ -1233,6 +1445,14 @@ interface PointerRecognizerOptions {
     toSurface?: (client: Point) => Point;
     /** Long-press hold time in ms, read at each press. Default `LONG_PRESS_MS`. */
     longPressMs?: () => number | undefined;
+    /** Longest gap in ms between two clicks of a double click, read at each click. Default `DOUBLE_CLICK_MAX_MS`. */
+    doubleClickMs?: () => number | undefined;
+    /** Farthest two clicks of a double click may land apart, in CSS px. Default `DOUBLE_CLICK_MAX_PX`. */
+    doubleClickPx?: () => number | undefined;
+    /** Farthest a multitouch tap's fingers may travel, in CSS px. Default `TAP_THRESHOLD_PX`. */
+    tapPx?: () => number | undefined;
+    /** Travel in CSS px that makes a press a drag, read at each move. Default `DRAG_THRESHOLD_PX`. */
+    dragPx?: () => number | undefined;
     clicks?: ClickMemory;
     observer?: RecognizerObserver;
 }
@@ -1303,4 +1523,4 @@ declare function activatesFocusedControl(e: KeyboardEvent): boolean;
  */
 declare function focusedControlOwnsKey(e: KeyboardEvent): boolean;
 
-export { ACTIVE_SIGILS, type BodyClassification, type BodyKind, type BodyTarget, CONTROL_SELECTOR, type ChannelRef, type ClaimableGesture, type ClickEvent, type ClickMemory, type ClickObserver, type ClickSpec, type ContextMenuEvent, type ContextMenuSpec, DOUBLE_CLICK_MAX_MS, DOUBLE_CLICK_MAX_PX, DRAG_THRESHOLD_PX, type DescribeRouteOptions, type DoubleClickEvent, type DoubleClickSpec, type DragSpec, type DropEvent, type DropSpec, type EventModifiers, type FixedSeat, GESTURE_DESCRIPTORS, type GestureArgSpec, type GestureDescriptor, type GestureName, type GestureSpec, type HeldPointers, type HeldPress, type HoverEvent, type HoverSpec, type HoverWhere, type IngestItem, type InputEvent, type KeyEvent, type KeyHeldEvent, type KeyHeldSpec, type KeySpec, LONG_PRESS_MS, type LongPressEvent, type LongPressSpec, MOD_NAME_SET, type ModRequirement, type ModSpec, type ModifierCombo, type ModifierKey, type ModifiersEvent, type MultiTouchEvent, type MultiTouchGeometry, type MultiTouchSpec, type MultiTouchTapEvent, type MultiTouchTapSpec, type OptionalMod, type ParsedKeyRoute, type ParsedModifiers, type ParsedRoute, type PasteEvent, type PasteSpec, type PhaseAtom, type PhaseContext, type PhaseSpec, type PinchEvent, type PinchSpec, type Point, type PointerCancelEvent, type PointerDownEvent, type PointerDownSpec, type PointerIdentity, type PointerMoveEvent, type PointerRecognizer, type PointerRecognizerOptions, type PointerSample, type PointerSampleStylus, type PointerUpEvent, type PressFacts, type PressSample, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, RESERVED_SIGILS, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, type RecognizerClock, type RecognizerObserver, type RecognizerSink, type ReleaseFacts, type ReleaseOutcome, type RouteDescriptionPart, type RouteFieldName, type RoutePhase, type RouteTermLabel, TAP_THRESHOLD_PX, type TargetPredicate, type TargetSpec, type TargetSpecForm, UNKNOWN_MIME, VALID_MOD_NAMES, type WheelEvent, type WheelSpec, activatesFocusedControl, bodyPredicate, canonicalModifiers, clickEvents, collapseShiftPairs, createPointerRecognizer, describeRoute, describeRouteParts, fixedSeat, focusedControlOwnsKey, formatKeyRoute, formatPhaseAtom, formatRoute, getGestureDescriptor, heldPointers, hitPredicate, isApplePlatform, isEditableTarget, isInControlWithin, isKnownGestureName, keyRouteToSpec, longPressEvents, matchIngestTypes, matchKey, matchModifiers, matchPhase, matchSpec, matchTarget, mimeMatchesGlob, modifierComboToParsed, mods, multiTouchGeometry, nearestPortalHost, parseKeyRoute, parseRoute, parseTargetSpec, pastDragThreshold, routeGestureForSpecKind, routeToSpec, specKindForRouteGesture, specificity, stylusOf };
+export { ACTIVE_SIGILS, type BodyClassification, type BodyKind, type BodyTarget, CONTROL_SELECTOR, type CarryEvent, type CarrySpec, type ChannelRef, type ClaimableGesture, type ClickEvent, type ClickMemory, type ClickObserver, type ClickSpec, type ContextMenuEvent, type ContextMenuSpec, DOUBLE_CLICK_MAX_MS, DOUBLE_CLICK_MAX_PX, DRAG_THRESHOLD_PX, type DescribeRouteOptions, type DoubleClickBody, type DoubleClickEvent, type DoubleClickSpec, type DragSpec, type DropEvent, type DropSpec, type EventModifiers, type FixedSeat, type FormatShortcutOptions, GESTURE_DESCRIPTORS, type GestureArgSpec, type GestureDescriptor, type GestureName, type GestureSpec, type HeldPointers, type HeldPress, type HoverEvent, type HoverSpec, type HoverWhere, type IngestItem, type InputEvent, type KeyEvent, type KeyHeldEvent, type KeyHeldSpec, type KeyLabels, type KeyLegend, type KeySpec, type KeySpecsFromModsOptions, LONG_PRESS_MS, type LegendStyle, type LogicalMod, type LogicalModSpec, type LongPressEvent, type LongPressSpec, MODIFIER_LABELS, MOD_NAME_SET, type ModRequirement, type ModSpec, type ModifierCombo, type ModifierKey, type ModifiersEvent, type MultiTouchEvent, type MultiTouchGeometry, type MultiTouchSpec, type MultiTouchTapEvent, type MultiTouchTapSpec, type OptionalMod, type ParsedKeyRoute, type ParsedModifiers, type ParsedRoute, type PasteEvent, type PasteSpec, type PhaseAtom, type PhaseContext, type PhaseSpec, type PinchEvent, type PinchSpec, type Platform, type Point, type PointerCancelEvent, type PointerDownEvent, type PointerDownSpec, type PointerIdentity, type PointerMoveEvent, type PointerRecognizer, type PointerRecognizerOptions, type PointerSample, type PointerSampleStylus, type PointerUpEvent, type PressFacts, type PressSample, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, RESERVED_SIGILS, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, type RecognizerClock, type RecognizerObserver, type RecognizerSink, type ReleaseFacts, type ReleaseOutcome, type RouteDescriptionPart, type RouteFieldName, type RoutePhase, type RouteTermLabel, type ShortcutInput, TAP_THRESHOLD_PX, type TargetPredicate, type TargetSpec, type TargetSpecForm, UNKNOWN_MIME, VALID_MOD_NAMES, type WheelEvent, type WheelSpec, activatesFocusedControl, bodyPredicate, canonicalModifiers, clickEvents, collapseShiftPairs, createPointerRecognizer, describeRoute, describeRouteParts, detectPlatform, fixedSeat, focusedControlOwnsKey, formatKeyRoute, formatPhaseAtom, formatRoute, formatShortcut, formatShortcutParts, getGestureDescriptor, heldPointers, hitPredicate, isApplePlatform, isEditableTarget, isInControlWithin, isKnownGestureName, keyRouteToSpec, keySpecFromCode, keySpecFromKey, keySpecsFromMods, keySpecsFromShortcut, longPressEvents, matchIngestTypes, matchKey, matchModifiers, matchPhase, matchSpec, matchTarget, mimeMatchesGlob, modifierComboToParsed, mods, multiTouchGeometry, nearestPortalHost, parseKeyRoute, parseRoute, parseTargetSpec, pastDragThreshold, routeGestureForSpecKind, routeToSpec, specKindForRouteGesture, specificity, stylusOf };