react-native-gesture-handler 2.26.0 → 2.27.1

package/lib/typescript/jestUtils/jestUtils.js

@@ -0,0 +1,290 @@
+import invariant from 'invariant';
+import { DeviceEventEmitter } from 'react-native';
+import { flingHandlerName, } from '../handlers/FlingGestureHandler';
+import { forceTouchHandlerName, } from '../handlers/ForceTouchGestureHandler';
+import { BaseGesture } from '../handlers/gestures/gesture';
+import { findHandlerByTestID } from '../handlers/handlersRegistry';
+import { longPressHandlerName, } from '../handlers/LongPressGestureHandler';
+import { nativeViewHandlerName, } from '../handlers/NativeViewGestureHandler';
+import { panHandlerName, } from '../handlers/PanGestureHandler';
+import { pinchHandlerName, } from '../handlers/PinchGestureHandler';
+import { rotationHandlerName, } from '../handlers/RotationGestureHandler';
+import { tapHandlerName, } from '../handlers/TapGestureHandler';
+import { State } from '../State';
+import { hasProperty, withPrevAndCurrent } from '../utils';
+// Load fireEvent conditionally, so RNGH may be used in setups without testing-library
+let fireEvent = (_element, _name, ..._data) => {
+    // NOOP
+};
+try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    fireEvent = require('@testing-library/react-native').fireEvent;
+}
+catch (_e) {
+    // Do nothing if not available
+}
+const handlersDefaultEvents = {
+    [flingHandlerName]: {
+        x: 0,
+        y: 0,
+        absoluteX: 0,
+        absoluteY: 0,
+        numberOfPointers: 1,
+    },
+    [forceTouchHandlerName]: {
+        x: 0,
+        y: 0,
+        absoluteX: 0,
+        absoluteY: 0,
+        force: 1,
+        numberOfPointers: 1,
+    },
+    [longPressHandlerName]: {
+        x: 0,
+        y: 0,
+        absoluteX: 0,
+        absoluteY: 0,
+        duration: 100,
+        numberOfPointers: 1,
+    },
+    [nativeViewHandlerName]: {
+        pointerInside: true,
+        numberOfPointers: 1,
+    },
+    [panHandlerName]: {
+        x: 0,
+        y: 0,
+        absoluteX: 0,
+        absoluteY: 0,
+        translationX: 100,
+        translationY: 0,
+        velocityX: 3,
+        velocityY: 0,
+        numberOfPointers: 1,
+        stylusData: undefined,
+    },
+    [pinchHandlerName]: {
+        focalX: 0,
+        focalY: 0,
+        scale: 2,
+        velocity: 1,
+        numberOfPointers: 2,
+    },
+    [rotationHandlerName]: {
+        anchorX: 0,
+        anchorY: 0,
+        rotation: 3.14,
+        velocity: 2,
+        numberOfPointers: 2,
+    },
+    [tapHandlerName]: {
+        x: 0,
+        y: 0,
+        absoluteX: 0,
+        absoluteY: 0,
+        numberOfPointers: 1,
+    },
+};
+function isGesture(componentOrGesture) {
+    return componentOrGesture instanceof BaseGesture;
+}
+function wrapWithNativeEvent(event) {
+    return { nativeEvent: event };
+}
+function fillOldStateChanges(previousEvent, currentEvent) {
+    const isFirstEvent = previousEvent === null;
+    if (isFirstEvent) {
+        return {
+            oldState: State.UNDETERMINED,
+            ...currentEvent,
+        };
+    }
+    const isGestureStateEvent = previousEvent.state !== currentEvent.state;
+    if (isGestureStateEvent) {
+        return {
+            oldState: previousEvent?.state,
+            ...currentEvent,
+        };
+    }
+    else {
+        return currentEvent;
+    }
+}
+function validateStateTransitions(previousEvent, currentEvent) {
+    function stringify(event) {
+        return JSON.stringify(event, null, 2);
+    }
+    function errorMsgWithBothEvents(description) {
+        return `${description}, invalid event: ${stringify(currentEvent)}, previous event: ${stringify(previousEvent)}`;
+    }
+    function errorMsgWithCurrentEvent(description) {
+        return `${description}, invalid event: ${stringify(currentEvent)}`;
+    }
+    invariant(hasProperty(currentEvent, 'state'), errorMsgWithCurrentEvent('every event must have state'));
+    const isFirstEvent = previousEvent === null;
+    if (isFirstEvent) {
+        invariant(currentEvent.state === State.BEGAN, errorMsgWithCurrentEvent('first event must have BEGAN state'));
+    }
+    if (previousEvent !== null) {
+        if (previousEvent.state !== currentEvent.state) {
+            invariant(hasProperty(currentEvent, 'oldState'), errorMsgWithCurrentEvent('when state changes, oldState field should be present'));
+            invariant(currentEvent.oldState === previousEvent.state, errorMsgWithBothEvents("when state changes, oldState should be the same as previous event' state"));
+        }
+    }
+    return currentEvent;
+}
+function fillMissingDefaultsFor({ handlerType, handlerTag, }) {
+    return (event) => {
+        return {
+            ...handlersDefaultEvents[handlerType],
+            ...event,
+            handlerTag,
+        };
+    };
+}
+function isDiscreteHandler(handlerType) {
+    return (handlerType === 'TapGestureHandler' ||
+        handlerType === 'LongPressGestureHandler');
+}
+function fillMissingStatesTransitions(events, isDiscreteHandler) {
+    const _events = [...events];
+    const lastEvent = _events[_events.length - 1] ?? null;
+    const firstEvent = _events[0] ?? null;
+    const shouldDuplicateFirstEvent = !isDiscreteHandler && !hasState(State.BEGAN)(firstEvent);
+    if (shouldDuplicateFirstEvent) {
+        const duplicated = { ...firstEvent, state: State.BEGAN };
+        // @ts-ignore badly typed, property may exist and we don't want to copy it
+        delete duplicated.oldState;
+        _events.unshift(duplicated);
+    }
+    const shouldDuplicateLastEvent = !hasState(State.END)(lastEvent) ||
+        !hasState(State.FAILED)(lastEvent) ||
+        !hasState(State.CANCELLED)(lastEvent);
+    if (shouldDuplicateLastEvent) {
+        const duplicated = { ...lastEvent, state: State.END };
+        // @ts-ignore badly typed, property may exist and we don't want to copy it
+        delete duplicated.oldState;
+        _events.push(duplicated);
+    }
+    function isWithoutState(event) {
+        return event !== null && !hasProperty(event, 'state');
+    }
+    function hasState(state) {
+        return (event) => event !== null && event.state === state;
+    }
+    function noEventsLeft(event) {
+        return event === null;
+    }
+    function trueFn() {
+        return true;
+    }
+    function fillEventsForCurrentState({ shouldConsumeEvent = trueFn, shouldTransitionToNextState = trueFn, }) {
+        function peekCurrentEvent() {
+            return _events[0] ?? null;
+        }
+        function peekNextEvent() {
+            return _events[1] ?? null;
+        }
+        function consumeCurrentEvent() {
+            _events.shift();
+        }
+        const currentEvent = peekCurrentEvent();
+        const nextEvent = peekNextEvent();
+        const currentRequiredState = REQUIRED_EVENTS[currentStateIdx];
+        let eventData = {};
+        const shouldUseEvent = shouldConsumeEvent(currentEvent);
+        if (shouldUseEvent) {
+            eventData = currentEvent;
+            consumeCurrentEvent();
+        }
+        transformedEvents.push({ state: currentRequiredState, ...eventData });
+        if (shouldTransitionToNextState(nextEvent)) {
+            currentStateIdx++;
+        }
+    }
+    const REQUIRED_EVENTS = [State.BEGAN, State.ACTIVE, State.END];
+    let currentStateIdx = 0;
+    const transformedEvents = [];
+    let hasAllStates;
+    let iterations = 0;
+    do {
+        const nextRequiredState = REQUIRED_EVENTS[currentStateIdx];
+        if (nextRequiredState === State.BEGAN) {
+            fillEventsForCurrentState({
+                shouldConsumeEvent: (e) => isWithoutState(e) || hasState(State.BEGAN)(e),
+            });
+        }
+        else if (nextRequiredState === State.ACTIVE) {
+            const shouldConsumeEvent = (e) => isWithoutState(e) || hasState(State.ACTIVE)(e);
+            const shouldTransitionToNextState = (nextEvent) => noEventsLeft(nextEvent) ||
+                hasState(State.END)(nextEvent) ||
+                hasState(State.FAILED)(nextEvent) ||
+                hasState(State.CANCELLED)(nextEvent);
+            fillEventsForCurrentState({
+                shouldConsumeEvent,
+                shouldTransitionToNextState,
+            });
+        }
+        else if (nextRequiredState === State.END) {
+            fillEventsForCurrentState({});
+        }
+        hasAllStates = currentStateIdx === REQUIRED_EVENTS.length;
+        invariant(iterations++ <= 500, 'exceeded max number of iterations, please report a bug in RNGH repository with your test case');
+    } while (!hasAllStates);
+    return transformedEvents;
+}
+function getHandlerData(componentOrGesture) {
+    if (isGesture(componentOrGesture)) {
+        const gesture = componentOrGesture;
+        return {
+            emitEvent: (eventName, args) => {
+                DeviceEventEmitter.emit(eventName, args.nativeEvent);
+            },
+            handlerType: gesture.handlerName,
+            handlerTag: gesture.handlerTag,
+            enabled: gesture.config.enabled,
+        };
+    }
+    const gestureHandlerComponent = componentOrGesture;
+    return {
+        emitEvent: (eventName, args) => {
+            fireEvent(gestureHandlerComponent, eventName, args);
+        },
+        handlerType: gestureHandlerComponent.props.handlerType,
+        handlerTag: gestureHandlerComponent.props.handlerTag,
+        enabled: gestureHandlerComponent.props.enabled,
+    };
+}
+export function fireGestureHandler(componentOrGesture, eventList = []) {
+    const { emitEvent, handlerType, handlerTag, enabled } = getHandlerData(componentOrGesture);
+    if (enabled === false) {
+        return;
+    }
+    let _ = fillMissingStatesTransitions(eventList, isDiscreteHandler(handlerType));
+    _ = _.map(fillMissingDefaultsFor({ handlerTag, handlerType }));
+    _ = withPrevAndCurrent(_, fillOldStateChanges);
+    _ = withPrevAndCurrent(_, validateStateTransitions);
+    // @ts-ignore TODO
+    _ = _.map(wrapWithNativeEvent);
+    const events = _;
+    const firstEvent = events.shift();
+    emitEvent('onGestureHandlerStateChange', firstEvent);
+    let lastSentEvent = firstEvent;
+    for (const event of events) {
+        const hasChangedState = lastSentEvent.nativeEvent.state !== event.nativeEvent.state;
+        if (hasChangedState) {
+            emitEvent('onGestureHandlerStateChange', event);
+        }
+        else {
+            emitEvent('onGestureHandlerEvent', event);
+        }
+        lastSentEvent = event;
+    }
+}
+export function getByGestureTestId(testID) {
+    const handler = findHandlerByTestID(testID);
+    if (handler === null) {
+        throw new Error(`Handler with id: '${testID}' cannot be found`);
+    }
+    return handler;
+}

package/lib/typescript/mocks.d.ts

@@ -44,4 +44,3 @@ declare const _default: {
     };
 };
 export default _default;
-//# sourceMappingURL=mocks.d.ts.map

package/lib/typescript/mocks.js

@@ -0,0 +1,59 @@
+import React from 'react';
+import { TouchableHighlight, TouchableNativeFeedback, TouchableOpacity, TouchableWithoutFeedback, ScrollView, FlatList, Switch, TextInput, DrawerLayoutAndroid, View, } from 'react-native';
+import { State } from './State';
+import { Directions } from './Directions';
+const NOOP = () => {
+    // Do nothing
+};
+const PanGestureHandler = View;
+const attachGestureHandler = NOOP;
+const createGestureHandler = NOOP;
+const dropGestureHandler = NOOP;
+const updateGestureHandler = NOOP;
+const flushOperations = NOOP;
+const install = NOOP;
+const NativeViewGestureHandler = View;
+const TapGestureHandler = View;
+const ForceTouchGestureHandler = View;
+const LongPressGestureHandler = View;
+const PinchGestureHandler = View;
+const RotationGestureHandler = View;
+const FlingGestureHandler = View;
+const RawButton = ({ enabled, ...rest }) => (<TouchableNativeFeedback disabled={!enabled} {...rest}>
+    <View />
+  </TouchableNativeFeedback>);
+const BaseButton = RawButton;
+const RectButton = RawButton;
+const BorderlessButton = TouchableNativeFeedback;
+export default {
+    TouchableHighlight,
+    TouchableNativeFeedback,
+    TouchableOpacity,
+    TouchableWithoutFeedback,
+    ScrollView,
+    FlatList,
+    Switch,
+    TextInput,
+    DrawerLayoutAndroid,
+    NativeViewGestureHandler,
+    TapGestureHandler,
+    ForceTouchGestureHandler,
+    LongPressGestureHandler,
+    PinchGestureHandler,
+    RotationGestureHandler,
+    FlingGestureHandler,
+    RawButton,
+    BaseButton,
+    RectButton,
+    BorderlessButton,
+    PanGestureHandler,
+    attachGestureHandler,
+    createGestureHandler,
+    dropGestureHandler,
+    updateGestureHandler,
+    flushOperations,
+    install,
+    // Probably can be removed
+    Directions,
+    State,
+};

package/lib/typescript/mountRegistry.d.ts

@@ -14,4 +14,3 @@ export declare class MountRegistry {
     static gestureWillUnmount(gesture: GestureType): void;
 }
 export {};
-//# sourceMappingURL=mountRegistry.d.ts.map

package/lib/typescript/mountRegistry.js

@@ -0,0 +1,29 @@
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class MountRegistry {
+    static mountListeners = new Set();
+    static unmountListeners = new Set();
+    static addMountListener(listener) {
+        this.mountListeners.add(listener);
+        return () => {
+            this.mountListeners.delete(listener);
+        };
+    }
+    static addUnmountListener(listener) {
+        this.unmountListeners.add(listener);
+        return () => {
+            this.unmountListeners.delete(listener);
+        };
+    }
+    static gestureHandlerWillMount(handler) {
+        this.mountListeners.forEach((listener) => listener(handler));
+    }
+    static gestureHandlerWillUnmount(handler) {
+        this.unmountListeners.forEach((listener) => listener(handler));
+    }
+    static gestureWillMount(gesture) {
+        this.mountListeners.forEach((listener) => listener(gesture));
+    }
+    static gestureWillUnmount(gesture) {
+        this.unmountListeners.forEach((listener) => listener(gesture));
+    }
+}

package/lib/typescript/specs/NativeRNGestureHandlerModule.d.ts

@@ -12,4 +12,3 @@ export interface Spec extends TurboModule {
 }
 declare const _default: Spec;
 export default _default;
-//# sourceMappingURL=NativeRNGestureHandlerModule.d.ts.map

package/lib/typescript/specs/NativeRNGestureHandlerModule.js

@@ -0,0 +1,2 @@
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('RNGestureHandlerModule');

package/lib/typescript/specs/RNGestureHandlerButtonNativeComponent.d.ts

@@ -14,4 +14,3 @@ interface NativeProps extends ViewProps {
 }
 declare const _default: import("react-native/Libraries/Utilities/codegenNativeComponent").NativeComponentType<NativeProps>;
 export default _default;
-//# sourceMappingURL=RNGestureHandlerButtonNativeComponent.d.ts.map

package/lib/typescript/specs/RNGestureHandlerButtonNativeComponent.js

@@ -0,0 +1,2 @@
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+export default codegenNativeComponent('RNGestureHandlerButton');

package/lib/typescript/specs/RNGestureHandlerRootViewNativeComponent.d.ts

@@ -3,4 +3,3 @@ interface NativeProps extends ViewProps {
 }
 declare const _default: import("react-native/Libraries/Utilities/codegenNativeComponent").NativeComponentType<NativeProps>;
 export default _default;
-//# sourceMappingURL=RNGestureHandlerRootViewNativeComponent.d.ts.map

package/lib/typescript/specs/RNGestureHandlerRootViewNativeComponent.js

@@ -0,0 +1,2 @@
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+export default codegenNativeComponent('RNGestureHandlerRootView');

package/lib/typescript/typeUtils.d.ts

@@ -1,2 +1 @@
 export type ValueOf<T> = T[keyof T];
-//# sourceMappingURL=typeUtils.d.ts.map

package/lib/typescript/typeUtils.js

@@ -0,0 +1 @@
+export {};

package/lib/typescript/utils.d.ts

@@ -18,4 +18,3 @@ export declare function isRemoteDebuggingEnabled(): boolean;
  */
 export declare function deepEqual(obj1: any, obj2: any): boolean;
 export declare const INT32_MAX: number;
-//# sourceMappingURL=utils.d.ts.map

package/lib/typescript/utils.js

@@ -0,0 +1,80 @@
+import React from 'react';
+export function toArray(object) {
+    if (!Array.isArray(object)) {
+        return [object];
+    }
+    return object;
+}
+export function withPrevAndCurrent(array, mapFn) {
+    const previousArr = [null];
+    const currentArr = [...array];
+    const transformedArr = [];
+    currentArr.forEach((current, i) => {
+        // This type cast is fine and solves problem mentioned in https://github.com/software-mansion/react-native-gesture-handler/pull/2867 (namely that `previous` can be undefined).
+        // Unfortunately, linter on our CI does not allow this type of casting as it is unnecessary. To bypass that we use eslint-disable.
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        const previous = previousArr[i];
+        const transformed = mapFn(previous, current);
+        previousArr.push(transformed);
+        transformedArr.push(transformed);
+    });
+    return transformedArr;
+}
+export function hasProperty(object, key) {
+    return Object.prototype.hasOwnProperty.call(object, key);
+}
+export function isTestEnv() {
+    // @ts-ignore Do not use `@types/node` because it will prioritise Node types over RN types which breaks the types (ex. setTimeout) in React Native projects.
+    return hasProperty(global, 'process') && process.env.NODE_ENV === 'test';
+}
+export function tagMessage(msg) {
+    return `[react-native-gesture-handler] ${msg}`;
+}
+// Helper method to check whether Fabric is enabled, however global.nativeFabricUIManager
+// may not be initialized before the first render
+export function isFabric() {
+    // @ts-expect-error nativeFabricUIManager is not yet included in the RN types
+    return !!global?.nativeFabricUIManager;
+}
+export function isReact19() {
+    return React.version.startsWith('19.');
+}
+export function isRemoteDebuggingEnabled() {
+    // react-native-reanimated checks if in remote debugging in the same way
+    // @ts-ignore global is available but node types are not included
+    const localGlobal = global;
+    return ((!localGlobal.nativeCallSyncHook || !!localGlobal.__REMOTEDEV__) &&
+        !localGlobal.RN$Bridgeless);
+}
+/**
+ * Recursively compares two objects for deep equality.
+ *
+ * **Note:** This function does not support cyclic references.
+ *
+ * @param obj1 - The first object to compare.
+ * @param obj2 - The second object to compare.
+ * @returns `true` if the objects are deeply equal, `false` otherwise.
+ */
+export function deepEqual(obj1, obj2) {
+    if (obj1 === obj2) {
+        return true;
+    }
+    if (typeof obj1 !== 'object' ||
+        typeof obj2 !== 'object' ||
+        obj1 === null ||
+        obj2 === null) {
+        return false;
+    }
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (const key of keys1) {
+        if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+export const INT32_MAX = 2 ** 31 - 1;

package/lib/typescript/web/Gestures.d.ts

@@ -34,4 +34,3 @@ export declare const HammerGestures: {
     RotationGestureHandler: typeof HammerRotationGestureHandler;
     FlingGestureHandler: typeof HammerFlingGestureHandler;
 };
-//# sourceMappingURL=Gestures.d.ts.map

package/lib/typescript/web/Gestures.js

@@ -0,0 +1,38 @@
+// Gesture Handlers
+import PanGestureHandler from './handlers/PanGestureHandler';
+import TapGestureHandler from './handlers/TapGestureHandler';
+import LongPressGestureHandler from './handlers/LongPressGestureHandler';
+import PinchGestureHandler from './handlers/PinchGestureHandler';
+import RotationGestureHandler from './handlers/RotationGestureHandler';
+import FlingGestureHandler from './handlers/FlingGestureHandler';
+import NativeViewGestureHandler from './handlers/NativeViewGestureHandler';
+import ManualGestureHandler from './handlers/ManualGestureHandler';
+import HoverGestureHandler from './handlers/HoverGestureHandler';
+// Hammer Handlers
+import HammerNativeViewGestureHandler from '../web_hammer/NativeViewGestureHandler';
+import HammerPanGestureHandler from '../web_hammer/PanGestureHandler';
+import HammerTapGestureHandler from '../web_hammer/TapGestureHandler';
+import HammerLongPressGestureHandler from '../web_hammer/LongPressGestureHandler';
+import HammerPinchGestureHandler from '../web_hammer/PinchGestureHandler';
+import HammerRotationGestureHandler from '../web_hammer/RotationGestureHandler';
+import HammerFlingGestureHandler from '../web_hammer/FlingGestureHandler';
+export const Gestures = {
+    NativeViewGestureHandler,
+    PanGestureHandler,
+    TapGestureHandler,
+    LongPressGestureHandler,
+    PinchGestureHandler,
+    RotationGestureHandler,
+    FlingGestureHandler,
+    ManualGestureHandler,
+    HoverGestureHandler,
+};
+export const HammerGestures = {
+    NativeViewGestureHandler: HammerNativeViewGestureHandler,
+    PanGestureHandler: HammerPanGestureHandler,
+    TapGestureHandler: HammerTapGestureHandler,
+    LongPressGestureHandler: HammerLongPressGestureHandler,
+    PinchGestureHandler: HammerPinchGestureHandler,
+    RotationGestureHandler: HammerRotationGestureHandler,
+    FlingGestureHandler: HammerFlingGestureHandler,
+};

package/lib/typescript/web/constants.d.ts

@@ -1,3 +1,2 @@
 export declare const DEFAULT_TOUCH_SLOP = 15;
 export declare const MINIMAL_RECOGNIZABLE_MAGNITUDE = 0.1;
-//# sourceMappingURL=constants.d.ts.map

package/lib/typescript/web/constants.js

@@ -0,0 +1,2 @@
+export const DEFAULT_TOUCH_SLOP = 15;
+export const MINIMAL_RECOGNIZABLE_MAGNITUDE = 0.1;

package/lib/typescript/web/detectors/RotationGestureDetector.d.ts

@@ -28,4 +28,3 @@ export default class RotationGestureDetector implements RotationGestureListener
     get rotation(): number;
     get timeDelta(): number;
 }
-//# sourceMappingURL=RotationGestureDetector.d.ts.map

package/lib/typescript/web/detectors/RotationGestureDetector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RotationGestureDetector.d.ts","sourceRoot":"","sources":["../../../../src/web/detectors/RotationGestureDetector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAc,MAAM,eAAe,CAAC;AACzD,OAAO,cAAc,MAAM,yBAAyB,CAAC;AAErD,MAAM,WAAW,uBAAuB;IACtC,eAAe,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,OAAO,CAAC;IAChE,UAAU,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,OAAO,CAAC;IAC3D,aAAa,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,IAAI,CAAC;CAC5D;AAED,MAAM,CAAC,OAAO,OAAO,uBACnB,YAAW,uBAAuB;IAElC,eAAe,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,OAAO,CAAC;IAChE,UAAU,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,OAAO,CAAC;IAC3D,aAAa,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,IAAI,CAAC;IAE3D,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,YAAY,CAAK;IAEzB,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,SAAS,CAAK;IAEtB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAK;IAErB,OAAO,CAAC,YAAY,CAAS;IAE7B,OAAO,CAAC,WAAW,CAAwB;gBAE/B,SAAS,EAAE,uBAAuB;IAM9C,OAAO,CAAC,aAAa;IAqCrB,OAAO,CAAC,MAAM;IAUd,OAAO,CAAC,cAAc;IAWf,YAAY,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO;IAoDnE,KAAK,IAAI,IAAI;IAKpB,IAAW,OAAO,WAEjB;IAED,IAAW,OAAO,WAEjB;IAED,IAAW,QAAQ,WAElB;IAED,IAAW,SAAS,WAEnB;CACF"}
+{"version":3,"file":"RotationGestureDetector.d.ts","sourceRoot":"","sources":["../../../../src/web/detectors/RotationGestureDetector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAc,MAAM,eAAe,CAAC;AACzD,OAAO,cAAc,MAAM,yBAAyB,CAAC;AAErD,MAAM,WAAW,uBAAuB;IACtC,eAAe,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,OAAO,CAAC;IAChE,UAAU,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,OAAO,CAAC;IAC3D,aAAa,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,IAAI,CAAC;CAC5D;AAED,MAAM,CAAC,OAAO,OAAO,uBACnB,YAAW,uBAAuB;IAElC,eAAe,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,OAAO,CAAC;IAChE,UAAU,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,OAAO,CAAC;IAC3D,aAAa,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,IAAI,CAAC;IAE3D,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,YAAY,CAAK;IAEzB,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,SAAS,CAAK;IAEtB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAK;IAErB,OAAO,CAAC,YAAY,CAAS;IAE7B,OAAO,CAAC,WAAW,CAAwB;gBAE/B,SAAS,EAAE,uBAAuB;IAM9C,OAAO,CAAC,aAAa;IAyCrB,OAAO,CAAC,MAAM;IAUd,OAAO,CAAC,cAAc;IAWf,YAAY,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO;IAoDnE,KAAK,IAAI,IAAI;IAKpB,IAAW,OAAO,WAEjB;IAED,IAAW,OAAO,WAEjB;IAED,IAAW,QAAQ,WAElB;IAED,IAAW,SAAS,WAEnB;CACF"}