gesturx 1.0.0 → 1.1.0

package/dist/index.js

@@ -0,0 +1,505 @@
+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) {
+  return Math.sqrt(
+    Math.pow(t.x - e.x, 2) + Math.pow(t.y - e.y, 2)
+  );
+}
+function fe(e) {
+  const t = e.length;
+  if (t < 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;
+  return n / s;
+}
+function z(e, t) {
+  const n = t.x - e.x, s = t.y - e.y;
+  return Math.atan2(s, n);
+}
+function me(e, t) {
+  return z(e, t) * (180 / Math.PI);
+}
+function R(e) {
+  const t = e.reduce(
+    (s, o) => (s.x += o.x, s.y += o.y, s),
+    { x: 0, y: 0 }
+  ), n = e.length || 1;
+  return {
+    x: t.x / n,
+    y: t.y / n
+  };
+}
+function ye(e, t) {
+  if (e.length !== t.length)
+    throw new Error("Initial and new points arrays must have the same length.");
+  const n = R(e), s = R(t);
+  let o = 0;
+  for (let p = 0; p < e.length; p++) {
+    const a = z(
+      n,
+      e[p]
+    );
+    let c = z(
+      s,
+      t[p]
+    ) - 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 };
+}
+function we(e) {
+  return e != 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]);
+  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;
+  return {
+    velocityX: s,
+    velocityY: o
+  };
+};
+class V {
+  constructor(t) {
+    D(this, "config$", new ae({}));
+    D(this, "validConfig$", this.config$.pipe(
+      d(
+        (t) => !!t.container
+      )
+    ));
+    this.update(t);
+  }
+  initialize(t) {
+    const n = this.config$.getValue();
+    this.config$.next({
+      ...n,
+      ...t,
+      options: {
+        ...n.options,
+        ...t.options
+      }
+    });
+  }
+  update(t) {
+    const n = this.config$.getValue();
+    this.config$.next({
+      ...n,
+      options: {
+        ...n.options,
+        ...t
+      }
+    });
+  }
+}
+const B = (e, t, n, s) => {
+  const o = e.x - t.x + n, r = e.y - t.y + s;
+  return {
+    deltaX: o,
+    deltaY: r
+  };
+}, Q = (e) => {
+  const t = (n) => R(
+    n.latestActivePointers.length ? n.latestActivePointers : [n.event]
+  );
+  return e.pipe(
+    G(
+      (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 = [
+          "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(
+          n.latestActivePointers ?? [],
+          s.latestActivePointers ?? []
+        ) : { degreesDelta: 0 };
+        return {
+          startTime: (/* @__PURE__ */ new Date()).getTime(),
+          ...n,
+          ...s,
+          center: o,
+          deltaX: y,
+          deltaY: w,
+          deltaPointersAngle: M
+        };
+      },
+      {
+        deltaX: 0,
+        deltaY: 0,
+        center: { x: 0, y: 0 },
+        latestActivePointers: []
+      }
+    ),
+    u((n) => {
+      const {
+        deltaX: s,
+        deltaY: o,
+        latestActivePointers: r,
+        startTime: i,
+        center: p,
+        event: a,
+        deltaPointersAngle: h
+      } = n, c = r ?? [], y = Date.now() - i, { velocityX: w, velocityY: M } = Ae(y, s, o), v = fe(r);
+      return {
+        deltaX: s,
+        deltaY: o,
+        velocityX: w,
+        velocityY: M,
+        delay: y,
+        center: p,
+        pointers: c,
+        startTime: i,
+        event: a,
+        deltaPointersAngle: h,
+        pointersAverageDistance: v
+      };
+    })
+  );
+};
+function F(e) {
+  return (t) => t.pipe(
+    d((n) => n.pointerId === e.pointerId)
+  );
+}
+const L = ({
+  container: e,
+  afterEventReceived: t = (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,
+    "pointercancel"
+  ).pipe(u(t));
+  return {
+    pointerDown$: n,
+    pointerCancel$: i,
+    pointerLeave$: r,
+    pointerUp$: s,
+    pointerMove$: o
+  };
+}, Z = ({
+  container: e,
+  afterEventReceived: t = (n) => n
+}) => T(e, "pointerdown").pipe(
+  u(t)
+), U = ({
+  pointerCancel$: e,
+  pointerLeave$: t,
+  pointerUp$: n,
+  pointerMove$: s,
+  trackMove: o
+}) => (r) => r.pipe(
+  X((i) => {
+    const p = $(
+      n,
+      t,
+      e
+    ).pipe(F(i)), a = ce(() => S(i));
+    return $(
+      a,
+      o ? s : _
+    ).pipe(
+      F(i),
+      u((c) => ({ id: c.pointerId, event: c })),
+      I(p),
+      le({ id: i.pointerId, event: void 0 })
+    );
+  }),
+  G(
+    (i, { event: p, id: a }) => {
+      if (!p) {
+        const { [a]: h, ...c } = i;
+        return c;
+      }
+      return {
+        ...i,
+        [a]: p
+      };
+    },
+    {}
+  ),
+  u((i) => Object.values(i).filter(we))
+);
+class xe extends V {
+  constructor(n = {}) {
+    super(n);
+    D(this, "events$");
+    D(this, "start$");
+    D(this, "end$");
+    D(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,
+          pointerDown$: a,
+          pointerLeave$: h,
+          pointerMove$: c,
+          pointerUp$: m
+        } = L({
+          container: o,
+          afterEventReceived: r
+        });
+        return a.pipe(
+          N((y) => {
+            const w = $(
+              S(y),
+              a
+            ), M = $(
+              p,
+              a,
+              h,
+              c,
+              m
+            ), v = w.pipe(
+              U({
+                pointerCancel$: p,
+                pointerLeave$: h,
+                pointerUp$: m,
+                pointerMove$: c,
+                trackMove: !0
+              }),
+              H()
+            ), f = $(
+              m,
+              h,
+              p
+            ).pipe(
+              Y(v),
+              d(([l, g]) => !g.length),
+              u(([l]) => l),
+              O(),
+              A()
+            ), x = w.pipe(
+              X(
+                (l) => c.pipe(
+                  F(l),
+                  // we start pan only if the user started moving a certain distance
+                  d(
+                    (g) => K(
+                      l,
+                      g,
+                      i
+                    )
+                  )
+                )
+              ),
+              O()
+            ).pipe(
+              u(() => ({
+                type: "panStart",
+                event: y
+              })),
+              A(),
+              I(f)
+            ), C = x.pipe(
+              X(
+                () => f.pipe(
+                  u((l) => ({
+                    type: "panEnd",
+                    event: l
+                  }))
+                )
+              )
+            ), k = M.pipe(
+              ue(x),
+              u((l) => ({
+                type: "panMove",
+                event: l
+              })),
+              I(f)
+            ), E = $(x, k, C).pipe(
+              Y(v),
+              u(([l, g]) => ({
+                ...l,
+                latestActivePointers: g
+              })),
+              A()
+            );
+            return J([
+              E.pipe(Q),
+              E
+            ]).pipe(
+              u(([l, { type: g }]) => ({
+                ...l,
+                type: g
+              }))
+            );
+          })
+        );
+      }),
+      A()
+    ), 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({
+          container: s,
+          afterEventReceived: o
+        });
+        return r.pointerDown$.pipe(
+          U({
+            ...r,
+            trackMove: !1
+          })
+        );
+      }),
+      u((s) => s.length)
+    );
+  }
+}
+const Te = (e) => (t) => t.pipe(
+  d((n) => Math.abs(n.velocityX) >= e || Math.abs(n.velocityY) >= e)
+);
+class Oe extends V {
+  constructor(n = {}) {
+    super(n);
+    D(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)
+        );
+        return i.start$.pipe(
+          N((a) => i.end$.pipe(
+            O(),
+            Te(o),
+            u(({ type: h, ...c }) => ({
+              type: "swipe",
+              angle: me(
+                a.event,
+                c.event
+              ),
+              ...c
+            })),
+            I(p)
+          )),
+          A()
+        );
+      })
+    );
+  }
+}
+class Re extends V {
+  constructor(n) {
+    super(n);
+    D(this, "events$");
+    this.options = n, this.events$ = this.validConfig$.pipe(
+      b((s) => {
+        const { container: o, afterEventReceived: r } = s, {
+          multiTapThreshold: i = 200,
+          maximumPressTime: p = 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,
+          failWith: c
+        } = s.options ?? {}, { pointerUp$: m, pointerLeave$: y, pointerCancel$: w, pointerMove$: M } = L({
+          container: o,
+          afterEventReceived: r
+        }), v = Z({ container: o, afterEventReceived: r }), f = v.pipe(
+          U({
+            pointerCancel$: w,
+            pointerLeave$: y,
+            pointerMove$: M,
+            pointerUp$: m,
+            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())
+        ).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()
+            ), ne = f.pipe(
+              b(() => ge(p))
+            ), se = $(
+              k,
+              w,
+              q,
+              te,
+              ne
+            ), j = ee.pipe(
+              De,
+              d((P) => P.length <= a),
+              u((P) => ({
+                type: "tap",
+                taps: P.length,
+                latestActivePointers: P,
+                event: P[0]
+              }))
+            );
+            return J([
+              j.pipe(Q),
+              j
+            ]).pipe(
+              u(([P, { type: oe, taps: ie }]) => ({
+                ...P,
+                type: oe,
+                taps: ie
+              })),
+              I(se)
+            );
+          })
+        );
+      }),
+      A()
+    );
+  }
+}
+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 });
+  });
+}, recognizers: t });
+export {
+  xe as PanRecognizer,
+  Oe as SwipeRecognizer,
+  Re as TapRecognizer,
+  Ce as createManager
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/core/utils/geometry.ts","../src/core/utils/utils.ts","../src/core/recognizer/Recognizer.ts","../src/core/recognizer/mapToRecognizerEvent.ts","../src/core/utils/events.ts","../src/core/pan/PanRecognizer.ts","../src/core/swipe/isRecognizedAsSwipe.ts","../src/core/swipe/SwipeRecognizer.ts","../src/core/tap/TapRecognizer.ts","../src/core/manager.ts"],"sourcesContent":["type Point = { x: number; y: number }\n\nexport function calculateDistance(pointA: Point, pointB: Point): number {\n  return Math.sqrt(\n    Math.pow(pointB.x - pointA.x, 2) + Math.pow(pointB.y - pointA.y, 2),\n  )\n}\n\nexport function calculateAverageDistance(pointerEvents: Point[]): number {\n  const n = pointerEvents.length\n  if (n < 2) return 0 // No distance if fewer than 2 pointers\n\n  const totalDistance = pointerEvents.reduce((sum, event1, i) => {\n    return (\n      sum +\n      pointerEvents.slice(i + 1).reduce((innerSum, event2) => {\n        return innerSum + calculateDistance(event1, event2)\n      }, 0)\n    )\n  }, 0)\n\n  // Number of pairs is n choose 2: n * (n - 1) / 2\n  const numberOfPairs = (n * (n - 1)) / 2\n  return totalDistance / numberOfPairs\n}\n\nexport function calculateRadianAngleBetweenPoints(\n  pointerA: Point,\n  pointerB: Point,\n): number {\n  // Calculate the differences in coordinates\n  const deltaX = pointerB.x - pointerA.x\n  const deltaY = pointerB.y - pointerA.y\n\n  // Calculate the angle in radians\n  const angleInRadians = Math.atan2(deltaY, deltaX)\n\n  // Return the angle in degrees\n  return angleInRadians\n}\n\nexport function calculateDegreeAngleBetweenPoints(\n  pointerA: Point,\n  pointerB: Point,\n): number {\n  // Calculate the angle in radians\n  const angleInRadians = calculateRadianAngleBetweenPoints(pointerA, pointerB)\n\n  // Convert the angle to degrees (optional)\n  const angleInDegrees = angleInRadians * (180 / Math.PI)\n\n  // Return the angle in degrees\n  return angleInDegrees\n}\n\nexport function calculateCentroid(points: Point[]) {\n  const sum = points.reduce(\n    (acc, point) => {\n      acc.x += point.x\n      acc.y += point.y\n\n      return acc\n    },\n    { x: 0, y: 0 },\n  )\n\n  const numPoints = points.length || 1\n\n  return {\n    x: sum.x / numPoints,\n    y: sum.y / numPoints,\n  }\n}\n\nexport function calculateAngleDelta(\n  initialPoints: Point[],\n  newPoints: Point[],\n) {\n  if (initialPoints.length !== newPoints.length) {\n    throw new Error(\"Initial and new points arrays must have the same length.\")\n  }\n\n  const initialCentroid = calculateCentroid(initialPoints)\n  const newCentroid = calculateCentroid(newPoints)\n\n  let totalAngleDelta = 0\n\n  for (let i = 0; i < initialPoints.length; i++) {\n    const initialAngle = calculateRadianAngleBetweenPoints(\n      initialCentroid,\n      initialPoints[i]!,\n    )\n    const newAngle = calculateRadianAngleBetweenPoints(\n      newCentroid,\n      newPoints[i]!,\n    )\n\n    let angleDelta = newAngle - initialAngle\n\n    // Normalize the angle delta to be within [-PI, PI]\n    if (angleDelta > Math.PI) {\n      angleDelta -= 2 * Math.PI\n    } else if (angleDelta < -Math.PI) {\n      angleDelta += 2 * Math.PI\n    }\n\n    totalAngleDelta += angleDelta\n  }\n\n  // Return the average angle delta\n  const radianDelta = totalAngleDelta / initialPoints.length\n  const degreesDelta = radianDelta * (180 / Math.PI)\n\n  return { radianDelta, degreesDelta }\n}\n","import {\n  NEVER,\n  Observable,\n  filter,\n  merge,\n} from \"rxjs\"\nimport { calculateCentroid } from \"./geometry\"\n\nexport function isDefined<T>(\n  arg: T | null | undefined,\n): arg is T extends null | undefined ? never : T {\n  return arg !== null && arg !== undefined\n}\n\nexport const hasAtLeastOneItem = <T>(events: T[]): events is [T, ...T[]] =>\n  events.length > 0\n\nexport const filterNotEmpty = <T>(\n  stream: Observable<T[]>,\n): Observable<[T, ...T[]]> => stream.pipe(filter(hasAtLeastOneItem))\n\nexport function isOutsidePosThreshold(\n  startEvent: PointerEvent,\n  endEvent: PointerEvent,\n  posThreshold: number,\n) {\n  const start = calculateCentroid([startEvent])\n  const end = calculateCentroid([endEvent])\n\n  // Determines if the movement qualifies as a drag\n  return (\n    Math.abs(end.x - start.x) > posThreshold ||\n    Math.abs(end.y - start.y) > posThreshold\n  )\n}\n\nexport const fromFailWith = (failWith?: { start$: Observable<unknown> }[]) =>\n  !failWith?.length\n    ? NEVER\n    : merge(...(failWith?.map(({ start$ }) => start$) ?? []))\n\n/**\n * Avoid division by zero\n * Calculate velocity in pixels per second\n */\nexport const calculateVelocity = (\n  delay: number,\n  deltaX: number,\n  deltaY: number,\n) => {\n  const velocityX = delay > 0 ? deltaX / delay : 0\n  const velocityY = delay > 0 ? deltaY / delay : 0\n\n  return {\n    velocityX,\n    velocityY,\n  }\n}\n","import { BehaviorSubject, Observable, filter } from \"rxjs\"\n\ntype RecognizerConfig<Options> = {\n  container?: HTMLElement\n  afterEventReceived?: (event: PointerEvent) => PointerEvent\n  options?: Options\n}\n\ntype ValidRecognizerConfig<Options> = Required<\n  Pick<RecognizerConfig<Options>, \"container\">\n> &\n  RecognizerConfig<Options>\n\nexport interface RecognizerOptions {\n  failWith?: { start$: Observable<unknown> }[]\n}\n\nexport class Recognizer<Options> {\n  protected config$ = new BehaviorSubject<RecognizerConfig<Options>>({})\n  protected validConfig$ = this.config$.pipe(\n    filter(\n      (config): config is ValidRecognizerConfig<Options> => !!config.container,\n    ),\n  )\n\n  constructor(options: Options) {\n    this.update(options)\n  }\n\n  public initialize(config: RecognizerConfig<Options>) {\n    const prevConfig = this.config$.getValue()\n\n    this.config$.next({\n      ...prevConfig,\n      ...config,\n      options: {\n        ...prevConfig.options,\n        ...config.options,\n      } as Options,\n    })\n  }\n\n  public update(options: Options) {\n    const config = this.config$.getValue()\n\n    this.config$.next({\n      ...config,\n      options: {\n        ...config.options,\n        ...options,\n      },\n    })\n  }\n}\n","import { Observable, map, scan } from \"rxjs\"\nimport { RecognizerEvent } from \"./RecognizerEvent\"\nimport { calculateVelocity } from \"../utils/utils\"\nimport {\n  calculateAngleDelta,\n  calculateAverageDistance,\n  calculateCentroid,\n} from \"../utils/geometry\"\n\nexport interface RecognizerEventInput {\n  event: PointerEvent\n  latestActivePointers: PointerEvent[]\n}\n\ninterface RecognizerEventState extends RecognizerEventInput {\n  startTime: number\n  center: { x: number; y: number }\n  deltaX: number\n  deltaY: number\n  deltaPointersAngle: number\n}\n\nconst calculateNewDelta = (\n  newCenter: { x: number; y: number },\n  prevCenter: { x: number; y: number },\n  prevDeltaX: number,\n  prevDeltaY: number,\n) => {\n  const deltaX = newCenter.x - prevCenter.x + prevDeltaX\n  const deltaY = newCenter.y - prevCenter.y + prevDeltaY\n\n  return {\n    deltaX,\n    deltaY,\n  }\n}\n\nexport const mapToRecognizerEvent = <T extends RecognizerEventInput>(\n  stream: Observable<T>,\n): Observable<RecognizerEvent> => {\n  const getCenterFromData = (data: T) =>\n    calculateCentroid(\n      !data.latestActivePointers.length\n        ? [data.event]\n        : data.latestActivePointers,\n    )\n\n  return stream.pipe(\n    scan<\n      T,\n      RecognizerEventState,\n      Pick<\n        RecognizerEventState,\n        \"deltaX\" | \"center\" | \"deltaY\" | \"latestActivePointers\"\n      >\n    >(\n      (acc, curr) => {\n        const newCenter = getCenterFromData(curr)\n        const prevCenter = acc.center\n        const prevDeltaX = acc.deltaX\n        const prevDeltaY = acc.deltaY\n        const prevActivePointersNumber = acc.latestActivePointers?.length ?? 0\n        const currActivePointersNumber = curr.latestActivePointers?.length ?? 0\n\n        const hasAddedOrRemovedAFinger =\n          [\n            \"pointerdown\",\n            \"pointercancel\",\n            \"pointerleave\",\n            \"pointerup\",\n          ].includes(curr.event.type) &&\n          prevActivePointersNumber !== currActivePointersNumber\n        const hasAtLeastOneFinger = currActivePointersNumber > 0\n\n        const { deltaX, deltaY } =\n          hasAddedOrRemovedAFinger && hasAtLeastOneFinger\n            ? calculateNewDelta(newCenter, newCenter, prevDeltaX, prevDeltaY)\n            : calculateNewDelta(newCenter, prevCenter, prevDeltaX, prevDeltaY)\n\n        const { degreesDelta: deltaPointersAngle } =\n          prevActivePointersNumber === currActivePointersNumber &&\n          prevActivePointersNumber >= 2 &&\n          currActivePointersNumber >= 2\n            ? calculateAngleDelta(\n                acc.latestActivePointers ?? [],\n                curr.latestActivePointers ?? [],\n              )\n            : { degreesDelta: 0 }\n\n        return {\n          startTime: new Date().getTime(),\n          ...acc,\n          ...curr,\n          center: newCenter,\n          deltaX,\n          deltaY,\n          deltaPointersAngle,\n        }\n      },\n      {\n        deltaX: 0,\n        deltaY: 0,\n        center: { x: 0, y: 0 },\n        latestActivePointers: [],\n      },\n    ),\n    map((data) => {\n      const {\n        deltaX,\n        deltaY,\n        latestActivePointers,\n        startTime,\n        center,\n        event,\n        deltaPointersAngle,\n      } = data\n      const events = latestActivePointers ?? []\n\n      // Calculate the change in time\n      const now = Date.now()\n      const delay = now - startTime\n\n      const { velocityX, velocityY } = calculateVelocity(delay, deltaX, deltaY)\n      const pointersAverageDistance =\n        calculateAverageDistance(latestActivePointers)\n\n      return {\n        deltaX,\n        deltaY,\n        velocityX,\n        velocityY,\n        delay,\n        center,\n        pointers: events,\n        startTime,\n        event,\n        deltaPointersAngle,\n        pointersAverageDistance,\n      } satisfies RecognizerEvent\n    }),\n  )\n}\n","import {\n  NEVER,\n  Observable,\n  defer,\n  endWith,\n  filter,\n  fromEvent,\n  map,\n  merge,\n  mergeMap,\n  of,\n  scan,\n  takeUntil,\n} from \"rxjs\"\nimport { isDefined } from \"./utils\"\n\nexport function matchPointer(pointer: PointerEvent) {\n  return (stream: Observable<PointerEvent>) =>\n    stream.pipe(\n      filter((newPointer) => newPointer.pointerId === pointer.pointerId),\n    )\n}\n\nexport const getPointerEvents = ({\n  container,\n  afterEventReceived = (event) => event,\n}: {\n  container: HTMLElement\n  afterEventReceived?: (event: PointerEvent) => PointerEvent\n}) => {\n  const pointerDown$ = fromPointerDown({ afterEventReceived, container })\n  const pointerUp$ = fromEvent<PointerEvent>(container, \"pointerup\").pipe(\n    map(afterEventReceived),\n  )\n  const pointerMove$ = fromEvent<PointerEvent>(container, \"pointermove\").pipe(\n    map(afterEventReceived),\n  )\n  /**\n   * Mostly used to handle cursor leaving window on mouse pointers.\n   */\n  const pointerLeave$ = fromEvent<PointerEvent>(container, \"pointerleave\").pipe(\n    map(afterEventReceived),\n  )\n  /**\n   * Handle things such as contextual menu popup or\n   * native swipe navigation conflict.\n   */\n  const pointerCancel$ = fromEvent<PointerEvent>(\n    container,\n    \"pointercancel\",\n  ).pipe(map(afterEventReceived))\n\n  return {\n    pointerDown$,\n    pointerCancel$,\n    pointerLeave$,\n    pointerUp$,\n    pointerMove$,\n  }\n}\n\nexport const fromPointerDown = ({\n  container,\n  afterEventReceived = (event) => event,\n}: {\n  container: HTMLElement\n  afterEventReceived?: (event: PointerEvent) => PointerEvent\n}) =>\n  fromEvent<PointerEvent>(container, \"pointerdown\").pipe(\n    map(afterEventReceived),\n  )\n\n/**\n * @todo test the strict stability\n * @important\n * Stable function, will not emit if the pointers don't change\n */\nexport const trackActivePointers = ({\n  container,\n}: {\n  container: HTMLElement\n}) => {\n  const pointerUp$ = fromEvent<PointerEvent>(container, \"pointerup\")\n  const pointerLeave$ = fromEvent<PointerEvent>(container, \"pointerleave\")\n  const pointerCancel$ = fromEvent<PointerEvent>(container, \"pointercancel\")\n\n  return fromEvent<PointerEvent>(container, \"pointerdown\").pipe(\n    mergeMap((pointerDown) => {\n      const pointerDownRelease$ = merge(\n        pointerUp$,\n        pointerLeave$,\n        pointerCancel$,\n      ).pipe(matchPointer(pointerDown))\n      const pointerDown$ = defer(() => of(pointerDown))\n\n      return pointerDown$.pipe(\n        mergeMap(() => merge(pointerDown$, NEVER)),\n        map((event) => ({ id: event.pointerId, event })),\n        takeUntil(pointerDownRelease$),\n        endWith({ id: pointerDown.pointerId, event: undefined }),\n      )\n    }),\n    scan(\n      (acc, { event, id }) => {\n        if (!event) {\n          // eslint-disable-next-line @typescript-eslint/no-unused-vars\n          const { [id]: _deleted, ...rest } = acc\n\n          return rest\n        }\n\n        return {\n          ...acc,\n          [id]: event,\n        }\n      },\n      {} as Record<number, PointerEvent | undefined>,\n    ),\n    map((events) => Object.values(events).filter(isDefined)),\n  )\n}\n\n/**\n * Track all pointerEvent for active fingers\n */\nexport const trackFingers =\n  ({\n    pointerCancel$,\n    pointerLeave$,\n    pointerUp$,\n    pointerMove$,\n    trackMove,\n  }: {\n    pointerUp$: Observable<PointerEvent>\n    pointerLeave$: Observable<PointerEvent>\n    pointerCancel$: Observable<PointerEvent>\n    pointerMove$: Observable<PointerEvent>\n    /**\n     * Setting this value to false will not update the list\n     * on pointer move. Use it if you only need to track number of active\n     * fingers.\n     */\n    trackMove: boolean\n  }) =>\n  (stream: Observable<PointerEvent>) => {\n    return stream.pipe(\n      mergeMap((pointerDown) => {\n        const pointerDownRelease$ = merge(\n          pointerUp$,\n          pointerLeave$,\n          pointerCancel$,\n        ).pipe(matchPointer(pointerDown))\n\n        const pointerDown$ = defer(() => of(pointerDown))\n\n        const tracking$ = merge(\n          pointerDown$,\n          trackMove ? pointerMove$ : NEVER,\n        ).pipe(\n          matchPointer(pointerDown),\n          map((event) => ({ id: event.pointerId, event })),\n          takeUntil(pointerDownRelease$),\n          endWith({ id: pointerDown.pointerId, event: undefined }),\n        )\n\n        return tracking$\n      }),\n      scan(\n        (acc, { event, id }) => {\n          if (!event) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            const { [id]: _deleted, ...rest } = acc\n\n            return rest\n          }\n\n          return {\n            ...acc,\n            [id]: event,\n          }\n        },\n        {} as Record<number, PointerEvent | undefined>,\n      ),\n      map((events) => Object.values(events).filter(isDefined)),\n    )\n  }\n","import {\n  Observable,\n  combineLatest,\n  exhaustMap,\n  filter,\n  first,\n  map,\n  merge,\n  mergeMap,\n  of,\n  share,\n  shareReplay,\n  skipUntil,\n  switchMap,\n  takeUntil,\n  withLatestFrom,\n} from \"rxjs\"\nimport { isOutsidePosThreshold } from \"../utils/utils\"\nimport { Recognizer } from \"../recognizer/Recognizer\"\nimport { RecognizerEvent } from \"../recognizer/RecognizerEvent\"\nimport { mapToRecognizerEvent } from \"../recognizer/mapToRecognizerEvent\"\nimport { getPointerEvents, matchPointer, trackFingers } from \"../utils/events\"\n\nexport interface PanEvent extends RecognizerEvent {\n  type: \"panStart\" | \"panMove\" | \"panEnd\"\n}\n\ntype Options = {\n  posThreshold?: number\n}\n\nexport class PanRecognizer extends Recognizer<Options> {\n  public events$: Observable<PanEvent>\n  public start$: Observable<PanEvent>\n  public end$: Observable<PanEvent>\n  public fingers$: Observable<number>\n\n  constructor(protected options: Options = {}) {\n    super(options)\n\n    this.events$ = this.validConfig$.pipe(\n      switchMap((config) => {\n        const { container, afterEventReceived } = config\n        const { posThreshold = 15 } = config.options ?? {}\n        const {\n          pointerCancel$,\n          pointerDown$,\n          pointerLeave$,\n          pointerMove$,\n          pointerUp$,\n        } = getPointerEvents({\n          container,\n          afterEventReceived,\n        })\n\n        return pointerDown$.pipe(\n          exhaustMap((initialPointerDownEvent) => {\n            const pointerDowns$ = merge(\n              of(initialPointerDownEvent),\n              pointerDown$,\n            )\n\n            const pointerUpdate$ = merge(\n              pointerCancel$,\n              pointerDown$,\n              pointerLeave$,\n              pointerMove$,\n              pointerUp$,\n            )\n\n            const trackFingers$ = pointerDowns$.pipe(\n              trackFingers({\n                pointerCancel$,\n                pointerLeave$,\n                pointerUp$,\n                pointerMove$,\n                trackMove: true,\n              }),\n              shareReplay(),\n            )\n\n            /**\n             * We release when we detect a pointer leave and there are no more\n             * active fingers.\n             *\n             * @todo move to utils\n             */\n            const panReleased$ = merge(\n              pointerUp$,\n              pointerLeave$,\n              pointerCancel$,\n            ).pipe(\n              withLatestFrom(trackFingers$),\n              filter(([_, pointers]) => !pointers.length),\n              map(([event]) => event),\n              first(),\n              share(),\n            )\n\n            const firstPointerDownMovingOutOfThreshold$ = pointerDowns$.pipe(\n              mergeMap((pointerDown) =>\n                pointerMove$.pipe(\n                  matchPointer(pointerDown),\n                  // we start pan only if the user started moving a certain distance\n                  filter((pointerMoveEvent) =>\n                    isOutsidePosThreshold(\n                      pointerDown,\n                      pointerMoveEvent,\n                      posThreshold,\n                    ),\n                  ),\n                ),\n              ),\n              first(),\n            )\n\n            const panStart$ = firstPointerDownMovingOutOfThreshold$.pipe(\n              map(() => ({\n                type: \"panStart\" as const,\n                event: initialPointerDownEvent,\n              })),\n              share(),\n              takeUntil(panReleased$),\n            )\n\n            const panEnd$ = panStart$.pipe(\n              mergeMap(() =>\n                panReleased$.pipe(\n                  map((endEvent) => ({\n                    type: \"panEnd\" as const,\n                    event: endEvent,\n                  })),\n                ),\n              ),\n            )\n\n            const panUpdate$ = pointerUpdate$.pipe(\n              skipUntil(panStart$),\n              map((event) => ({\n                type: \"panMove\" as const,\n                event,\n              })),\n              takeUntil(panReleased$),\n            )\n\n            const rawEvent$ = merge(panStart$, panUpdate$, panEnd$).pipe(\n              withLatestFrom(trackFingers$),\n              map(([event, pointers]) => ({\n                ...event,\n                latestActivePointers: pointers,\n              })),\n              share(),\n            )\n\n            return combineLatest([\n              rawEvent$.pipe(mapToRecognizerEvent),\n              rawEvent$,\n            ]).pipe(\n              map(([recognizerEvent, { type }]) => ({\n                ...recognizerEvent,\n                type,\n              })),\n            )\n          }),\n        )\n      }),\n      share(),\n    )\n\n    this.start$ = this.events$.pipe(\n      filter((event) => event.type === \"panStart\"),\n    )\n    this.end$ = this.events$.pipe(filter((event) => event.type === \"panEnd\"))\n\n    this.fingers$ = this.validConfig$.pipe(\n      switchMap(({ container, afterEventReceived }) => {\n        const pointerEvents = getPointerEvents({\n          container,\n          afterEventReceived,\n        })\n\n        return pointerEvents.pointerDown$.pipe(\n          trackFingers({\n            ...pointerEvents,\n            trackMove: false,\n          }),\n        )\n      }),\n      map((events) => events.length),\n    )\n  }\n}\n","import { Observable, filter } from \"rxjs\"\nimport { PanEvent } from \"../pan/PanRecognizer\"\n\nexport const isRecognizedAsSwipe =\n  (escapeVelocity: number) => (stream: Observable<PanEvent>) =>\n    stream.pipe(\n      filter((event) => {\n        return (\n          Math.abs(event.velocityX) >= escapeVelocity ||\n          Math.abs(event.velocityY) >= escapeVelocity\n        )\n      }),\n    )\n","import {\n  Observable,\n  exhaustMap,\n  filter,\n  first,\n  map,\n  share,\n  switchMap,\n  takeUntil,\n} from \"rxjs\"\nimport { Recognizer } from \"../recognizer/Recognizer\"\nimport { PanRecognizer } from \"../pan/PanRecognizer\"\nimport { RecognizerEvent } from \"../recognizer/RecognizerEvent\"\nimport { calculateDegreeAngleBetweenPoints } from \"../utils/geometry\"\nimport { isRecognizedAsSwipe } from \"./isRecognizedAsSwipe\"\n\nexport interface SwipeEvent extends RecognizerEvent {\n  type: \"swipe\"\n  /**\n   * Angle between first pointer and last one in degree\n   *\n   *             (-90)\n   * (+/-180) <-   |   -> (+/-0)\n   *             (+90)\n   */\n  angle: number\n}\n\ntype Options = {\n  /**\n   * The minimum velocity (px/ms) that the gesture has to obtain by the end event.\n   */\n  escapeVelocity?: number\n  // @todo\n  numInputs?: number\n  // @todo\n  maxRestTime?: number\n  posThreshold?: number\n}\n\nexport class SwipeRecognizer extends Recognizer<Options> {\n  public events$: Observable<SwipeEvent>\n\n  constructor(protected options: Options = {}) {\n    super(options)\n\n    this.events$ = this.validConfig$.pipe(\n      switchMap((initializedWith) => {\n        const { escapeVelocity = 0.9, posThreshold } =\n          initializedWith.options ?? {}\n        const panRecognizer = new PanRecognizer({ posThreshold })\n\n        panRecognizer.initialize(initializedWith)\n\n        const hasMoreThanOneFinger$ = panRecognizer.events$.pipe(\n          filter(({ pointers }) => pointers.length > 1),\n        )\n\n        return panRecognizer.start$.pipe(\n          exhaustMap((startEvent) => {\n            return panRecognizer.end$.pipe(\n              first(),\n              isRecognizedAsSwipe(escapeVelocity),\n              map(({ type, ...rest }) => {\n                return {\n                  type: \"swipe\" as const,\n                  angle: calculateDegreeAngleBetweenPoints(\n                    startEvent.event,\n                    rest.event,\n                  ),\n                  ...rest,\n                }\n              }),\n              takeUntil(hasMoreThanOneFinger$),\n            )\n          }),\n          share(),\n        )\n      }),\n    )\n  }\n}\n","import {\n  Observable,\n  buffer,\n  combineLatest,\n  debounceTime,\n  exhaustMap,\n  filter,\n  first,\n  ignoreElements,\n  map,\n  merge,\n  of,\n  share,\n  shareReplay,\n  switchMap,\n  takeUntil,\n  timer,\n  withLatestFrom,\n} from \"rxjs\"\nimport {\n  fromFailWith,\n  filterNotEmpty,\n  isOutsidePosThreshold,\n} from \"../utils/utils\"\nimport { Recognizer, RecognizerOptions } from \"../recognizer/Recognizer\"\nimport { RecognizerEvent } from \"../recognizer/RecognizerEvent\"\nimport { mapToRecognizerEvent } from \"../recognizer/mapToRecognizerEvent\"\nimport {\n  fromPointerDown,\n  getPointerEvents,\n  trackFingers,\n} from \"../utils/events\"\n\nexport interface TapEvent extends RecognizerEvent {\n  type: \"tap\"\n  taps: number\n}\n\ninterface Options extends RecognizerOptions {\n  // Maximum time in ms between multiple taps.\n  multiTapThreshold?: number\n  // Maximum press time in ms.\n  maximumPressTime?: number\n  maxTaps?: number\n  posThreshold?: number\n}\n\nexport class TapRecognizer extends Recognizer<Options> {\n  public events$: Observable<TapEvent>\n\n  constructor(protected options: Options) {\n    super(options)\n\n    this.events$ = this.validConfig$.pipe(\n      switchMap((config) => {\n        const { container, afterEventReceived } = config\n        const {\n          multiTapThreshold = 200,\n          maximumPressTime = 250,\n          maxTaps = 2,\n          // threshold should be high because of fingers size\n          // and potential margin due to it. clicks are nearly perfect\n          // not fingers.\n          posThreshold = 10,\n          failWith,\n        } = config.options ?? {}\n\n        const { pointerUp$, pointerLeave$, pointerCancel$, pointerMove$ } =\n          getPointerEvents({\n            container,\n            afterEventReceived,\n          })\n\n        const pointerDown$ = fromPointerDown({ container, afterEventReceived })\n        const activePointers$ = pointerDown$.pipe(\n          trackFingers({\n            pointerCancel$,\n            pointerLeave$,\n            pointerMove$,\n            pointerUp$,\n            trackMove: false,\n          }),\n          shareReplay(1),\n        )\n\n        const hasMoreThanOneActivePointer$ = activePointers$.pipe(\n          filter((pointers) => pointers.length > 1),\n        )\n\n        const onlyOnePointer = <T>(stream: Observable<T>) =>\n          stream.pipe(\n            withLatestFrom(activePointers$),\n            filter(([, pointers]) => pointers.length === 1),\n            map(([pointer]) => pointer),\n          )\n\n        const bufferPointerDowns = (stream: Observable<PointerEvent>) =>\n          stream.pipe(\n            buffer(pointerUp$.pipe(debounceTime(multiTapThreshold))),\n            first(),\n          )\n\n        const failWith$ = fromFailWith(failWith)\n\n        const tap$ = merge(\n          pointerDown$,\n          activePointers$.pipe(ignoreElements()),\n        ).pipe(\n          onlyOnePointer,\n          exhaustMap((initialPointerEvent) => {\n            const pointerDowns$ = merge(of(initialPointerEvent), pointerDown$)\n            const subsequentPointerEvents$ = merge(\n              pointerUp$,\n              pointerLeave$,\n              pointerCancel$,\n              pointerMove$,\n            )\n            const pointerDownsBuffered$ = pointerDowns$.pipe(bufferPointerDowns)\n            const subsequentPointersOutOfPositionThreshold$ =\n              subsequentPointerEvents$.pipe(\n                filter((event) =>\n                  isOutsidePosThreshold(\n                    initialPointerEvent,\n                    event,\n                    posThreshold,\n                  ),\n                ),\n                first(),\n              )\n            const waitedTooLong$ = activePointers$.pipe(\n              switchMap(() => timer(maximumPressTime)),\n            )\n\n            const takeUntil$ = merge(\n              failWith$,\n              pointerCancel$,\n              hasMoreThanOneActivePointer$,\n              subsequentPointersOutOfPositionThreshold$,\n              waitedTooLong$,\n            )\n\n            const rawEvent$ = pointerDownsBuffered$.pipe(\n              filterNotEmpty,\n              filter((events) => events.length <= maxTaps),\n              map((events) => ({\n                type: \"tap\" as const,\n                taps: events.length,\n                latestActivePointers: events,\n                event: events[0],\n              })),\n            )\n\n            return combineLatest([\n              rawEvent$.pipe(mapToRecognizerEvent),\n              rawEvent$,\n            ]).pipe(\n              map(([recognizerEvent, { type, taps }]) => ({\n                ...recognizerEvent,\n                type,\n                taps,\n              })),\n              takeUntil(takeUntil$),\n            )\n          }),\n        )\n\n        return tap$\n      }),\n      share(),\n    )\n  }\n}\n","import { merge, share } from \"rxjs\"\nimport { TapRecognizer } from \"./tap/TapRecognizer\"\nimport { PanRecognizer } from \"./pan/PanRecognizer\"\nimport { SwipeRecognizer } from \"./swipe/SwipeRecognizer\"\nimport { RotateRecognizer } from \"./rotate/RotateRecognizer\"\nimport { PinchRecognizer } from \"./pinch/PinchRecognizer\"\n\nexport type Manager = ReturnType<typeof createManager>\n\nexport const createManager = ({\n  afterEventReceived = (event) => event,\n  recognizers,\n}: {\n  recognizers: (\n    | TapRecognizer\n    | PanRecognizer\n    | SwipeRecognizer\n    | RotateRecognizer\n    | PinchRecognizer\n  )[]\n  afterEventReceived?: (event: PointerEvent) => PointerEvent\n}) => {\n  const events$ = merge(\n    ...recognizers.map((recognizer) => recognizer.events$),\n  ).pipe(share())\n\n  const initialize = (container: HTMLElement) => {\n    /**\n     * We have to disable touch-action otherwise every events will be followed\n     * by a cancel event since the browser will try to handle touch.\n     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/touch-action\n     */\n    container.style.touchAction = `none`\n\n    /**\n     *  Disables text selection to improve the dragging gesture. Mainly for desktop browsers.\n     */\n    container.style.userSelect = `none`\n\n    recognizers.forEach((recognizer) => {\n      recognizer.initialize({ container, afterEventReceived })\n    })\n  }\n\n  return { events$, initialize, recognizers }\n}\n"],"names":["calculateDistance","pointA","pointB","calculateAverageDistance","pointerEvents","n","totalDistance","sum","event1","innerSum","event2","numberOfPairs","calculateRadianAngleBetweenPoints","pointerA","pointerB","deltaX","deltaY","calculateDegreeAngleBetweenPoints","calculateCentroid","points","acc","point","numPoints","calculateAngleDelta","initialPoints","newPoints","initialCentroid","newCentroid","totalAngleDelta","i","initialAngle","angleDelta","radianDelta","degreesDelta","isDefined","arg","hasAtLeastOneItem","events","filterNotEmpty","stream","filter","isOutsidePosThreshold","startEvent","endEvent","posThreshold","start","end","fromFailWith","failWith","merge","start$","NEVER","calculateVelocity","delay","velocityX","velocityY","Recognizer","options","__publicField","BehaviorSubject","config","prevConfig","calculateNewDelta","newCenter","prevCenter","prevDeltaX","prevDeltaY","mapToRecognizerEvent","getCenterFromData","data","scan","curr","prevActivePointersNumber","_a","currActivePointersNumber","_b","hasAddedOrRemovedAFinger","hasAtLeastOneFinger","deltaPointersAngle","map","latestActivePointers","startTime","center","event","pointersAverageDistance","matchPointer","pointer","newPointer","getPointerEvents","container","afterEventReceived","pointerDown$","fromPointerDown","pointerUp$","fromEvent","pointerMove$","pointerLeave$","pointerCancel$","trackFingers","trackMove","mergeMap","pointerDown","pointerDownRelease$","defer","of","takeUntil","endWith","id","_deleted","rest","PanRecognizer","switchMap","exhaustMap","initialPointerDownEvent","pointerDowns$","pointerUpdate$","trackFingers$","shareReplay","panReleased$","withLatestFrom","_","pointers","first","share","panStart$","pointerMoveEvent","panEnd$","panUpdate$","skipUntil","rawEvent$","combineLatest","recognizerEvent","type","isRecognizedAsSwipe","escapeVelocity","SwipeRecognizer","initializedWith","panRecognizer","hasMoreThanOneFinger$","TapRecognizer","multiTapThreshold","maximumPressTime","maxTaps","activePointers$","hasMoreThanOneActivePointer$","onlyOnePointer","bufferPointerDowns","buffer","debounceTime","failWith$","ignoreElements","initialPointerEvent","subsequentPointerEvents$","pointerDownsBuffered$","subsequentPointersOutOfPositionThreshold$","waitedTooLong$","timer","takeUntil$","taps","createManager","recognizers","recognizer"],"mappings":";;;;AAEgB,SAAAA,GAAkBC,GAAeC,GAAuB;AACtE,SAAO,KAAK;AAAA,IACV,KAAK,IAAIA,EAAO,IAAID,EAAO,GAAG,CAAC,IAAI,KAAK,IAAIC,EAAO,IAAID,EAAO,GAAG,CAAC;AAAA,EAAA;AAEtE;AAEO,SAASE,GAAyBC,GAAgC;AACvE,QAAMC,IAAID,EAAc;AACxB,MAAIC,IAAI;AAAU,WAAA;AAElB,QAAMC,IAAgBF,EAAc,OAAO,CAACG,GAAKC,GAAQ,MAErDD,IACAH,EAAc,MAAM,IAAI,CAAC,EAAE,OAAO,CAACK,GAAUC,MACpCD,IAAWT,GAAkBQ,GAAQE,CAAM,GACjD,CAAC,GAEL,CAAC,GAGEC,IAAiBN,KAAKA,IAAI,KAAM;AACtC,SAAOC,IAAgBK;AACzB;AAEgB,SAAAC,EACdC,GACAC,GACQ;AAEF,QAAAC,IAASD,EAAS,IAAID,EAAS,GAC/BG,IAASF,EAAS,IAAID,EAAS;AAM9B,SAHgB,KAAK,MAAMG,GAAQD,CAAM;AAIlD;AAEgB,SAAAE,GACdJ,GACAC,GACQ;AAQD,SANgBF,EAAkCC,GAAUC,CAAQ,KAGlC,MAAM,KAAK;AAItD;AAEO,SAASI,EAAkBC,GAAiB;AACjD,QAAMZ,IAAMY,EAAO;AAAA,IACjB,CAACC,GAAKC,OACJD,EAAI,KAAKC,EAAM,GACfD,EAAI,KAAKC,EAAM,GAERD;AAAA,IAET,EAAE,GAAG,GAAG,GAAG,EAAE;AAAA,EAAA,GAGTE,IAAYH,EAAO,UAAU;AAE5B,SAAA;AAAA,IACL,GAAGZ,EAAI,IAAIe;AAAA,IACX,GAAGf,EAAI,IAAIe;AAAA,EAAA;AAEf;AAEgB,SAAAC,GACdC,GACAC,GACA;AACI,MAAAD,EAAc,WAAWC,EAAU;AAC/B,UAAA,IAAI,MAAM,0DAA0D;AAGtE,QAAAC,IAAkBR,EAAkBM,CAAa,GACjDG,IAAcT,EAAkBO,CAAS;AAE/C,MAAIG,IAAkB;AAEtB,WAASC,IAAI,GAAGA,IAAIL,EAAc,QAAQK,KAAK;AAC7C,UAAMC,IAAelB;AAAA,MACnBc;AAAA,MACAF,EAAcK,CAAC;AAAA,IAAA;AAOjB,QAAIE,IALanB;AAAA,MACfe;AAAA,MACAF,EAAUI,CAAC;AAAA,IAAA,IAGeC;AAGxB,IAAAC,IAAa,KAAK,KACpBA,KAAc,IAAI,KAAK,KACdA,IAAa,CAAC,KAAK,OAC5BA,KAAc,IAAI,KAAK,KAGNH,KAAAG;AAAA,EACrB;AAGM,QAAAC,IAAcJ,IAAkBJ,EAAc,QAC9CS,IAAeD,KAAe,MAAM,KAAK;AAExC,SAAA,EAAE,aAAAA,GAAa,cAAAC;AACxB;AC1GO,SAASC,GACdC,GAC+C;AACxC,SAAAA,KAAQ;AACjB;AAEO,MAAMC,KAAoB,CAAIC,MACnCA,EAAO,SAAS,GAELC,KAAiB,CAC5BC,MAC4BA,EAAO,KAAKC,EAAOJ,EAAiB,CAAC;AAEnD,SAAAK,EACdC,GACAC,GACAC,GACA;AACA,QAAMC,IAAQ3B,EAAkB,CAACwB,CAAU,CAAC,GACtCI,IAAM5B,EAAkB,CAACyB,CAAQ,CAAC;AAGxC,SACE,KAAK,IAAIG,EAAI,IAAID,EAAM,CAAC,IAAID,KAC5B,KAAK,IAAIE,EAAI,IAAID,EAAM,CAAC,IAAID;AAEhC;AAEO,MAAMG,KAAe,CAACC,MAC1BA,KAAA,QAAAA,EAAU,SAEPC,EAAM,IAAID,KAAA,gBAAAA,EAAU,IAAI,CAAC,EAAE,QAAAE,QAAaA,OAAW,CAAA,CAAG,IADtDC,GAOOC,KAAoB,CAC/BC,GACAtC,GACAC,MACG;AACH,QAAMsC,IAAYD,IAAQ,IAAItC,IAASsC,IAAQ,GACzCE,IAAYF,IAAQ,IAAIrC,IAASqC,IAAQ;AAExC,SAAA;AAAA,IACL,WAAAC;AAAA,IACA,WAAAC;AAAA,EAAA;AAEJ;ACxCO,MAAMC,EAAoB;AAAA,EAQ/B,YAAYC,GAAkB;AAPpB,IAAAC,EAAA,iBAAU,IAAIC,GAA2C,CAAA,CAAE;AAC3D,IAAAD,EAAA,sBAAe,KAAK,QAAQ;AAAA,MACpClB;AAAA,QACE,CAACoB,MAAqD,CAAC,CAACA,EAAO;AAAA,MACjE;AAAA,IAAA;AAIA,SAAK,OAAOH,CAAO;AAAA,EACrB;AAAA,EAEO,WAAWG,GAAmC;AAC7C,UAAAC,IAAa,KAAK,QAAQ,SAAS;AAEzC,SAAK,QAAQ,KAAK;AAAA,MAChB,GAAGA;AAAA,MACH,GAAGD;AAAA,MACH,SAAS;AAAA,QACP,GAAGC,EAAW;AAAA,QACd,GAAGD,EAAO;AAAA,MACZ;AAAA,IAAA,CACD;AAAA,EACH;AAAA,EAEO,OAAOH,GAAkB;AACxB,UAAAG,IAAS,KAAK,QAAQ,SAAS;AAErC,SAAK,QAAQ,KAAK;AAAA,MAChB,GAAGA;AAAA,MACH,SAAS;AAAA,QACP,GAAGA,EAAO;AAAA,QACV,GAAGH;AAAA,MACL;AAAA,IAAA,CACD;AAAA,EACH;AACF;AC/BA,MAAMK,IAAoB,CACxBC,GACAC,GACAC,GACAC,MACG;AACH,QAAMnD,IAASgD,EAAU,IAAIC,EAAW,IAAIC,GACtCjD,IAAS+C,EAAU,IAAIC,EAAW,IAAIE;AAErC,SAAA;AAAA,IACL,QAAAnD;AAAA,IACA,QAAAC;AAAA,EAAA;AAEJ,GAEamD,IAAuB,CAClC5B,MACgC;AAC1B,QAAA6B,IAAoB,CAACC,MACzBnD;AAAA,IACGmD,EAAK,qBAAqB,SAEvBA,EAAK,uBADL,CAACA,EAAK,KAAK;AAAA,EACN;AAGb,SAAO9B,EAAO;AAAA,IACZ+B;AAAA,MAQE,CAAClD,GAAKmD,MAAS;;AACP,cAAAR,IAAYK,EAAkBG,CAAI,GAClCP,IAAa5C,EAAI,QACjB6C,IAAa7C,EAAI,QACjB8C,IAAa9C,EAAI,QACjBoD,MAA2BC,IAAArD,EAAI,yBAAJ,gBAAAqD,EAA0B,WAAU,GAC/DC,MAA2BC,IAAAJ,EAAK,yBAAL,gBAAAI,EAA2B,WAAU,GAEhEC,IACJ;AAAA,UACE;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QAAA,EACA,SAASL,EAAK,MAAM,IAAI,KAC1BC,MAA6BE,GACzBG,IAAsBH,IAA2B,GAEjD,EAAE,QAAA3D,GAAQ,QAAAC,EACd,IAAA4D,KAA4BC,IACxBf,EAAkBC,GAAWA,GAAWE,GAAYC,CAAU,IAC9DJ,EAAkBC,GAAWC,GAAYC,GAAYC,CAAU,GAE/D,EAAE,cAAcY,EAAmB,IACvCN,MAA6BE,KAC7BF,KAA4B,KAC5BE,KAA4B,IACxBnD;AAAA,UACEH,EAAI,wBAAwB,CAAC;AAAA,UAC7BmD,EAAK,wBAAwB,CAAC;AAAA,QAAA,IAEhC,EAAE,cAAc;AAEf,eAAA;AAAA,UACL,YAAW,oBAAI,KAAK,GAAE,QAAQ;AAAA,UAC9B,GAAGnD;AAAA,UACH,GAAGmD;AAAA,UACH,QAAQR;AAAA,UACR,QAAAhD;AAAA,UACA,QAAAC;AAAA,UACA,oBAAA8D;AAAA,QAAA;AAAA,MAEJ;AAAA,MACA;AAAA,QACE,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ,EAAE,GAAG,GAAG,GAAG,EAAE;AAAA,QACrB,sBAAsB,CAAC;AAAA,MACzB;AAAA,IACF;AAAA,IACAC,EAAI,CAACV,MAAS;AACN,YAAA;AAAA,QACJ,QAAAtD;AAAA,QACA,QAAAC;AAAA,QACA,sBAAAgE;AAAA,QACA,WAAAC;AAAA,QACA,QAAAC;AAAA,QACA,OAAAC;AAAA,QACA,oBAAAL;AAAA,MACE,IAAAT,GACEhC,IAAS2C,KAAwB,IAIjC3B,IADM,KAAK,QACG4B,GAEd,EAAE,WAAA3B,GAAW,WAAAC,MAAcH,GAAkBC,GAAOtC,GAAQC,CAAM,GAClEoE,IACJjF,GAAyB6E,CAAoB;AAExC,aAAA;AAAA,QACL,QAAAjE;AAAA,QACA,QAAAC;AAAA,QACA,WAAAsC;AAAA,QACA,WAAAC;AAAA,QACA,OAAAF;AAAA,QACA,QAAA6B;AAAA,QACA,UAAU7C;AAAA,QACV,WAAA4C;AAAA,QACA,OAAAE;AAAA,QACA,oBAAAL;AAAA,QACA,yBAAAM;AAAA,MAAA;AAAA,IACF,CACD;AAAA,EAAA;AAEL;AC7HO,SAASC,EAAaC,GAAuB;AAC3C,SAAA,CAAC/C,MACNA,EAAO;AAAA,IACLC,EAAO,CAAC+C,MAAeA,EAAW,cAAcD,EAAQ,SAAS;AAAA,EAAA;AAEvE;AAEO,MAAME,IAAmB,CAAC;AAAA,EAC/B,WAAAC;AAAA,EACA,oBAAAC,IAAqB,CAACP,MAAUA;AAClC,MAGM;AACJ,QAAMQ,IAAeC,EAAgB,EAAE,oBAAAF,GAAoB,WAAAD,EAAW,CAAA,GAChEI,IAAaC,EAAwBL,GAAW,WAAW,EAAE;AAAA,IACjEV,EAAIW,CAAkB;AAAA,EAAA,GAElBK,IAAeD,EAAwBL,GAAW,aAAa,EAAE;AAAA,IACrEV,EAAIW,CAAkB;AAAA,EAAA,GAKlBM,IAAgBF,EAAwBL,GAAW,cAAc,EAAE;AAAA,IACvEV,EAAIW,CAAkB;AAAA,EAAA,GAMlBO,IAAiBH;AAAA,IACrBL;AAAA,IACA;AAAA,EACA,EAAA,KAAKV,EAAIW,CAAkB,CAAC;AAEvB,SAAA;AAAA,IACL,cAAAC;AAAA,IACA,gBAAAM;AAAA,IACA,eAAAD;AAAA,IACA,YAAAH;AAAA,IACA,cAAAE;AAAA,EAAA;AAEJ,GAEaH,IAAkB,CAAC;AAAA,EAC9B,WAAAH;AAAA,EACA,oBAAAC,IAAqB,CAACP,MAAUA;AAClC,MAIEW,EAAwBL,GAAW,aAAa,EAAE;AAAA,EAChDV,EAAIW,CAAkB;AACxB,GAuDWQ,IACX,CAAC;AAAA,EACC,gBAAAD;AAAA,EACA,eAAAD;AAAA,EACA,YAAAH;AAAA,EACA,cAAAE;AAAA,EACA,WAAAI;AACF,MAYA,CAAC5D,MACQA,EAAO;AAAA,EACZ6D,EAAS,CAACC,MAAgB;AACxB,UAAMC,IAAsBrD;AAAA,MAC1B4C;AAAA,MACAG;AAAA,MACAC;AAAA,IACA,EAAA,KAAKZ,EAAagB,CAAW,CAAC,GAE1BV,IAAeY,GAAM,MAAMC,EAAGH,CAAW,CAAC;AAYzC,WAVWpD;AAAA,MAChB0C;AAAA,MACAQ,IAAYJ,IAAe5C;AAAA,IAAA,EAC3B;AAAA,MACAkC,EAAagB,CAAW;AAAA,MACxBtB,EAAI,CAACI,OAAW,EAAE,IAAIA,EAAM,WAAW,OAAAA,IAAQ;AAAA,MAC/CsB,EAAUH,CAAmB;AAAA,MAC7BI,GAAQ,EAAE,IAAIL,EAAY,WAAW,OAAO,QAAW;AAAA,IAAA;AAAA,EAGlD,CACR;AAAA,EACD/B;AAAA,IACE,CAAClD,GAAK,EAAE,OAAA+D,GAAO,IAAAwB,QAAS;AACtB,UAAI,CAACxB,GAAO;AAEV,cAAM,EAAE,CAACwB,CAAE,GAAGC,GAAU,GAAGC,MAASzF;AAE7B,eAAAyF;AAAA,MACT;AAEO,aAAA;AAAA,QACL,GAAGzF;AAAA,QACH,CAACuF,CAAE,GAAGxB;AAAA,MAAA;AAAA,IAEV;AAAA,IACA,CAAC;AAAA,EACH;AAAA,EACAJ,EAAI,CAAC1C,MAAW,OAAO,OAAOA,CAAM,EAAE,OAAOH,EAAS,CAAC;AAAA;ACxJtD,MAAM4E,WAAsBtD,EAAoB;AAAA,EAMrD,YAAsBC,IAAmB,IAAI;AAC3C,UAAMA,CAAO;AANR,IAAAC,EAAA;AACA,IAAAA,EAAA;AACA,IAAAA,EAAA;AACA,IAAAA,EAAA;AAEe,SAAA,UAAAD,GAGf,KAAA,UAAU,KAAK,aAAa;AAAA,MAC/BsD,EAAU,CAACnD,MAAW;AACd,cAAA,EAAE,WAAA6B,GAAW,oBAAAC,EAAuB,IAAA9B,GACpC,EAAE,cAAAhB,IAAe,GAAA,IAAOgB,EAAO,WAAW,CAAA,GAC1C;AAAA,UACJ,gBAAAqC;AAAA,UACA,cAAAN;AAAA,UACA,eAAAK;AAAA,UACA,cAAAD;AAAA,UACA,YAAAF;AAAA,YACEL,EAAiB;AAAA,UACnB,WAAAC;AAAA,UACA,oBAAAC;AAAA,QAAA,CACD;AAED,eAAOC,EAAa;AAAA,UAClBqB,EAAW,CAACC,MAA4B;AACtC,kBAAMC,IAAgBjE;AAAA,cACpBuD,EAAGS,CAAuB;AAAA,cAC1BtB;AAAA,YAAA,GAGIwB,IAAiBlE;AAAA,cACrBgD;AAAA,cACAN;AAAA,cACAK;AAAA,cACAD;AAAA,cACAF;AAAA,YAAA,GAGIuB,IAAgBF,EAAc;AAAA,cAClChB,EAAa;AAAA,gBACX,gBAAAD;AAAA,gBACA,eAAAD;AAAA,gBACA,YAAAH;AAAA,gBACA,cAAAE;AAAA,gBACA,WAAW;AAAA,cAAA,CACZ;AAAA,cACDsB,EAAY;AAAA,YAAA,GASRC,IAAerE;AAAA,cACnB4C;AAAA,cACAG;AAAA,cACAC;AAAA,YAAA,EACA;AAAA,cACAsB,EAAeH,CAAa;AAAA,cAC5B5E,EAAO,CAAC,CAACgF,GAAGC,CAAQ,MAAM,CAACA,EAAS,MAAM;AAAA,cAC1C1C,EAAI,CAAC,CAACI,CAAK,MAAMA,CAAK;AAAA,cACtBuC,EAAM;AAAA,cACNC,EAAM;AAAA,YAAA,GAoBFC,IAjBwCV,EAAc;AAAA,cAC1Dd;AAAA,gBAAS,CAACC,MACRN,EAAa;AAAA,kBACXV,EAAagB,CAAW;AAAA;AAAA,kBAExB7D;AAAA,oBAAO,CAACqF,MACNpF;AAAA,sBACE4D;AAAA,sBACAwB;AAAA,sBACAjF;AAAA,oBACF;AAAA,kBACF;AAAA,gBACF;AAAA,cACF;AAAA,cACA8E,EAAM;AAAA,YAAA,EAGgD;AAAA,cACtD3C,EAAI,OAAO;AAAA,gBACT,MAAM;AAAA,gBACN,OAAOkC;AAAA,cAAA,EACP;AAAA,cACFU,EAAM;AAAA,cACNlB,EAAUa,CAAY;AAAA,YAAA,GAGlBQ,IAAUF,EAAU;AAAA,cACxBxB;AAAA,gBAAS,MACPkB,EAAa;AAAA,kBACXvC,EAAI,CAACpC,OAAc;AAAA,oBACjB,MAAM;AAAA,oBACN,OAAOA;AAAA,kBAAA,EACP;AAAA,gBACJ;AAAA,cACF;AAAA,YAAA,GAGIoF,IAAaZ,EAAe;AAAA,cAChCa,GAAUJ,CAAS;AAAA,cACnB7C,EAAI,CAACI,OAAW;AAAA,gBACd,MAAM;AAAA,gBACN,OAAAA;AAAA,cAAA,EACA;AAAA,cACFsB,EAAUa,CAAY;AAAA,YAAA,GAGlBW,IAAYhF,EAAM2E,GAAWG,GAAYD,CAAO,EAAE;AAAA,cACtDP,EAAeH,CAAa;AAAA,cAC5BrC,EAAI,CAAC,CAACI,GAAOsC,CAAQ,OAAO;AAAA,gBAC1B,GAAGtC;AAAA,gBACH,sBAAsBsC;AAAA,cAAA,EACtB;AAAA,cACFE,EAAM;AAAA,YAAA;AAGR,mBAAOO,EAAc;AAAA,cACnBD,EAAU,KAAK9D,CAAoB;AAAA,cACnC8D;AAAA,YACD,CAAA,EAAE;AAAA,cACDlD,EAAI,CAAC,CAACoD,GAAiB,EAAE,MAAAC,EAAM,CAAA,OAAO;AAAA,gBACpC,GAAGD;AAAA,gBACH,MAAAC;AAAA,cAAA,EACA;AAAA,YAAA;AAAA,UACJ,CACD;AAAA,QAAA;AAAA,MACH,CACD;AAAA,MACDT,EAAM;AAAA,IAAA,GAGH,KAAA,SAAS,KAAK,QAAQ;AAAA,MACzBnF,EAAO,CAAC2C,MAAUA,EAAM,SAAS,UAAU;AAAA,IAAA,GAExC,KAAA,OAAO,KAAK,QAAQ,KAAK3C,EAAO,CAAC2C,MAAUA,EAAM,SAAS,QAAQ,CAAC,GAEnE,KAAA,WAAW,KAAK,aAAa;AAAA,MAChC4B,EAAU,CAAC,EAAE,WAAAtB,GAAW,oBAAAC,QAAyB;AAC/C,cAAMtF,IAAgBoF,EAAiB;AAAA,UACrC,WAAAC;AAAA,UACA,oBAAAC;AAAA,QAAA,CACD;AAED,eAAOtF,EAAc,aAAa;AAAA,UAChC8F,EAAa;AAAA,YACX,GAAG9F;AAAA,YACH,WAAW;AAAA,UAAA,CACZ;AAAA,QAAA;AAAA,MACH,CACD;AAAA,MACD2E,EAAI,CAAC1C,MAAWA,EAAO,MAAM;AAAA,IAAA;AAAA,EAEjC;AACF;AC5LO,MAAMgG,KACX,CAACC,MAA2B,CAAC/F,MAC3BA,EAAO;AAAA,EACLC,EAAO,CAAC2C,MAEJ,KAAK,IAAIA,EAAM,SAAS,KAAKmD,KAC7B,KAAK,IAAInD,EAAM,SAAS,KAAKmD,CAEhC;AACH;AC4BG,MAAMC,WAAwB/E,EAAoB;AAAA,EAGvD,YAAsBC,IAAmB,IAAI;AAC3C,UAAMA,CAAO;AAHR,IAAAC,EAAA;AAEe,SAAA,UAAAD,GAGf,KAAA,UAAU,KAAK,aAAa;AAAA,MAC/BsD,EAAU,CAACyB,MAAoB;AAC7B,cAAM,EAAE,gBAAAF,IAAiB,KAAK,cAAA1F,EAC5B,IAAA4F,EAAgB,WAAW,IACvBC,IAAgB,IAAI3B,GAAc,EAAE,cAAAlE,EAAc,CAAA;AAExD,QAAA6F,EAAc,WAAWD,CAAe;AAElC,cAAAE,IAAwBD,EAAc,QAAQ;AAAA,UAClDjG,EAAO,CAAC,EAAE,UAAAiF,QAAeA,EAAS,SAAS,CAAC;AAAA,QAAA;AAG9C,eAAOgB,EAAc,OAAO;AAAA,UAC1BzB,EAAW,CAACtE,MACH+F,EAAc,KAAK;AAAA,YACxBf,EAAM;AAAA,YACNW,GAAoBC,CAAc;AAAA,YAClCvD,EAAI,CAAC,EAAE,MAAAqD,GAAM,GAAGvB,SACP;AAAA,cACL,MAAM;AAAA,cACN,OAAO5F;AAAA,gBACLyB,EAAW;AAAA,gBACXmE,EAAK;AAAA,cACP;AAAA,cACA,GAAGA;AAAA,YAAA,EAEN;AAAA,YACDJ,EAAUiC,CAAqB;AAAA,UAAA,CAElC;AAAA,UACDf,EAAM;AAAA,QAAA;AAAA,MACR,CACD;AAAA,IAAA;AAAA,EAEL;AACF;AClCO,MAAMgB,WAAsBnF,EAAoB;AAAA,EAGrD,YAAsBC,GAAkB;AACtC,UAAMA,CAAO;AAHR,IAAAC,EAAA;AAEe,SAAA,UAAAD,GAGf,KAAA,UAAU,KAAK,aAAa;AAAA,MAC/BsD,EAAU,CAACnD,MAAW;AACd,cAAA,EAAE,WAAA6B,GAAW,oBAAAC,EAAuB,IAAA9B,GACpC;AAAA,UACJ,mBAAAgF,IAAoB;AAAA,UACpB,kBAAAC,IAAmB;AAAA,UACnB,SAAAC,IAAU;AAAA;AAAA;AAAA;AAAA,UAIV,cAAAlG,IAAe;AAAA,UACf,UAAAI;AAAA,QAAA,IACEY,EAAO,WAAW,IAEhB,EAAE,YAAAiC,GAAY,eAAAG,GAAe,gBAAAC,GAAgB,cAAAF,EAAA,IACjDP,EAAiB;AAAA,UACf,WAAAC;AAAA,UACA,oBAAAC;AAAA,QAAA,CACD,GAEGC,IAAeC,EAAgB,EAAE,WAAAH,GAAW,oBAAAC,EAAoB,CAAA,GAChEqD,IAAkBpD,EAAa;AAAA,UACnCO,EAAa;AAAA,YACX,gBAAAD;AAAA,YACA,eAAAD;AAAA,YACA,cAAAD;AAAA,YACA,YAAAF;AAAA,YACA,WAAW;AAAA,UAAA,CACZ;AAAA,UACDwB,EAAY,CAAC;AAAA,QAAA,GAGT2B,IAA+BD,EAAgB;AAAA,UACnDvG,EAAO,CAACiF,MAAaA,EAAS,SAAS,CAAC;AAAA,QAAA,GAGpCwB,IAAiB,CAAI1G,MACzBA,EAAO;AAAA,UACLgF,EAAewB,CAAe;AAAA,UAC9BvG,EAAO,CAAC,CAAA,EAAGiF,CAAQ,MAAMA,EAAS,WAAW,CAAC;AAAA,UAC9C1C,EAAI,CAAC,CAACO,CAAO,MAAMA,CAAO;AAAA,QAAA,GAGxB4D,IAAqB,CAAC3G,MAC1BA,EAAO;AAAA,UACL4G,GAAOtD,EAAW,KAAKuD,GAAaR,CAAiB,CAAC,CAAC;AAAA,UACvDlB,EAAM;AAAA,QAAA,GAGJ2B,IAAYtG,GAAaC,CAAQ;AAgEhC,eA9DMC;AAAA,UACX0C;AAAA,UACAoD,EAAgB,KAAKO,IAAgB;AAAA,QAAA,EACrC;AAAA,UACAL;AAAA,UACAjC,EAAW,CAACuC,MAAwB;AAClC,kBAAMrC,IAAgBjE,EAAMuD,EAAG+C,CAAmB,GAAG5D,CAAY,GAC3D6D,IAA2BvG;AAAA,cAC/B4C;AAAA,cACAG;AAAA,cACAC;AAAA,cACAF;AAAA,YAAA,GAEI0D,KAAwBvC,EAAc,KAAKgC,CAAkB,GAC7DQ,KACJF,EAAyB;AAAA,cACvBhH;AAAA,gBAAO,CAAC2C,MACN1C;AAAA,kBACE8G;AAAA,kBACApE;AAAA,kBACAvC;AAAA,gBACF;AAAA,cACF;AAAA,cACA8E,EAAM;AAAA,YAAA,GAEJiC,KAAiBZ,EAAgB;AAAA,cACrChC,EAAU,MAAM6C,GAAMf,CAAgB,CAAC;AAAA,YAAA,GAGnCgB,KAAa5G;AAAA,cACjBoG;AAAA,cACApD;AAAA,cACA+C;AAAA,cACAU;AAAA,cACAC;AAAA,YAAA,GAGI1B,IAAYwB,GAAsB;AAAA,cACtCnH;AAAA,cACAE,EAAO,CAACH,MAAWA,EAAO,UAAUyG,CAAO;AAAA,cAC3C/D,EAAI,CAAC1C,OAAY;AAAA,gBACf,MAAM;AAAA,gBACN,MAAMA,EAAO;AAAA,gBACb,sBAAsBA;AAAA,gBACtB,OAAOA,EAAO,CAAC;AAAA,cAAA,EACf;AAAA,YAAA;AAGJ,mBAAO6F,EAAc;AAAA,cACnBD,EAAU,KAAK9D,CAAoB;AAAA,cACnC8D;AAAA,YACD,CAAA,EAAE;AAAA,cACDlD,EAAI,CAAC,CAACoD,GAAiB,EAAE,MAAAC,IAAM,MAAA0B,GAAM,CAAA,OAAO;AAAA,gBAC1C,GAAG3B;AAAA,gBACH,MAAAC;AAAA,gBACA,MAAA0B;AAAA,cAAA,EACA;AAAA,cACFrD,EAAUoD,EAAU;AAAA,YAAA;AAAA,UACtB,CACD;AAAA,QAAA;AAAA,MAGI,CACR;AAAA,MACDlC,EAAM;AAAA,IAAA;AAAA,EAEV;AACF;AClKO,MAAMoC,KAAgB,CAAC;AAAA,EAC5B,oBAAArE,IAAqB,CAACP,MAAUA;AAAA,EAChC,aAAA6E;AACF,OAgCS,EAAE,SAtBO/G;AAAA,EACd,GAAG+G,EAAY,IAAI,CAACC,MAAeA,EAAW,OAAO;AAAA,EACrD,KAAKtC,EAAA,CAAO,GAoBI,YAlBC,CAAClC,MAA2B;AAM7C,EAAAA,EAAU,MAAM,cAAc,QAK9BA,EAAU,MAAM,aAAa,QAEjBuE,EAAA,QAAQ,CAACC,MAAe;AAClC,IAAAA,EAAW,WAAW,EAAE,WAAAxE,GAAW,oBAAAC,EAAoB,CAAA;AAAA,EAAA,CACxD;AAAA,GAG2B,aAAAsE;"}

package/dist/index.umd.cjs

@@ -0,0 +1,2 @@
+(function(h,e){typeof exports=="object"&&typeof module<"u"?e(exports,require("rxjs")):typeof define=="function"&&define.amd?define(["exports","rxjs"],e):(h=typeof globalThis<"u"?globalThis:h||self,e(h.gesturx={},h.rxjs))})(this,function(h,e){"use strict";var pe=Object.defineProperty;var se=(h,e,D)=>e in h?pe(h,e,{enumerable:!0,configurable:!0,writable:!0,value:D}):h[e]=D;var M=(h,e,D)=>(se(h,typeof e!="symbol"?e+"":e,D),D);function D(t,o){return Math.sqrt(Math.pow(o.x-t.x,2)+Math.pow(o.y-t.y,2))}function V(t){const o=t.length;if(o<2)return 0;const n=t.reduce((a,s,p)=>a+t.slice(p+1).reduce((c,r)=>c+D(s,r),0),0),i=o*(o-1)/2;return n/i}function R(t,o){const n=o.x-t.x,i=o.y-t.y;return Math.atan2(i,n)}function q(t,o){return R(t,o)*(180/Math.PI)}function A(t){const o=t.reduce((i,a)=>(i.x+=a.x,i.y+=a.y,i),{x:0,y:0}),n=t.length||1;return{x:o.x/n,y:o.y/n}}function B(t,o){if(t.length!==o.length)throw new Error("Initial and new points arrays must have the same length.");const n=A(t),i=A(o);let a=0;for(let c=0;c<t.length;c++){const r=R(n,t[c]);let l=R(i,o[c])-r;l>Math.PI?l-=2*Math.PI:l<-Math.PI&&(l+=2*Math.PI),a+=l}const s=a/t.length,p=s*(180/Math.PI);return{radianDelta:s,degreesDelta:p}}function _(t){return t!=null}const G=t=>t.length>0,H=t=>t.pipe(e.filter(G));function U(t,o,n){const i=A([t]),a=A([o]);return Math.abs(a.x-i.x)>n||Math.abs(a.y-i.y)>n}const J=t=>t!=null&&t.length?e.merge(...(t==null?void 0:t.map(({start$:o})=>o))??[]):e.NEVER,K=(t,o,n)=>{const i=t>0?o/t:0,a=t>0?n/t:0;return{velocityX:i,velocityY:a}};class b{constructor(o){M(this,"config$",new e.BehaviorSubject({}));M(this,"validConfig$",this.config$.pipe(e.filter(o=>!!o.container)));this.update(o)}initialize(o){const n=this.config$.getValue();this.config$.next({...n,...o,options:{...n.options,...o.options}})}update(o){const n=this.config$.getValue();this.config$.next({...n,options:{...n.options,...o}})}}const L=(t,o,n,i)=>{const a=t.x-o.x+n,s=t.y-o.y+i;return{deltaX:a,deltaY:s}},F=t=>{const o=n=>A(n.latestActivePointers.length?n.latestActivePointers:[n.event]);return t.pipe(e.scan((n,i)=>{var f,m;const a=o(i),s=n.center,p=n.deltaX,c=n.deltaY,r=((f=n.latestActivePointers)==null?void 0:f.length)??0,g=((m=i.latestActivePointers)==null?void 0:m.length)??0,l=["pointerdown","pointercancel","pointerleave","pointerup"].includes(i.event.type)&&r!==g,$=g>0,{deltaX:v,deltaY:w}=l&&$?L(a,a,p,c):L(a,s,p,c),{degreesDelta:P}=r===g&&r>=2&&g>=2?B(n.latestActivePointers??[],i.latestActivePointers??[]):{degreesDelta:0};return{startTime:new Date().getTime(),...n,...i,center:a,deltaX:v,deltaY:w,deltaPointersAngle:P}},{deltaX:0,deltaY:0,center:{x:0,y:0},latestActivePointers:[]}),e.map(n=>{const{deltaX:i,deltaY:a,latestActivePointers:s,startTime:p,center:c,event:r,deltaPointersAngle:g}=n,l=s??[],v=Date.now()-p,{velocityX:w,velocityY:P}=K(v,i,a),f=V(s);return{deltaX:i,deltaY:a,velocityX:w,velocityY:P,delay:v,center:c,pointers:l,startTime:p,event:r,deltaPointersAngle:g,pointersAverageDistance:f}}))};function I(t){return o=>o.pipe(e.filter(n=>n.pointerId===t.pointerId))}const E=({container:t,afterEventReceived:o=n=>n})=>{const n=S({afterEventReceived:o,container:t}),i=e.fromEvent(t,"pointerup").pipe(e.map(o)),a=e.fromEvent(t,"pointermove").pipe(e.map(o)),s=e.fromEvent(t,"pointerleave").pipe(e.map(o)),p=e.fromEvent(t,"pointercancel").pipe(e.map(o));return{pointerDown$:n,pointerCancel$:p,pointerLeave$:s,pointerUp$:i,pointerMove$:a}},S=({container:t,afterEventReceived:o=n=>n})=>e.fromEvent(t,"pointerdown").pipe(e.map(o)),O=({pointerCancel$:t,pointerLeave$:o,pointerUp$:n,pointerMove$:i,trackMove:a})=>s=>s.pipe(e.mergeMap(p=>{const c=e.merge(n,o,t).pipe(I(p)),r=e.defer(()=>e.of(p));return e.merge(r,a?i:e.NEVER).pipe(I(p),e.map(l=>({id:l.pointerId,event:l})),e.takeUntil(c),e.endWith({id:p.pointerId,event:void 0}))}),e.scan((p,{event:c,id:r})=>{if(!c){const{[r]:g,...l}=p;return l}return{...p,[r]:c}},{}),e.map(p=>Object.values(p).filter(_)));class X extends b{constructor(n={}){super(n);M(this,"events$");M(this,"start$");M(this,"end$");M(this,"fingers$");this.options=n,this.events$=this.validConfig$.pipe(e.switchMap(i=>{const{container:a,afterEventReceived:s}=i,{posThreshold:p=15}=i.options??{},{pointerCancel$:c,pointerDown$:r,pointerLeave$:g,pointerMove$:l,pointerUp$:$}=E({container:a,afterEventReceived:s});return r.pipe(e.exhaustMap(v=>{const w=e.merge(e.of(v),r),P=e.merge(c,r,g,l,$),f=w.pipe(O({pointerCancel$:c,pointerLeave$:g,pointerUp$:$,pointerMove$:l,trackMove:!0}),e.shareReplay()),m=e.merge($,g,c).pipe(e.withLatestFrom(f),e.filter(([u,d])=>!d.length),e.map(([u])=>u),e.first(),e.share()),T=w.pipe(e.mergeMap(u=>l.pipe(I(u),e.filter(d=>U(u,d,p)))),e.first()).pipe(e.map(()=>({type:"panStart",event:v})),e.share(),e.takeUntil(m)),k=T.pipe(e.mergeMap(()=>m.pipe(e.map(u=>({type:"panEnd",event:u}))))),C=P.pipe(e.skipUntil(T),e.map(u=>({type:"panMove",event:u})),e.takeUntil(m)),z=e.merge(T,C,k).pipe(e.withLatestFrom(f),e.map(([u,d])=>({...u,latestActivePointers:d})),e.share());return e.combineLatest([z.pipe(F),z]).pipe(e.map(([u,{type:d}])=>({...u,type:d})))}))}),e.share()),this.start$=this.events$.pipe(e.filter(i=>i.type==="panStart")),this.end$=this.events$.pipe(e.filter(i=>i.type==="panEnd")),this.fingers$=this.validConfig$.pipe(e.switchMap(({container:i,afterEventReceived:a})=>{const s=E({container:i,afterEventReceived:a});return s.pointerDown$.pipe(O({...s,trackMove:!1}))}),e.map(i=>i.length))}}const Q=t=>o=>o.pipe(e.filter(n=>Math.abs(n.velocityX)>=t||Math.abs(n.velocityY)>=t));class Z extends b{constructor(n={}){super(n);M(this,"events$");this.options=n,this.events$=this.validConfig$.pipe(e.switchMap(i=>{const{escapeVelocity:a=.9,posThreshold:s}=i.options??{},p=new X({posThreshold:s});p.initialize(i);const c=p.events$.pipe(e.filter(({pointers:r})=>r.length>1));return p.start$.pipe(e.exhaustMap(r=>p.end$.pipe(e.first(),Q(a),e.map(({type:g,...l})=>({type:"swipe",angle:q(r.event,l.event),...l})),e.takeUntil(c))),e.share())}))}}class W extends b{constructor(n){super(n);M(this,"events$");this.options=n,this.events$=this.validConfig$.pipe(e.switchMap(i=>{const{container:a,afterEventReceived:s}=i,{multiTapThreshold:p=200,maximumPressTime:c=250,maxTaps:r=2,posThreshold:g=10,failWith:l}=i.options??{},{pointerUp$:$,pointerLeave$:v,pointerCancel$:w,pointerMove$:P}=E({container:a,afterEventReceived:s}),f=S({container:a,afterEventReceived:s}),m=f.pipe(O({pointerCancel$:w,pointerLeave$:v,pointerMove$:P,pointerUp$:$,trackMove:!1}),e.shareReplay(1)),Y=m.pipe(e.filter(u=>u.length>1)),T=u=>u.pipe(e.withLatestFrom(m),e.filter(([,d])=>d.length===1),e.map(([d])=>d)),k=u=>u.pipe(e.buffer($.pipe(e.debounceTime(p))),e.first()),C=J(l);return e.merge(f,m.pipe(e.ignoreElements())).pipe(T,e.exhaustMap(u=>{const d=e.merge(e.of(u),f),j=e.merge($,v,w,P),ee=d.pipe(k),te=j.pipe(e.filter(y=>U(u,y,g)),e.first()),ne=m.pipe(e.switchMap(()=>e.timer(c))),oe=e.merge(C,w,Y,te,ne),N=ee.pipe(H,e.filter(y=>y.length<=r),e.map(y=>({type:"tap",taps:y.length,latestActivePointers:y,event:y[0]})));return e.combineLatest([N.pipe(F),N]).pipe(e.map(([y,{type:ie,taps:ae}])=>({...y,type:ie,taps:ae})),e.takeUntil(oe))}))}),e.share())}}const x=({afterEventReceived:t=n=>n,recognizers:o})=>({events$:e.merge(...o.map(a=>a.events$)).pipe(e.share()),initialize:a=>{a.style.touchAction="none",a.style.userSelect="none",o.forEach(s=>{s.initialize({container:a,afterEventReceived:t})})},recognizers:o});h.PanRecognizer=X,h.SwipeRecognizer=Z,h.TapRecognizer=W,h.createManager=x,Object.defineProperty(h,Symbol.toStringTag,{value:"Module"})});
+//# sourceMappingURL=index.umd.cjs.map