gesturx 1.1.0 → 1.5.0

package/dist/index.js

@@ -1,122 +1,122 @@
-var re = Object.defineProperty;
-var pe = (e, t, n) => t in e ? re(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
-var D = (e, t, n) => (pe(e, typeof t != "symbol" ? t + "" : t, n), n);
-import { filter as d, NEVER as _, merge as $, BehaviorSubject as ae, scan as G, map as u, fromEvent as T, mergeMap as X, defer as ce, of as S, takeUntil as I, endWith as le, switchMap as b, exhaustMap as N, shareReplay as H, withLatestFrom as Y, first as O, share as A, skipUntil as ue, combineLatest as J, ignoreElements as he, timer as ge, buffer as de, debounceTime as $e } from "rxjs";
-function ve(e, t) {
+var ae = Object.defineProperty;
+var ce = (t, e, n) => e in t ? ae(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
+var m = (t, e, n) => (ce(t, typeof e != "symbol" ? e + "" : e, n), n);
+import { filter as v, NEVER as K, merge as A, BehaviorSubject as le, scan as F, map as h, fromEvent as I, 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 z, share as P, skipUntil as $e, combineLatest as S, ignoreElements as ue, timer as de, buffer as ve, debounceTime as fe, distinctUntilChanged as E } from "rxjs";
+function Ae(t, e) {
   return Math.sqrt(
-    Math.pow(t.x - e.x, 2) + Math.pow(t.y - e.y, 2)
+    Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2)
   );
 }
-function fe(e) {
-  const t = e.length;
-  if (t < 2)
+function ye(t) {
+  const e = t.length;
+  if (e < 2)
     return 0;
-  const n = e.reduce((o, r, i) => o + e.slice(i + 1).reduce((p, a) => p + ve(r, a), 0), 0), s = t * (t - 1) / 2;
+  const n = t.reduce((o, r, p) => o + t.slice(p + 1).reduce((l, a) => l + Ae(r, a), 0), 0), s = e * (e - 1) / 2;
   return n / s;
 }
-function z(e, t) {
-  const n = t.x - e.x, s = t.y - e.y;
+function _(t, e) {
+  const n = e.x - t.x, s = e.y - t.y;
   return Math.atan2(s, n);
 }
-function me(e, t) {
-  return z(e, t) * (180 / Math.PI);
+function De(t, e) {
+  return _(t, e) * (180 / Math.PI);
 }
-function R(e) {
-  const t = e.reduce(
+function b(t) {
+  const e = t.reduce(
     (s, o) => (s.x += o.x, s.y += o.y, s),
     { x: 0, y: 0 }
-  ), n = e.length || 1;
+  ), n = t.length || 1;
   return {
-    x: t.x / n,
-    y: t.y / n
+    x: e.x / n,
+    y: e.y / n
   };
 }
-function ye(e, t) {
-  if (e.length !== t.length)
+function me(t, e) {
+  if (t.length !== e.length)
     throw new Error("Initial and new points arrays must have the same length.");
-  const n = R(e), s = R(t);
+  const n = b(t), s = b(e);
   let o = 0;
-  for (let p = 0; p < e.length; p++) {
-    const a = z(
+  for (let l = 0; l < t.length; l++) {
+    const a = _(
       n,
-      e[p]
+      t[l]
     );
-    let c = z(
+    let c = _(
       s,
-      t[p]
+      e[l]
     ) - a;
     c > Math.PI ? c -= 2 * Math.PI : c < -Math.PI && (c += 2 * Math.PI), o += c;
   }
-  const r = o / e.length, i = r * (180 / Math.PI);
-  return { radianDelta: r, degreesDelta: i };
+  const r = o / t.length, p = r * (180 / Math.PI);
+  return { radianDelta: r, degreesDelta: p };
 }
-function we(e) {
-  return e != null;
+function we(t) {
+  return t != null;
 }
-const Pe = (e) => e.length > 0, De = (e) => e.pipe(d(Pe));
-function K(e, t, n) {
-  const s = R([e]), o = R([t]);
+const Me = (t) => t.length > 0, Pe = (t) => t.pipe(v(Me));
+function Z(t, e, n) {
+  const s = b([t]), o = b([e]);
   return Math.abs(o.x - s.x) > n || Math.abs(o.y - s.y) > n;
 }
-const Me = (e) => e != null && e.length ? $(...(e == null ? void 0 : e.map(({ start$: t }) => t)) ?? []) : _, Ae = (e, t, n) => {
-  const s = e > 0 ? t / e : 0, o = e > 0 ? n / e : 0;
+const Te = (t) => t != null && t.length ? A(...(t == null ? void 0 : t.map(({ start$: e }) => e)) ?? []) : K, xe = (t, e, n) => {
+  const s = t > 0 ? e / t : 0, o = t > 0 ? n / t : 0;
   return {
     velocityX: s,
     velocityY: o
   };
 };
-class V {
-  constructor(t) {
-    D(this, "config$", new ae({}));
-    D(this, "validConfig$", this.config$.pipe(
-      d(
-        (t) => !!t.container
+class C {
+  constructor(e) {
+    m(this, "config$", new le({}));
+    m(this, "validConfig$", this.config$.pipe(
+      v(
+        (e) => !!e.container
       )
     ));
-    this.update(t);
+    this.update(e);
   }
-  initialize(t) {
+  initialize(e) {
     const n = this.config$.getValue();
     this.config$.next({
       ...n,
-      ...t,
+      ...e,
       options: {
         ...n.options,
-        ...t.options
+        ...e.options
       }
     });
   }
-  update(t) {
+  update(e) {
     const n = this.config$.getValue();
     this.config$.next({
       ...n,
       options: {
         ...n.options,
-        ...t
+        ...e
       }
     });
   }
 }
-const B = (e, t, n, s) => {
-  const o = e.x - t.x + n, r = e.y - t.y + s;
+const J = (t, e, n, s) => {
+  const o = t.x - e.x + n, r = t.y - e.y + s;
   return {
     deltaX: o,
     deltaY: r
   };
-}, Q = (e) => {
-  const t = (n) => R(
+}, W = (t) => {
+  const e = (n) => b(
     n.latestActivePointers.length ? n.latestActivePointers : [n.event]
   );
-  return e.pipe(
-    G(
+  return t.pipe(
+    F(
       (n, s) => {
-        var v, f;
-        const o = t(s), r = n.center, i = n.deltaX, p = n.deltaY, a = ((v = n.latestActivePointers) == null ? void 0 : v.length) ?? 0, h = ((f = s.latestActivePointers) == null ? void 0 : f.length) ?? 0, c = [
+        var y, w;
+        const o = e(s), r = n.center, p = n.deltaX, l = n.deltaY, a = ((y = n.latestActivePointers) == null ? void 0 : y.length) ?? 0, $ = ((w = s.latestActivePointers) == null ? void 0 : w.length) ?? 0, c = [
           "pointerdown",
           "pointercancel",
           "pointerleave",
           "pointerup"
-        ].includes(s.event.type) && a !== h, m = h > 0, { deltaX: y, deltaY: w } = c && m ? B(o, o, i, p) : B(o, r, i, p), { degreesDelta: M } = a === h && a >= 2 && h >= 2 ? ye(
+        ].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(
           n.latestActivePointers ?? [],
           s.latestActivePointers ?? []
         ) : { degreesDelta: 0 };
@@ -125,9 +125,9 @@ const B = (e, t, n, s) => {
           ...n,
           ...s,
           center: o,
-          deltaX: y,
-          deltaY: w,
-          deltaPointersAngle: M
+          deltaX: g,
+          deltaY: d,
+          deltaPointersAngle: f
         };
       },
       {
@@ -137,369 +137,509 @@ const B = (e, t, n, s) => {
         latestActivePointers: []
       }
     ),
-    u((n) => {
+    h((n) => {
       const {
         deltaX: s,
         deltaY: o,
         latestActivePointers: r,
-        startTime: i,
-        center: p,
+        startTime: p,
+        center: l,
         event: a,
-        deltaPointersAngle: h
-      } = n, c = r ?? [], y = Date.now() - i, { velocityX: w, velocityY: M } = Ae(y, s, o), v = fe(r);
+        deltaPointersAngle: $
+      } = n, c = r ?? [], g = Date.now() - p, { velocityX: d, velocityY: f } = xe(g, s, o), y = ye(r);
       return {
         deltaX: s,
         deltaY: o,
-        velocityX: w,
-        velocityY: M,
-        delay: y,
-        center: p,
+        velocityX: d,
+        velocityY: f,
+        delay: g,
+        center: l,
         pointers: c,
-        startTime: i,
+        startTime: p,
         event: a,
-        deltaPointersAngle: h,
-        pointersAverageDistance: v
+        deltaPointersAngle: $,
+        pointersAverageDistance: y
       };
     })
   );
 };
-function F(e) {
-  return (t) => t.pipe(
-    d((n) => n.pointerId === e.pointerId)
+function U(t) {
+  return (e) => e.pipe(
+    v((n) => n.pointerId === t.pointerId)
   );
 }
-const L = ({
-  container: e,
-  afterEventReceived: t = (n) => n
+const N = ({
+  container: t,
+  afterEventReceived: e = (n) => n
 }) => {
-  const n = Z({ afterEventReceived: t, container: e }), s = T(e, "pointerup").pipe(
-    u(t)
-  ), o = T(e, "pointermove").pipe(
-    u(t)
-  ), r = T(e, "pointerleave").pipe(
-    u(t)
-  ), i = T(
-    e,
+  const n = ee({ afterEventReceived: e, container: t }), s = I(t, "pointerup").pipe(
+    h(e)
+  ), o = I(t, "pointermove").pipe(
+    h(e)
+  ), r = I(t, "pointerleave").pipe(
+    h(e)
+  ), p = I(
+    t,
     "pointercancel"
-  ).pipe(u(t));
+  ).pipe(h(e));
   return {
     pointerDown$: n,
-    pointerCancel$: i,
+    pointerCancel$: p,
     pointerLeave$: r,
     pointerUp$: s,
     pointerMove$: o
   };
-}, Z = ({
-  container: e,
-  afterEventReceived: t = (n) => n
-}) => T(e, "pointerdown").pipe(
-  u(t)
-), U = ({
-  pointerCancel$: e,
-  pointerLeave$: t,
+}, ee = ({
+  container: t,
+  afterEventReceived: e = (n) => n
+}) => I(t, "pointerdown").pipe(
+  h(e)
+), V = ({
+  pointerCancel$: t,
+  pointerLeave$: e,
   pointerUp$: n,
   pointerMove$: s,
   trackMove: o
 }) => (r) => r.pipe(
-  X((i) => {
-    const p = $(
+  T((p) => {
+    const l = A(
       n,
-      t,
-      e
-    ).pipe(F(i)), a = ce(() => S(i));
-    return $(
+      e,
+      t
+    ).pipe(U(p)), a = ge(() => q(p));
+    return A(
       a,
-      o ? s : _
+      o ? s : K
     ).pipe(
-      F(i),
-      u((c) => ({ id: c.pointerId, event: c })),
-      I(p),
-      le({ id: i.pointerId, event: void 0 })
+      U(p),
+      h((c) => ({ id: c.pointerId, event: c })),
+      x(l),
+      he({ id: p.pointerId, event: void 0 })
     );
   }),
-  G(
-    (i, { event: p, id: a }) => {
-      if (!p) {
-        const { [a]: h, ...c } = i;
+  F(
+    (p, { event: l, id: a }) => {
+      if (!l) {
+        const { [a]: $, ...c } = p;
         return c;
       }
       return {
-        ...i,
-        [a]: p
+        ...p,
+        [a]: l
       };
     },
     {}
   ),
-  u((i) => Object.values(i).filter(we))
+  h((p) => Object.values(p).filter(we))
 );
-class xe extends V {
+class B extends C {
   constructor(n = {}) {
     super(n);
-    D(this, "events$");
-    D(this, "start$");
-    D(this, "end$");
-    D(this, "fingers$");
+    m(this, "events$");
+    m(this, "start$");
+    m(this, "end$");
+    m(this, "fingers$");
     this.options = n, this.events$ = this.validConfig$.pipe(
-      b((s) => {
-        const { container: o, afterEventReceived: r } = s, { posThreshold: i = 15 } = s.options ?? {}, {
-          pointerCancel$: p,
+      R((s) => {
+        const { container: o, afterEventReceived: r } = s, { posThreshold: p = 15 } = s.options ?? {}, {
+          pointerCancel$: l,
           pointerDown$: a,
-          pointerLeave$: h,
+          pointerLeave$: $,
           pointerMove$: c,
-          pointerUp$: m
-        } = L({
+          pointerUp$: i
+        } = N({
           container: o,
           afterEventReceived: r
         });
         return a.pipe(
-          N((y) => {
-            const w = $(
-              S(y),
+          j((g) => {
+            const d = A(
+              q(g),
               a
-            ), M = $(
-              p,
+            ), f = A(
+              l,
               a,
-              h,
+              $,
               c,
-              m
-            ), v = w.pipe(
-              U({
-                pointerCancel$: p,
-                pointerLeave$: h,
-                pointerUp$: m,
+              i
+            ), y = d.pipe(
+              V({
+                pointerCancel$: l,
+                pointerLeave$: $,
+                pointerUp$: i,
                 pointerMove$: c,
                 trackMove: !0
               }),
-              H()
-            ), f = $(
-              m,
-              h,
-              p
+              Q()
+            ), w = A(
+              i,
+              $,
+              l
             ).pipe(
-              Y(v),
-              d(([l, g]) => !g.length),
-              u(([l]) => l),
-              O(),
-              A()
-            ), x = w.pipe(
-              X(
-                (l) => c.pipe(
-                  F(l),
+              Y(y),
+              v(([u, D]) => !D.length),
+              h(([u]) => u),
+              z(),
+              P()
+            ), O = d.pipe(
+              T(
+                (u) => c.pipe(
+                  U(u),
                   // we start pan only if the user started moving a certain distance
-                  d(
-                    (g) => K(
-                      l,
-                      g,
-                      i
+                  v(
+                    (D) => Z(
+                      u,
+                      D,
+                      p
                     )
                   )
                 )
               ),
-              O()
+              z()
             ).pipe(
-              u(() => ({
+              h(() => ({
                 type: "panStart",
-                event: y
+                event: g
               })),
-              A(),
-              I(f)
-            ), C = x.pipe(
-              X(
-                () => f.pipe(
-                  u((l) => ({
+              P(),
+              x(w)
+            ), k = O.pipe(
+              T(
+                () => w.pipe(
+                  h((u) => ({
                     type: "panEnd",
-                    event: l
+                    event: u
                   }))
                 )
               )
-            ), k = M.pipe(
-              ue(x),
-              u((l) => ({
+            ), L = f.pipe(
+              $e(O),
+              h((u) => ({
                 type: "panMove",
-                event: l
+                event: u
               })),
-              I(f)
-            ), E = $(x, k, C).pipe(
-              Y(v),
-              u(([l, g]) => ({
-                ...l,
-                latestActivePointers: g
+              x(w)
+            ), X = A(O, L, k).pipe(
+              Y(y),
+              h(([u, D]) => ({
+                ...u,
+                latestActivePointers: D
               })),
-              A()
+              P()
             );
-            return J([
-              E.pipe(Q),
-              E
+            return S([
+              X.pipe(W),
+              X
             ]).pipe(
-              u(([l, { type: g }]) => ({
-                ...l,
-                type: g
+              h(([u, { type: D }]) => ({
+                ...u,
+                type: D
               }))
             );
           })
         );
       }),
-      A()
+      P()
     ), this.start$ = this.events$.pipe(
-      d((s) => s.type === "panStart")
-    ), this.end$ = this.events$.pipe(d((s) => s.type === "panEnd")), this.fingers$ = this.validConfig$.pipe(
-      b(({ container: s, afterEventReceived: o }) => {
-        const r = L({
+      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
         });
         return r.pointerDown$.pipe(
-          U({
+          V({
             ...r,
             trackMove: !1
           })
         );
       }),
-      u((s) => s.length)
+      h((s) => s.length)
     );
   }
 }
-const Te = (e) => (t) => t.pipe(
-  d((n) => Math.abs(n.velocityX) >= e || Math.abs(n.velocityY) >= e)
+const Re = (t) => (e) => e.pipe(
+  v((n) => Math.abs(n.velocityX) >= t || Math.abs(n.velocityY) >= t)
 );
-class Oe extends V {
+class Ie extends C {
   constructor(n = {}) {
     super(n);
-    D(this, "events$");
+    m(this, "events$");
     this.options = n, this.events$ = this.validConfig$.pipe(
-      b((s) => {
-        const { escapeVelocity: o = 0.9, posThreshold: r } = s.options ?? {}, i = new xe({ posThreshold: r });
-        i.initialize(s);
-        const p = i.events$.pipe(
-          d(({ pointers: a }) => a.length > 1)
+      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 i.start$.pipe(
-          N((a) => i.end$.pipe(
-            O(),
-            Te(o),
-            u(({ type: h, ...c }) => ({
+        return p.start$.pipe(
+          j((a) => p.end$.pipe(
+            z(),
+            Re(o),
+            h(({ type: $, ...c }) => ({
               type: "swipe",
-              angle: me(
+              angle: De(
                 a.event,
                 c.event
               ),
               ...c
             })),
-            I(p)
+            x(l)
           )),
-          A()
+          P()
         );
       })
     );
   }
 }
-class Re extends V {
+class be extends C {
   constructor(n) {
     super(n);
-    D(this, "events$");
+    m(this, "events$");
     this.options = n, this.events$ = this.validConfig$.pipe(
-      b((s) => {
+      R((s) => {
         const { container: o, afterEventReceived: r } = s, {
-          multiTapThreshold: i = 200,
-          maximumPressTime: p = 250,
+          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: h = 10,
+          posThreshold: $ = 10,
           failWith: c
-        } = s.options ?? {}, { pointerUp$: m, pointerLeave$: y, pointerCancel$: w, pointerMove$: M } = L({
+        } = s.options ?? {}, { pointerUp$: i, pointerLeave$: g, pointerCancel$: d, pointerMove$: f } = N({
           container: o,
           afterEventReceived: r
-        }), v = Z({ container: o, afterEventReceived: r }), f = v.pipe(
-          U({
-            pointerCancel$: w,
-            pointerLeave$: y,
-            pointerMove$: M,
-            pointerUp$: m,
+        }), y = ee({ container: o, afterEventReceived: r }), w = y.pipe(
+          V({
+            pointerCancel$: d,
+            pointerLeave$: g,
+            pointerMove$: f,
+            pointerUp$: i,
             trackMove: !1
           }),
-          H(1)
-        ), q = f.pipe(
-          d((l) => l.length > 1)
-        ), x = (l) => l.pipe(
-          Y(f),
-          d(([, g]) => g.length === 1),
-          u(([g]) => g)
-        ), C = (l) => l.pipe(
-          de(m.pipe($e(i))),
-          O()
-        ), k = Me(c);
-        return $(
-          v,
-          f.pipe(he())
+          Q(1)
+        ), G = w.pipe(
+          v((u) => u.length > 1)
+        ), O = (u) => u.pipe(
+          Y(w),
+          v(([, D]) => D.length === 1),
+          h(([D]) => D)
+        ), k = (u) => u.pipe(
+          ve(i.pipe(fe(p))),
+          z()
+        ), L = Te(c);
+        return A(
+          y,
+          w.pipe(ue())
         ).pipe(
-          x,
-          N((l) => {
-            const g = $(S(l), v), W = $(
-              m,
-              y,
-              w,
-              M
-            ), ee = g.pipe(C), te = W.pipe(
-              d(
-                (P) => K(
-                  l,
-                  P,
-                  h
+          O,
+          j((u) => {
+            const D = A(q(u), y), te = A(
+              i,
+              g,
+              d,
+              f
+            ), ne = D.pipe(k), se = te.pipe(
+              v(
+                (M) => Z(
+                  u,
+                  M,
+                  $
                 )
               ),
-              O()
-            ), ne = f.pipe(
-              b(() => ge(p))
-            ), se = $(
-              k,
-              w,
-              q,
-              te,
-              ne
-            ), j = ee.pipe(
-              De,
-              d((P) => P.length <= a),
-              u((P) => ({
+              z()
+            ), oe = w.pipe(
+              R(() => de(l))
+            ), ie = A(
+              L,
+              d,
+              G,
+              se,
+              oe
+            ), H = ne.pipe(
+              Pe,
+              v((M) => M.length <= a),
+              h((M) => ({
                 type: "tap",
-                taps: P.length,
-                latestActivePointers: P,
-                event: P[0]
+                taps: M.length,
+                latestActivePointers: M,
+                event: M[0]
               }))
             );
-            return J([
-              j.pipe(Q),
-              j
+            return S([
+              H.pipe(W),
+              H
             ]).pipe(
-              u(([P, { type: oe, taps: ie }]) => ({
-                ...P,
-                type: oe,
-                taps: ie
+              h(([M, { type: re, taps: pe }]) => ({
+                ...M,
+                type: re,
+                taps: pe
               })),
-              I(se)
+              x(ie)
             );
           })
         );
       }),
-      A()
+      P()
     );
   }
 }
-const Ce = ({
-  afterEventReceived: e = (n) => n,
-  recognizers: t
-}) => ({ events$: $(
-  ...t.map((o) => o.events$)
-).pipe(A()), initialize: (o) => {
-  o.style.touchAction = "none", o.style.userSelect = "none", t.forEach((r) => {
-    r.initialize({ container: o, afterEventReceived: e });
+class Ce extends C {
+  constructor(n = {}) {
+    super(n);
+    m(this, "events$");
+    this.options = n, 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),
+          E()
+        ), a = r.events$.pipe(
+          h((i) => [i, i.pointers.length > 1]),
+          E(
+            ([i, g], [d, f]) => g === f
+          ),
+          v(([i, g]) => g)
+        ).pipe(
+          h(([i]) => ({
+            ...i,
+            type: "rotateStart",
+            angle: 0,
+            deltaAngle: 0
+          }))
+        ), $ = a.pipe(
+          T(
+            () => r.events$.pipe(
+              F(
+                (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(
+              z(),
+              h(([i]) => ({
+                ...i,
+                type: "rotateEnd"
+              }))
+            )
+          )
+        );
+        return A(a, $, c);
+      })
+    );
+  }
+}
+class Ee extends C {
+  constructor(n = {}) {
+    super(n);
+    m(this, "events$");
+    this.options = n, 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),
+          E()
+        ), a = r.events$.pipe(
+          h((i) => [i, i.pointers.length > 1]),
+          E(
+            ([i, g], [d, f]) => g === f
+          ),
+          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(
+            F(
+              (g, d) => {
+                const f = g.pointersAverageDistance ?? d.pointersAverageDistance, y = d.pointersAverageDistance / i.pointersAverageDistance;
+                return {
+                  ...g,
+                  ...d,
+                  scale: y,
+                  distance: d.pointersAverageDistance - i.pointersAverageDistance,
+                  deltaDistance: d.pointersAverageDistance - f,
+                  deltaDistanceScale: d.pointersAverageDistance / f,
+                  type: "pinchMove"
+                };
+              },
+              { scale: 0 }
+            ),
+            x(p)
+          ))
+        ), c = a.pipe(
+          T(
+            () => S([$, p]).pipe(
+              z(),
+              h(([i]) => ({
+                ...i,
+                type: "pinchEnd"
+              }))
+            )
+          )
+        );
+        return A(a, $, c);
+      })
+    );
+  }
+}
+class Fe {
+  constructor(e) {
+    m(this, "events$");
+    m(this, "recognizers");
+    this.options = e, this.recognizers = e.recognizers, this.events$ = A(
+      ...e.recognizers.map((n) => n.events$)
+    ).pipe(P());
+  }
+  initialize(e) {
+    e.style.touchAction = "none", e.style.userSelect = "none", this.options.recognizers.forEach((n) => {
+      n.initialize({
+        container: e,
+        afterEventReceived: this.options.afterEventReceived
+      });
+    });
+  }
+}
+const Se = ({
+  afterEventReceived: t = (n) => n,
+  recognizers: e
+}) => ({ events$: A(
+  ...e.map((o) => o.events$)
+).pipe(P()), initialize: (o) => {
+  o.style.touchAction = "none", o.style.userSelect = "none", e.forEach((r) => {
+    r.initialize({ container: o, afterEventReceived: t });
   });
-}, recognizers: t });
+}, recognizers: e });
 export {
-  xe as PanRecognizer,
-  Oe as SwipeRecognizer,
-  Re as TapRecognizer,
-  Ce as createManager
+  Fe as Manager,
+  B as PanRecognizer,
+  Ee as PinchRecognizer,
+  Ce as RotateRecognizer,
+  Ie as SwipeRecognizer,
+  be as TapRecognizer,
+  Se as createManager
 };
 //# sourceMappingURL=index.js.map