gesturx 1.2.0 → 1.6.0

package/dist/index.js

@@ -1,483 +1,501 @@
-var ae = Object.defineProperty;
-var ce = (e, n, t) => n in e ? ae(e, n, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[n] = t;
-var w = (e, n, t) => (ce(e, typeof n != "symbol" ? n + "" : n, t), t);
-import { filter as v, NEVER as K, merge as A, BehaviorSubject as le, scan as E, map as h, fromEvent as b, mergeMap as T, defer as ge, of as q, takeUntil as x, endWith as he, switchMap as R, exhaustMap as j, shareReplay as Q, withLatestFrom as Y, first as O, share as M, skipUntil as $e, combineLatest as S, ignoreElements as ue, timer as de, buffer as ve, debounceTime as fe, distinctUntilChanged as z } from "rxjs";
-function Ae(e, n) {
+var ee = Object.defineProperty;
+var te = (t, s, e) => s in t ? ee(t, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[s] = e;
+var h = (t, s, e) => (te(t, typeof s != "symbol" ? s + "" : s, e), e);
+import { filter as l, mergeMap as T, defer as ne, of as b, merge as m, takeWhile as N, scan as O, map as g, fromEvent as S, BehaviorSubject as B, switchMap as v, NEVER as se, shareReplay as w, exhaustMap as G, first as Y, share as M, timer as H, withLatestFrom as j, takeUntil as k, skip as ie, tap as pe, ignoreElements as oe, buffer as re, debounceTime as ae, startWith as le, pairwise as he, combineLatest as ce } from "rxjs";
+function ue(t, s) {
   return Math.sqrt(
-    Math.pow(n.x - e.x, 2) + Math.pow(n.y - e.y, 2)
+    Math.pow(s.x - t.x, 2) + Math.pow(s.y - t.y, 2)
   );
 }
-function De(e) {
-  const n = e.length;
-  if (n < 2)
+function ge(t) {
+  const s = t.length;
+  if (s < 2)
     return 0;
-  const t = e.reduce((o, r, p) => o + e.slice(p + 1).reduce((l, a) => l + Ae(r, a), 0), 0), s = n * (n - 1) / 2;
-  return t / s;
+  const e = t.reduce((n, r, a) => n + t.slice(a + 1).reduce((p, o) => p + ue(r, o), 0), 0), i = s * (s - 1) / 2;
+  return e / i;
 }
-function _(e, n) {
-  const t = n.x - e.x, s = n.y - e.y;
-  return Math.atan2(s, t);
+function U(t, s) {
+  const e = s.x - t.x, i = s.y - t.y;
+  return Math.atan2(i, e);
 }
-function ye(e, n) {
-  return _(e, n) * (180 / Math.PI);
+function $e(t, s) {
+  return U(t, s) * (180 / Math.PI);
 }
-function C(e) {
-  const n = e.reduce(
-    (s, o) => (s.x += o.x, s.y += o.y, s),
+function z(t) {
+  const s = t.reduce(
+    (i, n) => (i.x += n.x, i.y += n.y, i),
     { x: 0, y: 0 }
-  ), t = e.length || 1;
+  ), e = t.length || 1;
   return {
-    x: n.x / t,
-    y: n.y / t
+    x: s.x / e,
+    y: s.y / e
   };
 }
-function me(e, n) {
-  if (e.length !== n.length)
+function de(t, s) {
+  if (t.length !== s.length)
     throw new Error("Initial and new points arrays must have the same length.");
-  const t = C(e), s = C(n);
-  let o = 0;
-  for (let l = 0; l < e.length; l++) {
-    const a = _(
-      t,
-      e[l]
+  const e = z(t), i = z(s);
+  let n = 0;
+  for (let p = 0; p < t.length; p++) {
+    const o = U(
+      e,
+      t[p]
     );
-    let c = _(
-      s,
-      n[l]
-    ) - a;
-    c > Math.PI ? c -= 2 * Math.PI : c < -Math.PI && (c += 2 * Math.PI), o += c;
+    let u = U(
+      i,
+      s[p]
+    ) - o;
+    u > Math.PI ? u -= 2 * Math.PI : u < -Math.PI && (u += 2 * Math.PI), n += u;
   }
-  const r = o / e.length, p = r * (180 / Math.PI);
-  return { radianDelta: r, degreesDelta: p };
+  const r = n / t.length, a = r * (180 / Math.PI);
+  return { radianDelta: r, degreesDelta: a };
 }
-function we(e) {
-  return e != null;
+function ve(t) {
+  return t != null;
 }
-const Pe = (e) => e.length > 0, Me = (e) => e.pipe(v(Pe));
-function Z(e, n, t) {
-  const s = C([e]), o = C([n]);
-  return Math.abs(o.x - s.x) > t || Math.abs(o.y - s.y) > t;
+const ye = (t) => t.length > 0, me = (t) => t.pipe(l(ye));
+function J(t, s, e) {
+  const i = z([t]), n = z([s]);
+  return Math.abs(n.x - i.x) >= e || Math.abs(n.y - i.y) >= e;
 }
-const Te = (e) => e != null && e.length ? A(...(e == null ? void 0 : e.map(({ start$: n }) => n)) ?? []) : K, xe = (e, n, t) => {
-  const s = e > 0 ? n / e : 0, o = e > 0 ? t / e : 0;
+const De = (t, s, e) => {
+  const i = t > 0 ? s / t : 0, n = t > 0 ? e / t : 0;
   return {
-    velocityX: s,
-    velocityY: o
+    velocityX: i,
+    velocityY: n
   };
 };
-class F {
-  constructor(n) {
-    w(this, "config$", new le({}));
-    w(this, "validConfig$", this.config$.pipe(
-      v(
-        (n) => !!n.container
-      )
-    ));
-    this.update(n);
-  }
-  initialize(n) {
-    const t = this.config$.getValue();
-    this.config$.next({
-      ...t,
-      ...n,
-      options: {
-        ...t.options,
-        ...n.options
-      }
-    });
-  }
-  update(n) {
-    const t = this.config$.getValue();
-    this.config$.next({
-      ...t,
-      options: {
-        ...t.options,
-        ...n
-      }
-    });
-  }
+function F(t) {
+  return (s) => s.pipe(
+    l((e) => e.pointerId === t.pointerId)
+  );
 }
-const J = (e, n, t, s) => {
-  const o = e.x - n.x + t, r = e.y - n.y + s;
+const K = (t) => t.type === "pointerleave" || t.type === "pointercancel" || t.type === "pointerup", Pe = ({
+  container: t,
+  afterEventReceived: s = (e) => e
+}) => S(t, "pointerdown").pipe(
+  g(s)
+), Q = ({
+  pointerEvent$: t
+}) => (s) => {
+  const e = t.pipe(
+    l((p) => p.type === "pointerup")
+  ), i = t.pipe(
+    l((p) => p.type === "pointerleave")
+  ), n = t.pipe(
+    l((p) => p.type === "pointercancel")
+  ), r = t.pipe(
+    l((p) => p.type === "pointermove")
+  ), a = (p) => ["pointercancel", "pointerleave", "pointerup"].includes(p.type);
+  return s.pipe(
+    T((p) => {
+      const o = ne(() => b(p));
+      return m(
+        o,
+        m(r, n, i, e)
+      ).pipe(
+        F(p),
+        N((u) => !a(u), !0)
+      );
+    }),
+    O((p, o) => {
+      if (a(o)) {
+        const { [o.pointerId]: c, ...u } = (p == null ? void 0 : p.pointers) ?? {};
+        return {
+          event: o,
+          pointers: u
+        };
+      }
+      return {
+        event: o,
+        pointers: {
+          ...(p == null ? void 0 : p.pointers) ?? {},
+          [o.pointerId]: o
+        }
+      };
+    }, void 0),
+    g(({ event: p, pointers: o }) => ({
+      event: p,
+      pointers: Object.values(o).filter(ve)
+    }))
+  );
+}, _ = (t, s, e, i) => {
+  const n = t.x - s.x + e, r = t.y - s.y + i;
   return {
-    deltaX: o,
+    deltaX: n,
     deltaY: r
   };
-}, W = (e) => {
-  const n = (t) => C(
-    t.latestActivePointers.length ? t.latestActivePointers : [t.event]
+}, Z = (t) => {
+  const s = (e) => z(
+    e.latestActivePointers.length ? e.latestActivePointers : [e.event]
   );
-  return e.pipe(
-    E(
-      (t, s) => {
-        var D, m;
-        const o = n(s), r = t.center, p = t.deltaX, l = t.deltaY, a = ((D = t.latestActivePointers) == null ? void 0 : D.length) ?? 0, $ = ((m = s.latestActivePointers) == null ? void 0 : m.length) ?? 0, c = [
-          "pointerdown",
-          "pointercancel",
-          "pointerleave",
-          "pointerup"
-        ].includes(s.event.type) && a !== $, i = $ > 0, { deltaX: g, deltaY: d } = c && i ? J(o, o, p, l) : J(o, r, p, l), { degreesDelta: f } = a === $ && a >= 2 && $ >= 2 ? me(
-          t.latestActivePointers ?? [],
-          s.latestActivePointers ?? []
-        ) : { degreesDelta: 0 };
-        return {
-          startTime: (/* @__PURE__ */ new Date()).getTime(),
-          ...t,
-          ...s,
-          center: o,
-          deltaX: g,
-          deltaY: d,
-          deltaPointersAngle: f
-        };
-      },
-      {
-        deltaX: 0,
-        deltaY: 0,
-        center: { x: 0, y: 0 },
-        latestActivePointers: []
-      }
-    ),
-    h((t) => {
+  return t.pipe(
+    O((e, i) => {
+      var d, x;
+      const n = s(i), r = (e == null ? void 0 : e.center) ?? n, a = (e == null ? void 0 : e.deltaX) ?? 0, p = (e == null ? void 0 : e.deltaY) ?? 0, o = ((d = e == null ? void 0 : e.latestActivePointers) == null ? void 0 : d.length) ?? 1, c = ((x = i.latestActivePointers) == null ? void 0 : x.length) ?? 1, u = ["pointerdown", "pointercancel", "pointerleave", "pointerup"].includes(
+        i.event.type
+      ) && o !== c, f = c > 0, { deltaX: $, deltaY: P } = u && f ? _(n, n, a, p) : _(n, r, a, p), { degreesDelta: D } = o === c && o >= 2 && c >= 2 ? de(
+        (e == null ? void 0 : e.latestActivePointers) ?? [],
+        i.latestActivePointers ?? []
+      ) : { degreesDelta: 0 };
+      return {
+        startTime: (/* @__PURE__ */ new Date()).getTime(),
+        ...e,
+        ...i,
+        center: n,
+        deltaX: $,
+        deltaY: P,
+        deltaPointersAngle: D
+      };
+    }, void 0),
+    g((e) => {
       const {
-        deltaX: s,
-        deltaY: o,
+        deltaX: i,
+        deltaY: n,
         latestActivePointers: r,
-        startTime: p,
-        center: l,
-        event: a,
-        deltaPointersAngle: $
-      } = t, c = r ?? [], g = Date.now() - p, { velocityX: d, velocityY: f } = xe(g, s, o), D = De(r);
+        startTime: a,
+        center: p,
+        event: o,
+        deltaPointersAngle: c
+      } = e, u = r ?? [], $ = Date.now() - a, { velocityX: P, velocityY: D } = De($, i, n), d = ge(r);
       return {
-        deltaX: s,
-        deltaY: o,
-        velocityX: d,
-        velocityY: f,
-        delay: g,
-        center: l,
-        pointers: c,
-        startTime: p,
-        event: a,
-        deltaPointersAngle: $,
-        pointersAverageDistance: D
+        deltaX: i,
+        deltaY: n,
+        velocityX: P,
+        velocityY: D,
+        delay: $,
+        center: p,
+        pointers: u,
+        startTime: a,
+        event: o,
+        deltaPointersAngle: c,
+        pointersAverageDistance: d
       };
     })
   );
-};
-function U(e) {
-  return (n) => n.pipe(
-    v((t) => t.pointerId === e.pointerId)
-  );
-}
-const N = ({
-  container: e,
-  afterEventReceived: n = (t) => t
+}, q = (t) => t.pipe(
+  l(
+    (s) => !!s.container
+  )
+), W = (t) => t.pipe(l(K)), Ae = ({
+  container: t,
+  afterEventReceived: s = (e) => e
 }) => {
-  const t = ee({ afterEventReceived: n, container: e }), s = b(e, "pointerup").pipe(
-    h(n)
-  ), o = b(e, "pointermove").pipe(
-    h(n)
-  ), r = b(e, "pointerleave").pipe(
-    h(n)
-  ), p = b(
-    e,
+  const e = Pe({ afterEventReceived: s, container: t }), i = S(t, "pointerup").pipe(
+    g(s)
+  ), n = S(t, "pointermove").pipe(
+    g(s)
+  ), r = S(t, "pointerleave").pipe(
+    g(s)
+  ), a = S(
+    t,
     "pointercancel"
-  ).pipe(h(n));
-  return {
-    pointerDown$: t,
-    pointerCancel$: p,
-    pointerLeave$: r,
-    pointerUp$: s,
-    pointerMove$: o
-  };
-}, ee = ({
-  container: e,
-  afterEventReceived: n = (t) => t
-}) => b(e, "pointerdown").pipe(
-  h(n)
-), V = ({
-  pointerCancel$: e,
-  pointerLeave$: n,
-  pointerUp$: t,
-  pointerMove$: s,
-  trackMove: o
-}) => (r) => r.pipe(
-  T((p) => {
-    const l = A(
-      t,
-      n,
-      e
-    ).pipe(U(p)), a = ge(() => q(p));
-    return A(
-      a,
-      o ? s : K
-    ).pipe(
-      U(p),
-      h((c) => ({ id: c.pointerId, event: c })),
-      x(l),
-      he({ id: p.pointerId, event: void 0 })
-    );
-  }),
-  E(
-    (p, { event: l, id: a }) => {
-      if (!l) {
-        const { [a]: $, ...c } = p;
-        return c;
-      }
-      return {
-        ...p,
-        [a]: l
-      };
-    },
-    {}
-  ),
-  h((p) => Object.values(p).filter(we))
-);
-class B extends F {
-  constructor(t = {}) {
-    super(t);
-    w(this, "events$");
-    w(this, "start$");
-    w(this, "end$");
-    w(this, "fingers$");
-    this.options = t, this.events$ = this.validConfig$.pipe(
-      R((s) => {
-        const { container: o, afterEventReceived: r } = s, { posThreshold: p = 15 } = s.options ?? {}, {
-          pointerCancel$: l,
-          pointerDown$: a,
-          pointerLeave$: $,
-          pointerMove$: c,
-          pointerUp$: i
-        } = N({
-          container: o,
+  ).pipe(g(s));
+  return m(
+    e,
+    a,
+    r,
+    i,
+    n
+  );
+};
+class C {
+  constructor(s, e) {
+    h(this, "configSubject", new B({}));
+    h(this, "panEvent$");
+    h(this, "pointerEvent$");
+    h(this, "pointerDown$");
+    h(this, "pointerUp$");
+    h(this, "pointerCancel$");
+    h(this, "pointerMove$");
+    h(this, "pointerOff$");
+    h(this, "state$");
+    h(this, "failWith$");
+    h(this, "config$", this.configSubject.pipe(q));
+    const i = new B({
+      fingers: 0
+    });
+    this.pointerEvent$ = this.config$.pipe(
+      v(
+        ({ container: n, afterEventReceived: r }) => Ae({
+          container: n,
           afterEventReceived: r
-        });
-        return a.pipe(
-          j((g) => {
-            const d = A(
-              q(g),
-              a
-            ), f = A(
-              l,
-              a,
-              $,
-              c,
-              i
-            ), D = d.pipe(
-              V({
-                pointerCancel$: l,
-                pointerLeave$: $,
-                pointerUp$: i,
-                pointerMove$: c,
-                trackMove: !0
-              }),
-              Q()
-            ), m = A(
-              i,
-              $,
-              l
-            ).pipe(
-              Y(D),
-              v(([u, y]) => !y.length),
-              h(([u]) => u),
-              O(),
+        })
+      )
+    ), this.pointerDown$ = this.pointerEvent$.pipe(
+      l((n) => n.type === "pointerdown")
+    ), this.pointerUp$ = this.pointerEvent$.pipe(
+      l((n) => n.type === "pointerup")
+    ), this.pointerMove$ = this.pointerEvent$.pipe(
+      l((n) => n.type === "pointermove")
+    ), this.pointerCancel$ = this.pointerEvent$.pipe(
+      l((n) => n.type === "pointercancel")
+    ), this.pointerOff$ = this.pointerEvent$.pipe(W), this.failWith$ = this.config$.pipe(
+      v(
+        ({ failWith: n }) => n != null && n.length ? m(...(n == null ? void 0 : n.map(({ start$: r }) => r)) ?? []) : se
+      )
+    ), this.panEvent$ = this.configSubject.pipe(
+      q,
+      v((n) => {
+        var f, $, P;
+        const r = Math.max(1, ((f = n.panConfig) == null ? void 0 : f.numInputs) ?? 1), a = Math.max(0, (($ = n.panConfig) == null ? void 0 : $.posThreshold) ?? 0), p = Math.max(0, ((P = n.panConfig) == null ? void 0 : P.delay) ?? 0), o = this.pointerDown$.pipe(
+          Q({
+            pointerEvent$: this.pointerEvent$,
+            trackMove: !0
+          }),
+          w(1)
+        ), c = (D) => D.pipe(
+          l(
+            (d) => d.pointers.length >= r
+          )
+        ), u = (D) => D.pipe(l((d) => d.pointers.length < r));
+        return o.pipe(
+          c,
+          G(({ pointers: D }) => {
+            const d = o.pipe(
+              u,
+              Y(),
               M()
-            ), I = d.pipe(
+            ), x = H(p), I = m(
+              ...D.map((y) => b(y)),
+              this.pointerDown$
+            ).pipe(
               T(
-                (u) => c.pipe(
-                  U(u),
-                  // we start pan only if the user started moving a certain distance
-                  v(
-                    (y) => Z(
-                      u,
+                (y) => m(this.pointerMove$, b(y)).pipe(
+                  F(y),
+                  l(
+                    (E) => J(
                       y,
-                      p
+                      E,
+                      a
                     )
                   )
                 )
               ),
-              O()
+              Y()
             ).pipe(
-              h(() => ({
+              v(() => x),
+              j(o),
+              g(([, { event: y, pointers: E }]) => ({
                 type: "panStart",
-                event: g
+                event: y,
+                latestActivePointers: E
               })),
-              M(),
-              x(m)
-            ), k = I.pipe(
+              w({
+                bufferSize: 1,
+                refCount: !1
+              }),
+              k(d)
+            ), A = I.pipe(
+              T(
+                () => o.pipe(
+                  ie(1),
+                  g(({ event: y, pointers: E }) => ({
+                    type: "panMove",
+                    event: y,
+                    latestActivePointers: E
+                  }))
+                )
+              ),
+              k(d)
+            ), L = I.pipe(
               T(
-                () => m.pipe(
-                  h((u) => ({
+                () => d.pipe(
+                  g(({ event: y, pointers: E }) => ({
                     type: "panEnd",
-                    event: u
+                    event: y,
+                    latestActivePointers: E
                   }))
                 )
               )
-            ), L = f.pipe(
-              $e(I),
-              h((u) => ({
-                type: "panMove",
-                event: u
-              })),
-              x(m)
-            ), X = A(I, L, k).pipe(
-              Y(D),
-              h(([u, y]) => ({
-                ...u,
-                latestActivePointers: y
-              })),
-              M()
+            ), R = m(I, A, L).pipe(
+              w(1)
             );
-            return S([
-              X.pipe(W),
-              X
-            ]).pipe(
-              h(([u, { type: y }]) => ({
-                ...u,
-                type: y
+            return R.pipe(
+              Z,
+              j(R),
+              g(([y, { type: E }]) => ({
+                ...y,
+                type: E
               }))
             );
           })
         );
       }),
-      M()
-    ), this.start$ = this.events$.pipe(
-      v((s) => s.type === "panStart")
-    ), this.end$ = this.events$.pipe(v((s) => s.type === "panEnd")), this.fingers$ = this.validConfig$.pipe(
-      R(({ container: s, afterEventReceived: o }) => {
-        const r = N({
-          container: s,
-          afterEventReceived: o
+      pe((n) => {
+        i.next({
+          fingers: n.pointers.length
         });
-        return r.pointerDown$.pipe(
-          V({
-            ...r,
-            trackMove: !1
-          })
-        );
       }),
-      h((s) => s.length)
-    );
+      M()
+    ), this.state$ = i.asObservable(), this.updateInternal(s ?? {}, e);
+  }
+  updateInternal(s, e) {
+    const i = this.configSubject.getValue();
+    this.configSubject.next({
+      ...i,
+      ...s,
+      ...s.options && {
+        options: { ...i.options, ...s.options }
+      },
+      panConfig: {
+        ...i.panConfig,
+        ...e
+      }
+    });
+  }
+  update(s, e) {
+    this.updateInternal(s, e);
+  }
+}
+class Ie extends C {
+  constructor(e) {
+    var i;
+    super(e, {
+      ...e,
+      posThreshold: ((i = e == null ? void 0 : e.options) == null ? void 0 : i.posThreshold) ?? 15
+    });
+    h(this, "events$");
+    h(this, "start$");
+    h(this, "end$");
+    this.events$ = this.panEvent$, this.start$ = this.panEvent$.pipe(
+      l((n) => n.type === "panStart")
+    ), this.end$ = this.events$.pipe(l((n) => n.type === "panEnd"));
+  }
+  update(e) {
+    super.update(e, e.options);
   }
 }
-const Re = (e) => (n) => n.pipe(
-  v((t) => Math.abs(t.velocityX) >= e || Math.abs(t.velocityY) >= e)
+const Ee = (t) => (s) => s.pipe(
+  l((e) => Math.abs(e.velocityX) >= t || Math.abs(e.velocityY) >= t)
 );
-class be extends F {
-  constructor(t = {}) {
-    super(t);
-    w(this, "events$");
-    this.options = t, this.events$ = this.validConfig$.pipe(
-      R((s) => {
-        const { escapeVelocity: o = 0.9, posThreshold: r } = s.options ?? {}, p = new B({ posThreshold: r });
-        p.initialize(s);
-        const l = p.events$.pipe(
-          v(({ pointers: a }) => a.length > 1)
-        );
-        return p.start$.pipe(
-          j((a) => p.end$.pipe(
-            O(),
-            Re(o),
-            h(({ type: $, ...c }) => ({
+class Te extends C {
+  constructor(e) {
+    super(e, {
+      posThreshold: 0,
+      numInputs: 1
+    });
+    h(this, "events$");
+    this.events$ = this.config$.pipe(
+      v((i) => {
+        const { escapeVelocity: n = 0.9 } = i.options ?? {}, r = this.panEvent$.pipe(
+          l((p) => p.type === "panStart")
+        ), a = this.panEvent$.pipe(l((p) => p.type === "panEnd"));
+        return r.pipe(
+          v((p) => a.pipe(
+            Ee(n),
+            g(({ type: o, ...c }) => ({
               type: "swipe",
-              angle: ye(
-                a.event,
+              angle: $e(
+                p.event,
                 c.event
               ),
               ...c
-            })),
-            x(l)
+            }))
           )),
           M()
         );
       })
     );
   }
+  update(e) {
+    super.update(e);
+  }
 }
-class Ce extends F {
-  constructor(t) {
-    super(t);
-    w(this, "events$");
-    this.options = t, this.events$ = this.validConfig$.pipe(
-      R((s) => {
-        const { container: o, afterEventReceived: r } = s, {
-          multiTapThreshold: p = 200,
-          maximumPressTime: l = 250,
-          maxTaps: a = 2,
-          // threshold should be high because of fingers size
-          // and potential margin due to it. clicks are nearly perfect
-          // not fingers.
-          posThreshold: $ = 10,
-          failWith: c
-        } = s.options ?? {}, { pointerUp$: i, pointerLeave$: g, pointerCancel$: d, pointerMove$: f } = N({
-          container: o,
-          afterEventReceived: r
-        }), D = ee({ container: o, afterEventReceived: r }), m = D.pipe(
-          V({
-            pointerCancel$: d,
-            pointerLeave$: g,
-            pointerMove$: f,
-            pointerUp$: i,
-            trackMove: !1
+const fe = ({
+  timeout: t,
+  pointerEvent$: s
+}) => (e) => e.pipe(
+  T(
+    (i) => H(t).pipe(
+      k(
+        s.pipe(W, F(i))
+      )
+    )
+  )
+), we = ({
+  initialPointerEvent: t,
+  pointerEvent$: s,
+  tolerance: e
+}) => (i) => i.pipe(
+  T(
+    (n) => s.pipe(
+      F(n),
+      N((r) => !K(r), !0),
+      l(
+        (r) => J(t, r, e)
+      )
+    )
+  )
+);
+class be extends C {
+  constructor(e) {
+    super(e);
+    h(this, "events$");
+    this.events$ = this.config$.pipe(
+      v((i) => {
+        const {
+          multiTapThreshold: n = 0,
+          maximumPressTime: r = 150,
+          maxTaps: a = 1,
+          tolerance: p = 10
+        } = i.options ?? {}, o = this.pointerDown$.pipe(
+          Q({
+            pointerEvent$: this.pointerEvent$,
+            trackMove: !0
           }),
-          Q(1)
-        ), G = m.pipe(
-          v((u) => u.length > 1)
-        ), I = (u) => u.pipe(
-          Y(m),
-          v(([, y]) => y.length === 1),
-          h(([y]) => y)
-        ), k = (u) => u.pipe(
-          ve(i.pipe(fe(p))),
-          O()
-        ), L = Te(c);
-        return A(
-          D,
-          m.pipe(ue())
+          w(1)
+        ), c = o.pipe(
+          l(({ pointers: $ }) => $.length > 1)
+        ), u = ($) => $.pipe(
+          re(this.pointerUp$.pipe(ae(n))),
+          Y()
+        );
+        return m(
+          this.pointerDown$,
+          o.pipe(oe())
         ).pipe(
-          I,
-          j((u) => {
-            const y = A(q(u), D), te = A(
-              i,
-              g,
-              d,
-              f
-            ), ne = y.pipe(k), se = te.pipe(
-              v(
-                (P) => Z(
-                  u,
-                  P,
-                  $
-                )
-              ),
-              O()
-            ), oe = m.pipe(
-              R(() => de(l))
-            ), ie = A(
-              L,
+          G(($) => {
+            const P = m(
+              b($),
+              this.pointerDown$
+            ).pipe(w(1)), D = P.pipe(u), d = P.pipe(
+              we({
+                initialPointerEvent: $,
+                pointerEvent$: this.pointerEvent$,
+                tolerance: p
+              })
+            ), x = P.pipe(
+              fe({
+                pointerEvent$: this.pointerEvent$,
+                timeout: r
+              })
+            ), V = m(
+              this.failWith$,
+              this.pointerCancel$,
+              c,
               d,
-              G,
-              se,
-              oe
-            ), H = ne.pipe(
-              Me,
-              v((P) => P.length <= a),
-              h((P) => ({
+              x
+            ), I = D.pipe(
+              me,
+              l((A) => A.length <= a),
+              g((A) => ({
                 type: "tap",
-                taps: P.length,
-                latestActivePointers: P,
-                event: P[0]
-              }))
+                taps: A.length,
+                latestActivePointers: A,
+                event: A[0]
+              })),
+              w(1)
             );
-            return S([
-              H.pipe(W),
-              H
-            ]).pipe(
-              h(([P, { type: re, taps: pe }]) => ({
-                ...P,
-                type: re,
-                taps: pe
+            return I.pipe(
+              Z,
+              j(I),
+              g(([A, { type: L, taps: R }]) => ({
+                ...A,
+                type: L,
+                taps: R
               })),
-              x(ie)
+              k(V)
             );
           })
         );
@@ -485,143 +503,167 @@ class Ce extends F {
       M()
     );
   }
+  update(e) {
+    super.update(e);
+  }
 }
-class Fe extends F {
-  constructor(t = {}) {
-    super(t);
-    w(this, "events$");
-    this.options = t, this.events$ = this.config$.pipe(
-      R((s) => {
-        const { posThreshold: o } = s.options ?? {}, r = new B({ posThreshold: o });
-        r.initialize(s);
-        const p = r.events$.pipe(
-          v(({ pointers: i }) => i.length < 2),
-          z()
-        ), a = r.events$.pipe(
-          h((i) => [i, i.pointers.length > 1]),
-          z(
-            ([i, g], [d, f]) => g === f
-          ),
-          v(([i, g]) => g)
-        ).pipe(
-          h(([i]) => ({
-            ...i,
+class Se extends C {
+  constructor(e = {}) {
+    super(e, {
+      numInputs: 2,
+      posThreshold: 15,
+      ...e.options
+    });
+    h(this, "events$");
+    this.events$ = this.config$.pipe(
+      v(() => {
+        const i = this.panEvent$.pipe(
+          l((p) => p.type === "panStart"),
+          g((p) => ({
+            ...p,
             type: "rotateStart",
             angle: 0,
             deltaAngle: 0
-          }))
-        ), $ = a.pipe(
-          T(
-            () => r.events$.pipe(
-              E(
-                (i, g) => {
-                  const d = i.angle + g.deltaPointersAngle;
-                  return {
-                    ...i,
-                    ...g,
-                    type: "rotate",
-                    angle: d,
-                    deltaAngle: g.deltaPointersAngle
-                  };
-                },
-                { angle: 0, deltaAngle: 0 }
-              ),
-              x(p)
-            )
-          )
-        ), c = a.pipe(
-          T(
-            () => S([$, p]).pipe(
-              O(),
-              h(([i]) => ({
-                ...i,
-                type: "rotateEnd"
-              }))
+          })),
+          w(1)
+        ), n = i.pipe(
+          v(
+            () => this.panEvent$.pipe(
+              O((p, o) => {
+                const c = ((p == null ? void 0 : p.angle) ?? 0) + o.deltaPointersAngle;
+                return {
+                  ...p,
+                  ...o,
+                  angle: c,
+                  deltaAngle: o.deltaPointersAngle
+                };
+              }, void 0)
             )
-          )
+          ),
+          M()
+        ), r = n.pipe(
+          l((p) => p.type === "panMove"),
+          g((p) => ({ ...p, type: "rotateMove" }))
+        ), a = n.pipe(
+          l((p) => p.type === "panEnd"),
+          g((p) => ({ ...p, type: "rotateEnd" }))
         );
-        return A(a, $, c);
-      })
+        return m(i, r, a);
+      }),
+      M()
     );
   }
+  update(e) {
+    super.update(e, e.options);
+  }
 }
-class ze extends F {
-  constructor(t = {}) {
-    super(t);
-    w(this, "events$");
-    this.options = t, this.events$ = this.config$.pipe(
-      R((s) => {
-        const { posThreshold: o } = s.options ?? {}, r = new B({ posThreshold: o });
-        r.initialize(s);
-        const p = r.events$.pipe(
-          v(({ pointers: i }) => i.length < 2),
-          z()
-        ), a = r.events$.pipe(
-          h((i) => [i, i.pointers.length > 1]),
-          z(
-            ([i, g], [d, f]) => g === f
+const X = ({
+  type: t,
+  initialEvent: s
+}) => (e) => e.pipe(
+  O((i, n) => {
+    const a = ((i == null ? void 0 : i.pointers.length) ?? 0) !== n.pointers.length, p = (i == null ? void 0 : i.pointersAverageDistance) ?? n.pointersAverageDistance, o = a ? n.pointersAverageDistance : i && "initialPointersAverageDistance" in i ? i.initialPointersAverageDistance : n.pointersAverageDistance, c = o === 0 ? 1 : n.pointersAverageDistance / o, u = n.pointersAverageDistance - o, f = n.pointersAverageDistance - o, $ = a || p === 0 ? 1 : n.pointersAverageDistance / p;
+    return {
+      ...i,
+      ...n,
+      type: t,
+      initialPointersAverageDistance: o,
+      scale: c,
+      distance: u,
+      deltaDistance: f,
+      deltaDistanceScale: $
+    };
+  }, s),
+  g(({ initialPointersAverageDistance: i, ...n }) => n)
+);
+class ze extends C {
+  constructor(e) {
+    super(e, {
+      ...e == null ? void 0 : e.options,
+      numInputs: 2
+    });
+    h(this, "events$");
+    this.events$ = this.config$.pipe(
+      v(() => {
+        const i = this.panEvent$.pipe(
+          l((a) => a.type === "panStart"),
+          v(
+            (a) => b(a).pipe(
+              X({
+                type: "pinchStart",
+                initialEvent: void 0
+              })
+            )
           ),
-          v(([i, g]) => g)
-        ).pipe(
-          h(([i]) => ({
-            ...i,
-            type: "pinchStart",
-            scale: 1,
-            distance: 0,
-            deltaDistance: 0,
-            deltaDistanceScale: 1
-          }))
-        ), $ = a.pipe(
-          T((i) => r.events$.pipe(
-            E(
-              (g, d) => {
-                const f = g.pointersAverageDistance ?? d.pointersAverageDistance, D = d.pointersAverageDistance / i.pointersAverageDistance;
-                return {
-                  ...g,
-                  ...d,
-                  scale: D,
-                  distance: d.pointersAverageDistance - i.pointersAverageDistance,
-                  deltaDistance: d.pointersAverageDistance - f,
-                  deltaDistanceScale: d.pointersAverageDistance / f,
-                  type: "pinchMove"
-                };
-              },
-              { scale: 0 }
-            ),
-            x(p)
+          w(1)
+        ), n = i.pipe(
+          v((a) => this.panEvent$.pipe(
+            N((p) => p.type !== "panEnd"),
+            X({
+              type: "pinchMove",
+              initialEvent: a
+            })
           ))
-        ), c = a.pipe(
-          T(
-            () => S([$, p]).pipe(
-              O(),
-              h(([i]) => ({
-                ...i,
-                type: "pinchEnd"
-              }))
+        ), r = i.pipe(
+          v(
+            (a) => this.panEvent$.pipe(
+              // we cannot have a panEnd without a previous event so it will always emit
+              le(a),
+              he(),
+              l(([p, o]) => o.type === "panEnd"),
+              v(
+                ([p, o]) => b(o).pipe(
+                  X({
+                    type: "pinchEnd",
+                    initialEvent: p
+                  })
+                )
+              )
             )
           )
         );
-        return A(a, $, c);
-      })
+        return m(i, n, r);
+      }),
+      M()
     );
   }
+  update(e) {
+    super.update(e, e.options);
+  }
+}
+class Ce {
+  constructor(s) {
+    h(this, "events$");
+    h(this, "recognizers");
+    h(this, "state$");
+    this.options = s, this.recognizers = s.recognizers, this.events$ = m(
+      ...s.recognizers.map((e) => e.events$)
+    ).pipe(M()), this.state$ = ce(
+      this.recognizers.map((e) => e.state$)
+    ).pipe(
+      g(
+        (e) => e.reduce((i, n) => ({
+          fingers: Math.max(i.fingers, n.fingers)
+        }))
+      )
+    );
+  }
+  initialize(s) {
+    s.style.touchAction = "none", s.style.userSelect = "none", this.options.recognizers.forEach((e) => {
+      console.log("recognizable update"), e.update({
+        container: s,
+        afterEventReceived: this.options.afterEventReceived
+      });
+    });
+  }
 }
-const Ee = ({
-  afterEventReceived: e = (t) => t,
-  recognizers: n
-}) => ({ events$: A(
-  ...n.map((o) => o.events$)
-).pipe(M()), initialize: (o) => {
-  o.style.touchAction = "none", o.style.userSelect = "none", n.forEach((r) => {
-    r.initialize({ container: o, afterEventReceived: e });
-  });
-}, recognizers: n });
 export {
-  B as PanRecognizer,
+  Ie as PanRecognizer,
   ze as PinchRecognizer,
-  Fe as RotateRecognizer,
-  be as SwipeRecognizer,
-  Ce as TapRecognizer,
-  Ee as createManager
+  Ce as Recognizable,
+  C as Recognizer,
+  Se as RotateRecognizer,
+  Te as SwipeRecognizer,
+  be as TapRecognizer
 };
 //# sourceMappingURL=index.js.map