@astryxdesign/core 0.7.5-canary.fccd771 → 0.7.5

package/src/gestures/__tests__/arenaContinuous.test.ts

@@ -0,0 +1,207 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file arenaContinuous.test.ts
+ * @input GestureArena with pans, long presses, taps, consumers and scroll
+ *   probes, driven by synthetic touches with explicit timestamps
+ * @output The pan's conflicts: native scrolling (failing, scroll edge,
+ *   handoff), long press vs pan, nested pans, delegate hooks, two fingers on
+ *   two views, delivery while moving, cancellation from code, the clock
+ * @position Unit tests of packages/core/src/gestures/GestureArena.ts
+ */
+
+import {describe, expect, it} from 'vitest';
+import {LongPressGestureRecognizer} from '../LongPressGestureRecognizer';
+import {PanGestureRecognizer} from '../PanGestureRecognizer';
+import {TapGestureRecognizer} from '../TapGestureRecognizer';
+import {createHarness, RecordingConsumer, scrollProbe} from './harness';
+
+describe('conflict matrix', () => {
+  it('pan vs native scroll: the browser taking the touch fails a possible pan', () => {
+    const h = createHarness();
+    const pan = new PanGestureRecognizer({name: 'pan', direction: 'vertical'});
+    h.finger(1)
+      .down(0, 100, 0, {recognizers: [pan]})
+      .move(0, 105, 16);
+    h.finger(1).takenByBrowser(24);
+    // The touch is gone from the pan, so it is ready for the next one.
+    expect(h.log).toEqual(['pan:failed@24', 'pan:possible@24']);
+    expect(h.claims).toEqual([]);
+  });
+
+  it('pan at a scroll edge (scrollEdge): begins and claims when the content cannot scroll that way', () => {
+    const atTop = createHarness();
+    const sheet = new PanGestureRecognizer({
+      name: 'sheet',
+      direction: 'down',
+      scrollEdge: true,
+    });
+    // Content at its top: a finger moving down scrolls nothing.
+    const probe = scrollProbe((_dx, dy) => dy < 0);
+    atTop.finger(1).down(0, 100, 0, {recognizers: [sheet], scroll: probe});
+    atTop.finger(1).drag(0, 30, 50, 5);
+    expect(atTop.log[0]).toBe('sheet:began@20');
+    expect(atTop.claims).toEqual([1]);
+
+    const midContent = createHarness();
+    const scrolled = new PanGestureRecognizer({
+      name: 'sheet',
+      direction: 'down',
+      scrollEdge: true,
+    });
+    const canScrollUp = scrollProbe(() => true);
+    midContent.finger(1).down(0, 100, 0, {
+      recognizers: [scrolled],
+      scroll: canScrollUp,
+    });
+    midContent.finger(1).drag(0, 30, 50, 5);
+    expect(midContent.log).toEqual(['sheet:failed@20']);
+  });
+
+  it("a drag that began as a scroll stays the browser's past the content's edge (spec:AST-094 FR14)", () => {
+    const h = createHarness();
+    const sheet = new PanGestureRecognizer({
+      name: 'sheet',
+      direction: 'down',
+      scrollEdge: true,
+    });
+    let scrollTop = 30;
+    const finger = h.finger(1).down(0, 100, 0, {
+      recognizers: [sheet],
+      scroll: scrollProbe(() => scrollTop > 0),
+    });
+    // The content scrolls toward its top: the drag is the browser's.
+    finger.move(0, 120, 16);
+    finger.takenByBrowser(20);
+    // It reaches its top mid-gesture; the finger keeps pulling.
+    scrollTop = 0;
+    finger.move(0, 160, 32);
+    finger.move(0, 200, 48);
+    finger.up(64);
+    // It failed at its first move and is reset when the browser takes the
+    // touch: it never begins, however far the finger pulls.
+    expect(h.log).toEqual(['sheet:failed@16', 'sheet:possible@20']);
+  });
+
+  it('long press vs pan: holding still wins for the long press', () => {
+    const h = createHarness();
+    const press = new LongPressGestureRecognizer({name: 'press'});
+    const pan = new PanGestureRecognizer({name: 'pan'});
+    h.finger(1).down(0, 0, 0, {recognizers: [press, pan]});
+    h.advance(500);
+    expect(h.log).toEqual(['press:began@500', 'pan:failed@500']);
+    h.finger(1).move(80, 0, 600);
+    expect(press.state).toBe('changed');
+    expect(pan.state).toBe('failed');
+    expect(h.claims).toEqual([1]);
+  });
+
+  it('long press vs pan: moving first wins for the pan', () => {
+    const h = createHarness();
+    const press = new LongPressGestureRecognizer({name: 'press'});
+    const pan = new PanGestureRecognizer({name: 'pan'});
+    h.finger(1).down(0, 0, 0, {recognizers: [press, pan]});
+    h.finger(1).move(5, 0, 100).move(12, 0, 120);
+    expect(h.log).toEqual(['press:failed@120', 'pan:began@120']);
+    h.advance(600);
+    expect(press.state).toBe('failed');
+  });
+
+  it('nested pans that both qualify on the same move: the innermost wins', () => {
+    const h = createHarness();
+    const inner = new PanGestureRecognizer({name: 'inner'});
+    const outer = new PanGestureRecognizer({name: 'outer'});
+    h.finger(1)
+      .down(0, 0, 0, {recognizers: [inner, outer]})
+      .move(20, 0, 16);
+    expect(h.log).toEqual(['inner:began@16', 'outer:failed@16']);
+  });
+
+  it('honors shouldBegin and shouldReceiveTouch', () => {
+    const h = createHarness();
+    const refused = new PanGestureRecognizer({
+      name: 'refused',
+      shouldBegin: () => false,
+    });
+    const blind = new TapGestureRecognizer({
+      name: 'blind',
+      shouldReceiveTouch: () => false,
+    });
+    h.finger(1)
+      .down(0, 0, 0, {recognizers: [refused, blind]})
+      .move(30, 0, 16);
+    expect(h.log).toEqual(['refused:failed@16']);
+    expect(blind.numberOfTouches).toBe(0);
+  });
+
+  it('two fingers on two unrelated views drive two pans at once', () => {
+    const h = createHarness();
+    const left = new PanGestureRecognizer({name: 'left'});
+    const right = new PanGestureRecognizer({name: 'right'});
+    h.finger(1).down(50, 300, 0, {recognizers: [left]});
+    h.finger(2).down(300, 300, 0, {recognizers: [right]});
+    h.finger(1).move(50, 340, 16);
+    h.finger(2).move(300, 260, 16);
+    expect(left.state).toBe('began');
+    expect(right.state).toBe('began');
+  });
+});
+
+describe('delivery to the view', () => {
+  it('delivers an unclaimed touch to the consumer and allows its click', () => {
+    const h = createHarness();
+    const consumer = new RecordingConsumer();
+    const pan = new PanGestureRecognizer({name: 'pan'});
+    const finger = h.finger(1).down(0, 0, 0, {recognizers: [pan], consumer});
+    finger.move(3, 0, 16);
+    expect(finger.up(60)).toBe('allow');
+    expect(consumer.events).toEqual(['began:1', 'moved:1', 'ended:1']);
+  });
+
+  it('cancels the view and swallows the click when a recognizer takes the touch', () => {
+    const h = createHarness();
+    const consumer = new RecordingConsumer();
+    const pan = new PanGestureRecognizer({name: 'pan'});
+    const finger = h.finger(1).down(0, 0, 0, {recognizers: [pan], consumer});
+    finger.move(30, 0, 16).move(40, 0, 32);
+    expect(consumer.events).toEqual(['began:1', 'cancelled:1']);
+    expect(finger.up(60)).toBe('suppress');
+  });
+
+  it('keeps the view and the click with cancelsTouchesInView off', () => {
+    const h = createHarness();
+    const consumer = new RecordingConsumer();
+    const pan = new PanGestureRecognizer({
+      name: 'pan',
+      cancelsTouchesInView: false,
+    });
+    const finger = h.finger(1).down(0, 0, 0, {recognizers: [pan], consumer});
+    finger.move(30, 0, 16);
+    expect(finger.up(60)).toBe('allow');
+    expect(consumer.events).toEqual(['began:1', 'moved:1', 'ended:1']);
+  });
+});
+
+describe('cancellation', () => {
+  it('stop() cancels an active recognizer from code', () => {
+    const h = createHarness();
+    const pan = new PanGestureRecognizer({name: 'pan'});
+    h.finger(1)
+      .down(0, 0, 0, {recognizers: [pan]})
+      .move(30, 0, 16);
+    pan.cancel();
+    expect(pan.state).toBe('cancelled');
+    h.finger(1).move(60, 0, 32);
+    expect(pan.state).toBe('cancelled');
+    h.finger(1).up(48);
+    expect(pan.state).toBe('possible');
+  });
+
+  it('never moves the event clock backwards', () => {
+    const h = createHarness();
+    const pan = new PanGestureRecognizer({name: 'pan'});
+    h.finger(1).down(0, 0, 100, {recognizers: [pan]});
+    h.finger(1).move(30, 0, 90);
+    expect(h.log).toEqual(['pan:began@100']);
+  });
+});

package/src/gestures/__tests__/arenaTapLongPress.test.ts

@@ -0,0 +1,211 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file arenaTapLongPress.test.ts
+ * @input GestureArena with taps, long presses and consumers, driven by
+ *   synthetic touches with explicit timestamps
+ * @output The arena with real discrete and press recognizers: tap vs double
+ *   tap with and without require-to-fail, delegate requirements, delivery and
+ *   deferred clicks, cancellation before and after a long press began
+ * @position Unit tests of packages/core/src/gestures/GestureArena.ts; the
+ *   arena's own rules, with scripted recognizers, are in arena.test.ts
+ */
+
+import {describe, expect, it} from 'vitest';
+import {LongPressGestureRecognizer} from '../LongPressGestureRecognizer';
+import {TapGestureRecognizer} from '../TapGestureRecognizer';
+import {UIKIT_GESTURES} from '../../motion/uikit/gestures';
+import {createHarness, RecordingConsumer} from './harness';
+
+const INTERVAL = UIKIT_GESTURES.tap.maximumIntervalBetweenTaps.value;
+
+describe('conflict matrix', () => {
+  it('tap vs double tap, single requires double to fail: the single waits out the interval', () => {
+    const h = createHarness();
+    const single = new TapGestureRecognizer({name: 'single'});
+    const double = new TapGestureRecognizer({
+      name: 'double',
+      numberOfTapsRequired: 2,
+    });
+    single.requireToFail(double);
+    h.finger(1).down(0, 0, 0, {recognizers: [single, double]});
+    h.finger(1).up(80);
+    expect(single.state).toBe('possible');
+    expect(single.pending).toBe('ended');
+    h.advance(80 + INTERVAL);
+    expect(h.log).toEqual([
+      `double:failed@${80 + INTERVAL}`,
+      `single:ended@${80 + INTERVAL}`,
+      `single:possible@${80 + INTERVAL}`,
+      `double:possible@${80 + INTERVAL}`,
+    ]);
+  });
+
+  it('tap vs double tap, single requires double to fail: a double tap fails the single', () => {
+    const h = createHarness();
+    const single = new TapGestureRecognizer({name: 'single'});
+    const double = new TapGestureRecognizer({
+      name: 'double',
+      numberOfTapsRequired: 2,
+    });
+    single.requireToFail(double);
+    h.finger(1).down(0, 0, 0, {recognizers: [single, double]});
+    h.finger(1).up(80);
+    h.finger(2).down(2, 2, 200, {recognizers: [single, double]});
+    h.finger(2).up(260);
+    expect(h.log).toEqual([
+      'double:ended@260',
+      'single:failed@260',
+      'single:possible@260',
+      'double:possible@260',
+    ]);
+  });
+
+  it('tap vs double tap with no requirement: the single wins at once and fails the double', () => {
+    const h = createHarness();
+    const single = new TapGestureRecognizer({name: 'single'});
+    const double = new TapGestureRecognizer({
+      name: 'double',
+      numberOfTapsRequired: 2,
+    });
+    h.finger(1).down(0, 0, 0, {recognizers: [single, double]});
+    h.finger(1).up(80);
+    expect(h.log.slice(0, 2)).toEqual(['single:ended@80', 'double:failed@80']);
+  });
+
+  it('a recognizer that is not involved holds nothing up', () => {
+    const h = createHarness();
+    const idle = new TapGestureRecognizer({name: 'idle'});
+    const tap = new TapGestureRecognizer({name: 'tap'});
+    tap.requireToFail(idle);
+    h.finger(1).down(0, 0, 0, {recognizers: [tap]});
+    h.finger(1).up(50);
+    expect(h.log[0]).toBe('tap:ended@50');
+  });
+
+  it('honors delegate failure requirements', () => {
+    const h = createHarness();
+    const double = new TapGestureRecognizer({
+      name: 'double',
+      numberOfTapsRequired: 2,
+    });
+    const single = new TapGestureRecognizer({
+      name: 'single',
+      shouldRequireFailureOf: (_self, other) => other === double,
+    });
+    h.finger(1).down(0, 0, 0, {recognizers: [single, double]});
+    h.finger(1).up(50);
+    expect(single.pending).toBe('ended');
+  });
+});
+
+describe('delivery to the view', () => {
+  it('delivers an unclaimed touch to the consumer and allows its click', () => {
+    const h = createHarness();
+    const consumer = new RecordingConsumer();
+    const press = new LongPressGestureRecognizer({name: 'press'});
+    const finger = h.finger(1).down(0, 0, 0, {recognizers: [press], consumer});
+    finger.move(3, 0, 16);
+    expect(finger.up(60)).toBe('allow');
+    expect(consumer.events).toEqual(['began:1', 'moved:1', 'ended:1']);
+  });
+
+  it('cancels the view and swallows the click when a recognizer takes the touch', () => {
+    const h = createHarness();
+    const consumer = new RecordingConsumer();
+    const press = new LongPressGestureRecognizer({name: 'press'});
+    const finger = h.finger(1).down(0, 0, 0, {recognizers: [press], consumer});
+    h.advance(500);
+    expect(consumer.events).toEqual(['began:1', 'cancelled:1']);
+    expect(h.claims).toEqual([1]);
+    expect(finger.up(600)).toBe('suppress');
+  });
+
+  it('keeps the view and the click with cancelsTouchesInView off', () => {
+    const h = createHarness();
+    const consumer = new RecordingConsumer();
+    const press = new LongPressGestureRecognizer({
+      name: 'press',
+      cancelsTouchesInView: false,
+    });
+    const finger = h.finger(1).down(0, 0, 0, {recognizers: [press], consumer});
+    h.advance(500);
+    expect(finger.up(600)).toBe('allow');
+    expect(consumer.events).toEqual(['began:1', 'ended:1']);
+  });
+
+  it('defers the click of a tap a double tap may still claim, then replays it', () => {
+    const h = createHarness();
+    const consumer = new RecordingConsumer();
+    const double = new TapGestureRecognizer({
+      name: 'double',
+      numberOfTapsRequired: 2,
+    });
+    const finger = h.finger(1).down(0, 0, 0, {recognizers: [double], consumer});
+    expect(finger.up(70)).toBe('defer');
+    expect(consumer.events).toEqual(['began:1']);
+    h.advance(70 + INTERVAL);
+    expect(consumer.events).toEqual(['began:1', 'ended:1']);
+    expect(h.deferredClicks).toEqual([
+      {id: 1, allowed: true, time: 70 + INTERVAL},
+    ]);
+  });
+
+  it('drops the deferred click when the double tap is recognized', () => {
+    const h = createHarness();
+    const consumer = new RecordingConsumer();
+    const double = new TapGestureRecognizer({
+      name: 'double',
+      numberOfTapsRequired: 2,
+    });
+    h.finger(1).down(0, 0, 0, {recognizers: [double], consumer});
+    h.finger(1).up(70);
+    h.finger(2).down(1, 1, 150, {recognizers: [double], consumer});
+    expect(h.finger(2).up(210)).toBe('suppress');
+    expect(h.deferredClicks).toEqual([{id: 1, allowed: false, time: 210}]);
+    expect(consumer.events).toEqual([
+      'began:1',
+      'began:2',
+      'cancelled:1',
+      'cancelled:2',
+    ]);
+  });
+
+  it('cancels the view when the browser takes the touch', () => {
+    const h = createHarness();
+    const consumer = new RecordingConsumer();
+    const tap = new TapGestureRecognizer({name: 'tap'});
+    const finger = h.finger(1).down(0, 0, 0, {recognizers: [tap], consumer});
+    finger.takenByBrowser(30);
+    expect(consumer.events).toEqual(['began:1', 'cancelled:1']);
+    expect(h.log).toEqual(['tap:failed@30', 'tap:possible@30']);
+  });
+});
+
+describe('cancellation', () => {
+  it('a system cancel cancels an active gesture and fails a possible one', () => {
+    const h = createHarness();
+    const press = new LongPressGestureRecognizer({name: 'press'});
+    const tap = new TapGestureRecognizer({name: 'tap'});
+    h.finger(1).down(0, 0, 0, {recognizers: [press]});
+    h.advance(500);
+    h.finger(2).down(100, 0, 600, {recognizers: [tap]});
+    h.arena.cancelled([1, 2], 650);
+    expect(h.log).toEqual([
+      'press:began@500',
+      'press:cancelled@650',
+      'tap:failed@650',
+      'press:possible@650',
+      'tap:possible@650',
+    ]);
+  });
+
+  it('a long press cancelled before its duration never begins', () => {
+    const h = createHarness();
+    const press = new LongPressGestureRecognizer({name: 'press'});
+    h.finger(1).down(0, 0, 0, {recognizers: [press]});
+    h.finger(1).cancel(200);
+    h.advance(1000);
+    expect(h.log).toEqual(['press:failed@200', 'press:possible@200']);
+  });
+});

package/src/gestures/__tests__/fixtures/pointer-streams/README.md

@@ -0,0 +1,82 @@
+# Pointer streams
+
+What real browsers delivered for one moving contact, as the page saw it.
+`VelocityTracker.streams.test.ts` replays them (spec:AST-100 FR4).
+
+| Files                                  | Browser                                              | Pointer           | Input                                                         |
+| -------------------------------------- | ---------------------------------------------------- | ----------------- | ------------------------------------------------------------- |
+| `android-chromium-*`                   | Chromium 158 on an Android 15 emulator               | touch             | 120 Hz through a uinput touchscreen                           |
+| `android-firefox-*`                    | Firefox 158 on the same emulator                     | touch             | the same                                                      |
+| `ios-safari-*`                         | Safari 26.2 on an iOS 26.2 simulator (iPhone 17 Pro) | touch             | HID through idb, about one move every 30 ms                   |
+| `desktop-chromium-{mouse,pen,touch}-*` | headless Chromium 149                                | mouse, pen, touch | CDP input at 120 Hz, each event stamped at its scheduled time |
+
+Each source has three gestures:
+
+- `slow`: 200 px down at 200 px/s, lifted while moving;
+- `fling`: 300 px down at 2,000 px/s, lifted while moving;
+- `stop-release`: 200 px in 400 ms, then still for 300 ms (longer than the
+  40 ms stillness interval), then lifted.
+
+On iOS the simulator paces the moves itself, so its recordings differ: Safari
+delivered 194 px at 183.5 px/s for the slow drag, 240 px at 2,400 px/s for the
+fling, and the stop-then-release's moves over about 2.2 s before its still
+300 ms. Each fixture's `injected.speed` is what Safari delivered.
+
+## Format (schema 1)
+
+- `events`: `[type, t, x, y]` for each pointer and touch event, with `t` in ms
+  after the pointerdown's `timeStamp` and `x`, `y` in CSS px from where the
+  contact went down. A `pointermove` adds its `getCoalescedEvents()` samples
+  (`[t, x, y]` each) and its `getPredictedEvents()` count.
+- `injected`: the ground truth. `speed` is px/s along y while the contact
+  moved; a source injected at a set rate also has its `hz` and `points`.
+- `release`: where the replay releases (`pointerup`, or `lastMove` with a
+  `note` saying why) and, for a stream whose release misses the injected
+  speed by more than 10%, `check: "shape"`: it is not velocity evidence, and
+  only its direction and axis are checked.
+- `caveat`: what the input is not (below).
+
+## Caveat
+
+Rig input is synthetic, not a finger: Android injects at 120 Hz through a
+uinput touchscreen and desktop through CDP, each through the browser's real
+input pipeline; iOS input is HID through idb on a leased simulator, which
+delivers a move every ~30 ms (not 120 Hz), so iOS speeds are the distance
+Safari delivered between the first and last moving pointermove, over that time.
+A physical finger's 120–240 Hz jittered sampling is not reproduced.
+
+## What the replay feeds
+
+Each `pointermove` event's own position and time, one sample per event, as
+`PanGestureRecognizer` reads them (it does not read `getCoalescedEvents()`).
+The coalesced samples are the input the browser received: the replay also
+models a busy main thread from them, one event per four input samples at the
+latest of them, as a browser coalesces input while its handlers run late.
+
+## What the streams show
+
+- Chromium on Android coalesces one to three samples into each `pointermove`
+  at 120 Hz input; Firefox dispatches about 60 a second, each with a one-entry
+  coalesced list.
+- For CDP-dispatched input, desktop Chromium returns an empty
+  `getCoalescedEvents()` list, so the busy-thread replay uses the events
+  themselves.
+- Safari on the simulator merged two moves that arrived in one frame into a
+  single `pointermove` whose coalesced list had one entry (one 120 px step).
+- idb lifts 58–85 ms after the last move, longer than the stillness interval,
+  so the iOS slow drag and fling release at their last move. The simulator
+  delivers their steps 29–44 ms apart, and against the speed Safari delivered
+  each misses 10% on one of its two releases: the slow
+  drag's pan reads 22.9% under (its scroll 2.3% over), the fling's scroll
+  12.2% under (its pan 7.2% under, from six samples). Neither is velocity
+  evidence; both are checked for direction and axis only.
+- iOS input at 120 Hz would need XCTest's own event synthesis
+  (`press(forDuration:thenDragTo:withVelocity:thenHoldForDuration:)`), which
+  these streams do not use.
+
+## Capturing a stream
+
+`capture.html` records one contact: open it in the browser, drive one gesture
+over it, and read the record from `window.__streams` (or have the page post
+it with `?post=probe` or `?post=beacon`). A fixture is that record plus the
+injected ground truth and the fields above.

package/src/gestures/__tests__/fixtures/pointer-streams/android-chromium-fling.json

@@ -0,0 +1,130 @@
+{
+  "schema": 1,
+  "platform": "Android 15 emulator",
+  "browser": "Chromium 158.0.8123.0",
+  "ua": "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/158.0.0.0 Mobile Safari/537.36",
+  "dpr": 1.75,
+  "pointerType": "touch",
+  "coarse": true,
+  "gesture": "fling",
+  "caveat": "Rig input is synthetic, not a finger: Android injects at 120 Hz through a uinput touchscreen and desktop through CDP, each through the browser's real input pipeline; iOS input is HID through idb on a leased simulator, which delivers a move every ~30 ms (not 120 Hz), so iOS speeds are the distance Safari delivered between the first and last moving pointermove, over that time. A physical finger's 120–240 Hz jittered sampling is not reproduced.",
+  "injected": {
+    "source": "one continuous touch through a uinput touchscreen (no stylus) at 120 Hz, Android 15 emulator, panel 720×1600",
+    "hz": 120,
+    "speed": 2000,
+    "restMs": 0,
+    "points": [
+      [0, 0, 0],
+      [8.333, 0, 16.677],
+      [16.667, 0, 33.354],
+      [25, 0, 50.032],
+      [33.333, 0, 66.709],
+      [41.667, 0, 83.386],
+      [50, 0, 100.063],
+      [58.333, 0, 116.741],
+      [66.667, 0, 133.418],
+      [75, 0, 150.095],
+      [83.333, 0, 166.772],
+      [91.667, 0, 183.45],
+      [100, 0, 200.127],
+      [108.333, 0, 216.804],
+      [116.667, 0, 233.481],
+      [125, 0, 250.159],
+      [133.333, 0, 266.836],
+      [141.667, 0, 283.513],
+      [150, 0, 300.19]
+    ]
+  },
+  "release": {
+    "at": "pointerup"
+  },
+  "liftAfterLastMoveMs": 0,
+  "events": [
+    ["pointerdown", 0, 0, 0],
+    ["touchstart", 0, 0, 0],
+    ["pointermove", 0, 0, 16.685, [[0, 0, 16.685]], 0],
+    ["touchmove", 0, 0, 16.685],
+    ["pointermove", 4.5, 0, 33.343, [[4.5, 0, 33.343]], 0],
+    ["touchmove", 4.5, 0, 33.343],
+    [
+      "pointermove",
+      21.3,
+      0,
+      66.713,
+      [
+        [13.1, 0, 50.028],
+        [21.3, 0, 66.713]
+      ],
+      3
+    ],
+    ["touchmove", 21.3, 0, 66.713],
+    [
+      "pointermove",
+      38,
+      0,
+      100.056,
+      [
+        [29.9, 0, 83.398],
+        [38, 0, 100.056]
+      ],
+      3
+    ],
+    ["touchmove", 38, 0, 100.056],
+    ["pointermove", 46.5, 0, 116.741, [[46.5, 0, 116.741]], 3],
+    ["touchmove", 46.5, 0, 116.741],
+    [
+      "pointermove",
+      71.6,
+      0,
+      166.769,
+      [
+        [55, 0, 133.426],
+        [63.5, 0, 150.112],
+        [71.6, 0, 166.769]
+      ],
+      3
+    ],
+    ["touchmove", 71.6, 0, 166.769],
+    [
+      "pointermove",
+      88.4,
+      0,
+      200.139,
+      [
+        [80.1, 0, 183.454],
+        [88.4, 0, 200.139]
+      ],
+      3
+    ],
+    ["touchmove", 88.4, 0, 200.139],
+    [
+      "pointermove",
+      104.9,
+      0,
+      233.482,
+      [
+        [96.6, 0, 216.797],
+        [104.9, 0, 233.482]
+      ],
+      3
+    ],
+    ["touchmove", 104.9, 0, 233.482],
+    ["pointermove", 113.2, 0, 250.167, [[113.2, 0, 250.167]], 3],
+    ["touchmove", 113.2, 0, 250.167],
+    [
+      "pointermove",
+      138.4,
+      0,
+      300.195,
+      [
+        [121.8, 0, 266.853],
+        [130, 0, 283.51],
+        [138.4, 0, 300.195]
+      ],
+      3
+    ],
+    ["touchmove", 138.4, 0, 300.195],
+    ["pointerup", 138.4, 0, 300.195],
+    ["touchend", 138.4, 0, 300.195]
+  ]
+}