easy-gestures 2.0.47 → 2.0.49

package/lib/constants.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get MAXIMUM_SPREAD () {
+        return MAXIMUM_SPREAD;
+    },
+    get MAXIMUM_TAP_TIME () {
+        return MAXIMUM_TAP_TIME;
+    },
+    get MINIMUM_SWIPE_SPEED () {
+        return MINIMUM_SWIPE_SPEED;
+    },
+    get PI () {
+        return PI;
+    },
+    get PI_OVER_TWO () {
+        return PI_OVER_TWO;
+    },
+    get PRESS_DELAY () {
+        return PRESS_DELAY;
+    },
+    get TAP_DELAY () {
+        return TAP_DELAY;
+    }
+});
+const { PI } = Math;
+const TAP_DELAY = 250;
+const PRESS_DELAY = 750;
+const PI_OVER_TWO = PI / 2;
+const MAXIMUM_SPREAD = PI / 4;
+const MAXIMUM_TAP_TIME = 125;
+const MINIMUM_SWIPE_SPEED = 1;
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9jb25zdGFudHMuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmV4cG9ydCBjb25zdCB7IFBJIH0gPSBNYXRoO1xuXG5leHBvcnQgY29uc3QgVEFQX0RFTEFZID0gMjUwO1xuZXhwb3J0IGNvbnN0IFBSRVNTX0RFTEFZID0gNzUwO1xuZXhwb3J0IGNvbnN0IFBJX09WRVJfVFdPID0gUEkgLyAyO1xuZXhwb3J0IGNvbnN0IE1BWElNVU1fU1BSRUFEID0gUEkgLyA0O1xuZXhwb3J0IGNvbnN0IE1BWElNVU1fVEFQX1RJTUUgPSAxMjU7XG5leHBvcnQgY29uc3QgTUlOSU1VTV9TV0lQRV9TUEVFRCA9IDE7XG4iXSwibmFtZXMiOlsiTUFYSU1VTV9TUFJFQUQiLCJNQVhJTVVNX1RBUF9USU1FIiwiTUlOSU1VTV9TV0lQRV9TUEVFRCIsIlBJIiwiUElfT1ZFUl9UV08iLCJQUkVTU19ERUxBWSIsIlRBUF9ERUxBWSIsIk1hdGgiXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7OztRQU9hQTtlQUFBQTs7UUFDQUM7ZUFBQUE7O1FBQ0FDO2VBQUFBOztRQVBFQztlQUFBQTs7UUFJRkM7ZUFBQUE7O1FBREFDO2VBQUFBOztRQURBQztlQUFBQTs7O0FBRk4sTUFBTSxFQUFFSCxFQUFFLEVBQUUsR0FBR0k7QUFFZixNQUFNRCxZQUFZO0FBQ2xCLE1BQU1ELGNBQWM7QUFDcEIsTUFBTUQsY0FBY0QsS0FBSztBQUN6QixNQUFNSCxpQkFBaUJHLEtBQUs7QUFDNUIsTUFBTUYsbUJBQW1CO0FBQ3pCLE1BQU1DLHNCQUFzQiJ9

package/lib/customEventTypes.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DOUBLE_TAP_CUSTOM_EVENT_TYPE () {
+        return DOUBLE_TAP_CUSTOM_EVENT_TYPE;
+    },
+    get DRAG_DOWN_CUSTOM_EVENT_TYPE () {
+        return DRAG_DOWN_CUSTOM_EVENT_TYPE;
+    },
+    get DRAG_LEFT_CUSTOM_EVENT_TYPE () {
+        return DRAG_LEFT_CUSTOM_EVENT_TYPE;
+    },
+    get DRAG_RIGHT_CUSTOM_EVENT_TYPE () {
+        return DRAG_RIGHT_CUSTOM_EVENT_TYPE;
+    },
+    get DRAG_START_CUSTOM_EVENT_TYPE () {
+        return DRAG_START_CUSTOM_EVENT_TYPE;
+    },
+    get DRAG_UP_CUSTOM_EVENT_TYPE () {
+        return DRAG_UP_CUSTOM_EVENT_TYPE;
+    },
+    get PINCH_MOVE_CUSTOM_EVENT_TYPE () {
+        return PINCH_MOVE_CUSTOM_EVENT_TYPE;
+    },
+    get PINCH_START_CUSTOM_EVENT_TYPE () {
+        return PINCH_START_CUSTOM_EVENT_TYPE;
+    },
+    get PINCH_STOP_CUSTOM_EVENT_TYPE () {
+        return PINCH_STOP_CUSTOM_EVENT_TYPE;
+    },
+    get PRESS_CUSTOM_EVENT_TYPE () {
+        return PRESS_CUSTOM_EVENT_TYPE;
+    },
+    get SINGLE_TAP_CUSTOM_EVENT_TYPE () {
+        return SINGLE_TAP_CUSTOM_EVENT_TYPE;
+    },
+    get SWIPE_DOWN_CUSTOM_EVENT_TYPE () {
+        return SWIPE_DOWN_CUSTOM_EVENT_TYPE;
+    },
+    get SWIPE_LEFT_CUSTOM_EVENT_TYPE () {
+        return SWIPE_LEFT_CUSTOM_EVENT_TYPE;
+    },
+    get SWIPE_RIGHT_CUSTOM_EVENT_TYPE () {
+        return SWIPE_RIGHT_CUSTOM_EVENT_TYPE;
+    },
+    get SWIPE_UP_CUSTOM_EVENT_TYPE () {
+        return SWIPE_UP_CUSTOM_EVENT_TYPE;
+    }
+});
+const PRESS_CUSTOM_EVENT_TYPE = "press";
+const DRAG_UP_CUSTOM_EVENT_TYPE = "drag-up";
+const DRAG_DOWN_CUSTOM_EVENT_TYPE = "drag-down";
+const DRAG_LEFT_CUSTOM_EVENT_TYPE = "drag-left";
+const DRAG_RIGHT_CUSTOM_EVENT_TYPE = "drag-right";
+const DRAG_START_CUSTOM_EVENT_TYPE = "drag-start";
+const SWIPE_UP_CUSTOM_EVENT_TYPE = "swipe-up";
+const SWIPE_DOWN_CUSTOM_EVENT_TYPE = "swipe-down";
+const SWIPE_LEFT_CUSTOM_EVENT_TYPE = "swipe-left";
+const SWIPE_RIGHT_CUSTOM_EVENT_TYPE = "swipe-right";
+const PINCH_MOVE_CUSTOM_EVENT_TYPE = "pinch-move";
+const PINCH_START_CUSTOM_EVENT_TYPE = "pinch-start";
+const PINCH_STOP_CUSTOM_EVENT_TYPE = "pinch-stop";
+const SINGLE_TAP_CUSTOM_EVENT_TYPE = "single-tap";
+const DOUBLE_TAP_CUSTOM_EVENT_TYPE = "double-tap";
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/example/preamble.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _easy = require("easy");
+Object.assign(globalThis, {
+    React: _easy.React
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9leGFtcGxlL3ByZWFtYmxlLmpzIl0sInNvdXJjZXNDb250ZW50IjpbIlwidXNlIHN0cmljdFwiO1xuXG5pbXBvcnQgeyBSZWFjdCB9IGZyb20gXCJlYXN5XCI7XG5cbk9iamVjdC5hc3NpZ24oZ2xvYmFsVGhpcywge1xuICBSZWFjdFxufSk7XG4iXSwibmFtZXMiOlsiT2JqZWN0IiwiYXNzaWduIiwiZ2xvYmFsVGhpcyIsIlJlYWN0Il0sIm1hcHBpbmdzIjoiQUFBQTs7OztzQkFFc0I7QUFFdEJBLE9BQU9DLE1BQU0sQ0FBQ0MsWUFBWTtJQUN4QkMsT0FBQUEsV0FBSztBQUNQIn0=

package/lib/example/view.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _easywithstyle = /*#__PURE__*/ _interop_require_default(require("easy-with-style"));
+const _easy = require("easy");
+const _index = require("../index");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class View extends _easy.Element {
+    singleTapCustomHandler = (event, element, top, left)=>{
+        console.log("single tap");
+    };
+    doubleTapCustomHandler = (event, element, top, left)=>{
+        console.log("double tap");
+    };
+    pinchStartCustomHandler = (event, element)=>{
+        console.log("pinch start");
+    };
+    pinchMoveCustomHandler = (event, element, ratio)=>{
+        console.log("pinch move", ratio);
+    };
+    swipeRightCustomHandler = (event, element, top, left, speed)=>{
+        console.log("swipe right", speed);
+    };
+    swipeLeftCustomHandler = (event, element, top, left, speed)=>{
+        console.log("swipe left", speed);
+    };
+    dragDownCustomHandler = (event, element, top, left)=>{
+        console.log("drag down", top);
+    };
+    dragUpCustomHandler = (event, element, top, left)=>{
+        console.log("drag up", top);
+    };
+    didMount() {
+        this.onCustomDragUp(this.dragUpCustomHandler);
+        this.onCustomDragDown(this.dragDownCustomHandler);
+        this.onCustomSwipeLeft(this.swipeLeftCustomHandler);
+        this.onCustomSwipeRight(this.swipeRightCustomHandler);
+        this.onCustomPinchMove(this.pinchMoveCustomHandler);
+        this.onCustomPinchStart(this.pinchStartCustomHandler);
+        this.onCustomSingleTap(this.singleTapCustomHandler);
+        this.onCustomDoubleTap(this.doubleTapCustomHandler);
+        this.enableTouch();
+    }
+    willUnmount() {
+        this.disableTouch();
+        this.offCustomDragUp(this.dragUpCustomHandler);
+        this.offCustomDragDown(this.dragDownCustomHandler);
+        this.offCustomSwipeLeft(this.swipeLeftCustomHandler);
+        this.offCustomSwipeRight(this.swipeRightCustomHandler);
+        this.offCustomPinchMove(this.pinchMoveCustomHandler);
+        this.offCustomPinchStart(this.pinchStartCustomHandler);
+        this.offCustomSingleTap(this.singleTapCustomHandler);
+        this.offCustomDoubleTap(this.doubleTapCustomHandler);
+    }
+    static tagName = "div";
+    static defaultProperties = {
+        className: "view"
+    };
+}
+Object.assign(View.prototype, _index.touchMixins);
+const _default = (0, _easywithstyle.default)(View)`
+  
+  width: 100%;
+  height: 100%;
+  display: flex;
+  align-items: center;
+  touch-action: none;
+  justify-content: center;
+  
+`;
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/example.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+require("./example/preamble");
+const _easywithstyle = /*#__PURE__*/ _interop_require_default(require("easy-with-style"));
+const _easy = require("easy");
+const _view = /*#__PURE__*/ _interop_require_default(require("./example/view"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const { renderStyles } = _easywithstyle.default;
+const body = new _easy.Body(), view = /*#__PURE__*/ React.createElement(_view.default, null);
+renderStyles();
+body.mount(view);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9leGFtcGxlLmpzIl0sInNvdXJjZXNDb250ZW50IjpbIlwidXNlIHN0cmljdFwiO1xuXG5pbXBvcnQgXCIuL2V4YW1wbGUvcHJlYW1ibGVcIjtcblxuaW1wb3J0IHdpdGhTdHlsZSBmcm9tIFwiZWFzeS13aXRoLXN0eWxlXCI7ICAvLy9cblxuaW1wb3J0IHsgQm9keSB9IGZyb20gXCJlYXN5XCI7XG5cbmltcG9ydCBWaWV3IGZyb20gXCIuL2V4YW1wbGUvdmlld1wiO1xuXG5jb25zdCB7IHJlbmRlclN0eWxlcyB9ID0gd2l0aFN0eWxlO1xuXG5jb25zdCBib2R5ID0gbmV3IEJvZHkoKSxcbiAgICAgIHZpZXcgPVxuXG4gICAgICAgIDxWaWV3Lz5cblxuICAgICAgO1xuXG5yZW5kZXJTdHlsZXMoKTtcblxuYm9keS5tb3VudCh2aWV3KTtcbiJdLCJuYW1lcyI6WyJyZW5kZXJTdHlsZXMiLCJ3aXRoU3R5bGUiLCJib2R5IiwiQm9keSIsInZpZXciLCJWaWV3IiwibW91bnQiXSwibWFwcGluZ3MiOiJBQUFBOzs7O1FBRU87c0VBRWU7c0JBRUQ7NkRBRUo7Ozs7OztBQUVqQixNQUFNLEVBQUVBLFlBQVksRUFBRSxHQUFHQyxzQkFBUztBQUVsQyxNQUFNQyxPQUFPLElBQUlDLFVBQUksSUFDZkMscUJBRUUsb0JBQUNDLGFBQUk7QUFJYkw7QUFFQUUsS0FBS0ksS0FBSyxDQUFDRiJ9

package/lib/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "touchMixins", {
+    enumerable: true,
+    get: function() {
+        return _touch.default;
+    }
+});
+const _touch = /*#__PURE__*/ _interop_require_default(require("./mixins/touch"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuZXhwb3J0IHsgZGVmYXVsdCBhcyB0b3VjaE1peGlucyB9IGZyb20gXCIuL21peGlucy90b3VjaFwiO1xuIl0sIm5hbWVzIjpbInRvdWNoTWl4aW5zIl0sIm1hcHBpbmdzIjoiQUFBQTs7OzsrQkFFb0JBOzs7ZUFBQUEsY0FBVzs7OzhEQUFRIn0=

package/lib/mixins/touch.js

@@ -0,0 +1,477 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _easy = require("easy");
+const _necessary = require("necessary");
+const _relative = /*#__PURE__*/ _interop_require_default(require("../position/relative"));
+const _constants = require("../constants");
+const _positions = require("../utilities/positions");
+const _customEventTypes = require("../customEventTypes");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const { push, first, second } = _necessary.arrayUtilities;
+function enableTouch() {
+    const tapInterval = null, startMagnitude = null, startPositions = [], movingPositions = [];
+    this.updateState({
+        tapInterval,
+        startMagnitude,
+        startPositions,
+        movingPositions
+    });
+    this.onMouseDown(this.mouseDownHandler);
+    this.onMouseMove(this.mouseMoveHandler);
+    _easy.window.onMouseUp(this.mouseUpHandler, this);
+    this.onTouchStart(this.touchStartHandler);
+    this.onTouchMove(this.touchMoveHandler);
+    this.onTouchEnd(this.touchEndHandler);
+}
+function disableTouch() {
+    this.offMouseDown(this.mouseDownHandler);
+    this.offMouseMove(this.mouseMoveHandler);
+    _easy.window.offMouseUp(this.mouseUpHandler, this);
+    this.offTouchStart(this.touchStartHandler);
+    this.offTouchMove(this.touchMoveHandler);
+    this.offTouchEnd(this.touchEndHandler);
+}
+function onCustomPress(pressCustomHandler, element) {
+    const customEventType = _customEventTypes.PRESS_CUSTOM_EVENT_TYPE, customHandler = pressCustomHandler; ///
+    this.onCustomEvent(customEventType, customHandler, element);
+}
+function offCustomPress(pressCustomHandler, element) {
+    const customEventType = _customEventTypes.PRESS_CUSTOM_EVENT_TYPE, customHandler = pressCustomHandler; ///
+    this.offCustomEvent(customEventType, customHandler, element);
+}
+function onCustomDragUp(dragUpCustomHandler, element) {
+    const customEventType = _customEventTypes.DRAG_UP_CUSTOM_EVENT_TYPE, customHandler = dragUpCustomHandler; ///
+    this.onCustomEvent(customEventType, customHandler, element);
+}
+function offCustomDragUp(dragUpCustomHandler, element) {
+    const customEventType = _customEventTypes.DRAG_UP_CUSTOM_EVENT_TYPE, customHandler = dragUpCustomHandler; ///
+    this.offCustomEvent(customEventType, customHandler, element);
+}
+function onCustomDragDown(dragDownCustomHandler, element) {
+    const customEventType = _customEventTypes.DRAG_DOWN_CUSTOM_EVENT_TYPE, customHandler = dragDownCustomHandler; ///
+    this.onCustomEvent(customEventType, customHandler, element);
+}
+function offCustomDragDown(dragDownCustomHandler, element) {
+    const customEventType = _customEventTypes.DRAG_DOWN_CUSTOM_EVENT_TYPE, customHandler = dragDownCustomHandler; ///
+    this.offCustomEvent(customEventType, customHandler, element);
+}
+function onCustomDragLeft(dragLeftCustomHandler, element) {
+    const customEventType = _customEventTypes.DRAG_LEFT_CUSTOM_EVENT_TYPE, customHandler = dragLeftCustomHandler; ///
+    this.onCustomEvent(customEventType, customHandler, element);
+}
+function offCustomDragLeft(dragLeftCustomHandler, element) {
+    const customEventType = _customEventTypes.DRAG_LEFT_CUSTOM_EVENT_TYPE, customHandler = dragLeftCustomHandler; ///
+    this.offCustomEvent(customEventType, customHandler, element);
+}
+function onCustomDragRight(dragRightCustomHandler, element) {
+    const customEventType = _customEventTypes.DRAG_RIGHT_CUSTOM_EVENT_TYPE, customHandler = dragRightCustomHandler; ///
+    this.onCustomEvent(customEventType, customHandler, element);
+}
+function offCustomDragRight(dragRightCustomHandler, element) {
+    const customEventType = _customEventTypes.DRAG_RIGHT_CUSTOM_EVENT_TYPE, customHandler = dragRightCustomHandler; ///
+    this.offCustomEvent(customEventType, customHandler, element);
+}
+function onCustomDragStart(dragStartCustomHandler, element) {
+    const customEventType = _customEventTypes.DRAG_START_CUSTOM_EVENT_TYPE, customHandler = dragStartCustomHandler; ///
+    this.onCustomEvent(customEventType, customHandler, element);
+}
+function offCustomDragStart(dragStartCustomHandler, element) {
+    const customEventType = _customEventTypes.DRAG_START_CUSTOM_EVENT_TYPE, customHandler = dragStartCustomHandler; ///
+    this.offCustomEvent(customEventType, customHandler, element);
+}
+function onCustomSwipeUp(swipeUpCustomHandler, element) {
+    const customEventType = _customEventTypes.SWIPE_UP_CUSTOM_EVENT_TYPE, customHandler = swipeUpCustomHandler; ///
+    this.onCustomEvent(customEventType, customHandler, element);
+}
+function offCustomSwipeUp(swipeUpCustomHandler, element) {
+    const customEventType = _customEventTypes.SWIPE_UP_CUSTOM_EVENT_TYPE, customHandler = swipeUpCustomHandler; ///
+    this.offCustomEvent(customEventType, customHandler, element);
+}
+function onCustomSwipeDown(swipeDownCustomHandler, element) {
+    const customEventType = _customEventTypes.SWIPE_DOWN_CUSTOM_EVENT_TYPE, customHandler = swipeDownCustomHandler; ///
+    this.onCustomEvent(customEventType, customHandler, element);
+}
+function offCustomSwipeDown(swipeDownCustomHandler, element) {
+    const customEventType = _customEventTypes.SWIPE_DOWN_CUSTOM_EVENT_TYPE, customHandler = swipeDownCustomHandler; ///
+    this.offCustomEvent(customEventType, customHandler, element);
+}
+function onCustomSwipeLeft(swipeLeftCustomHandler, element) {
+    const customEventType = _customEventTypes.SWIPE_LEFT_CUSTOM_EVENT_TYPE, customHandler = swipeLeftCustomHandler; ///
+    this.onCustomEvent(customEventType, customHandler, element);
+}
+function offCustomSwipeLeft(swipeLeftCustomHandler, element) {
+    const customEventType = _customEventTypes.SWIPE_LEFT_CUSTOM_EVENT_TYPE, customHandler = swipeLeftCustomHandler; ///
+    this.offCustomEvent(customEventType, customHandler, element);
+}
+function onCustomSwipeRight(swipeRightCustomHandler, element) {
+    const customEventType = _customEventTypes.SWIPE_RIGHT_CUSTOM_EVENT_TYPE, customHandler = swipeRightCustomHandler; ///
+    this.onCustomEvent(customEventType, customHandler, element);
+}
+function offCustomSwipeRight(swipeRightCustomHandler, element) {
+    const customEventType = _customEventTypes.SWIPE_RIGHT_CUSTOM_EVENT_TYPE, customHandler = swipeRightCustomHandler; ///
+    this.offCustomEvent(customEventType, customHandler, element);
+}
+function onCustomPinchMove(pinchMoveCustomHandler, element) {
+    const customEventType = _customEventTypes.PINCH_MOVE_CUSTOM_EVENT_TYPE, customHandler = pinchMoveCustomHandler; ///
+    this.onCustomEvent(customEventType, customHandler, element);
+}
+function offCustomPinchMove(pinchMoveCustomHandler, element) {
+    const customEventType = _customEventTypes.PINCH_MOVE_CUSTOM_EVENT_TYPE, customHandler = pinchMoveCustomHandler; ///
+    this.offCustomEvent(customEventType, customHandler, element);
+}
+function onCustomPinchStart(pinchStartCustomHandler, element) {
+    const customEventType = _customEventTypes.PINCH_START_CUSTOM_EVENT_TYPE, customHandler = pinchStartCustomHandler; ///
+    this.onCustomEvent(customEventType, customHandler, element);
+}
+function offCustomPinchStart(pinchStartCustomHandler, element) {
+    const customEventType = _customEventTypes.PINCH_START_CUSTOM_EVENT_TYPE, customHandler = pinchStartCustomHandler; ///
+    this.offCustomEvent(customEventType, customHandler, element);
+}
+function onCustomPinchStop(pinchStopCustomHandler, element) {
+    const customEventType = _customEventTypes.PINCH_STOP_CUSTOM_EVENT_TYPE, customHandler = pinchStopCustomHandler; ///
+    this.onCustomEvent(customEventType, customHandler, element);
+}
+function offCustomPinchStop(pinchStopCustomHandler, element) {
+    const customEventType = _customEventTypes.PINCH_STOP_CUSTOM_EVENT_TYPE, customHandler = pinchStopCustomHandler; ///
+    this.offCustomEvent(customEventType, customHandler, element);
+}
+function onCustomSingleTap(singleTapCustomHandler, element) {
+    const customEventType = _customEventTypes.SINGLE_TAP_CUSTOM_EVENT_TYPE, customHandler = singleTapCustomHandler; ///
+    this.onCustomEvent(customEventType, customHandler, element);
+}
+function offCustomSingleTap(singleTapCustomHandler, element) {
+    const customEventType = _customEventTypes.SINGLE_TAP_CUSTOM_EVENT_TYPE, customHandler = singleTapCustomHandler; ///
+    this.offCustomEvent(customEventType, customHandler, element);
+}
+function onCustomDoubleTap(doubleTapCustomHandler, element) {
+    const customEventType = _customEventTypes.DOUBLE_TAP_CUSTOM_EVENT_TYPE, customHandler = doubleTapCustomHandler; ///
+    this.onCustomEvent(customEventType, customHandler, element);
+}
+function offCustomDoubleTap(doubleTapCustomHandler, element) {
+    const customEventType = _customEventTypes.DOUBLE_TAP_CUSTOM_EVENT_TYPE, customHandler = doubleTapCustomHandler; ///
+    this.offCustomEvent(customEventType, customHandler, element);
+}
+function getTapInterval() {
+    const { tapInterval } = this.getState();
+    return tapInterval;
+}
+function getPressSInterval() {
+    const { pressInterval } = this.getState();
+    return pressInterval;
+}
+function getStartMagnitude() {
+    const { startMagnitude } = this.getState();
+    return startMagnitude;
+}
+function getStartPositions() {
+    const { startPositions } = this.getState();
+    return startPositions;
+}
+function getMovingPositions() {
+    const { movingPositions } = this.getState();
+    return movingPositions;
+}
+function setTapInterval(tapInterval) {
+    this.updateState({
+        tapInterval
+    });
+}
+function setPressSInterval(pressInterval) {
+    this.updateState({
+        pressInterval
+    });
+}
+function setStartMagnitude(startMagnitude) {
+    this.updateState({
+        startMagnitude
+    });
+}
+function setStartPositions(startPositions) {
+    this.updateState({
+        startPositions
+    });
+}
+function setMovingPositions(movingPositions) {
+    this.updateState({
+        movingPositions
+    });
+}
+function touchStartHandler(event, element) {
+    this.startHandler(event, element, (event)=>{
+        const touchEvent = event, changed = false, positions = (0, _positions.positionsFromTouchEvent)(touchEvent, changed);
+        return positions;
+    });
+}
+function mouseDownHandler(event, element) {
+    this.startHandler(event, element, (event)=>{
+        const mouseEvent = event, positions = (0, _positions.positionsFromMouseEvent)(mouseEvent);
+        return positions;
+    });
+}
+function touchMoveHandler(event, element) {
+    this.moveHandler(event, element, (event)=>{
+        const touchEvent = event, changed = false, positions = (0, _positions.positionsFromTouchEvent)(touchEvent, changed);
+        return positions;
+    });
+}
+function mouseMoveHandler(event, element) {
+    this.moveHandler(event, element, (event)=>{
+        const mouseEvent = event, positions = (0, _positions.positionsFromMouseEvent)(mouseEvent);
+        return positions;
+    });
+}
+function touchEndHandler(event, element) {
+    this.endHandler(event, element, (event)=>{
+        const touchEvent = event, changed = true, positions = (0, _positions.positionsFromTouchEvent)(touchEvent, changed);
+        return positions;
+    });
+}
+function mouseUpHandler(event, element) {
+    this.endHandler(event, element, (event)=>{
+        const mouseEvent = event, positions = (0, _positions.positionsFromMouseEvent)(mouseEvent);
+        return positions;
+    });
+}
+function startHandler(event, element, positionsFromEvent) {
+    const positions = positionsFromEvent(event), startPositions = this.getStartPositions();
+    (0, _positions.filterPositions)(startPositions, positions);
+    push(startPositions, positions);
+    const startingPositionsLength = startPositions.length;
+    if (startingPositionsLength === 1) {
+        this.dragStart(event, element);
+        const interval = setTimeout(()=>{
+            const pressInterval = null;
+            this.setPressSInterval(pressInterval);
+            this.press(event, element);
+        }, _constants.PRESS_DELAY);
+        const pressInterval = interval; ///
+        this.setPressSInterval(pressInterval);
+    }
+    if (startingPositionsLength === 2) {
+        this.pinchStart(event, element);
+    }
+}
+function moveHandler(event, element, positionsFromEvent) {
+    const positions = positionsFromEvent(event), startPositions = this.getStartPositions(), movingPositions = this.getMovingPositions();
+    (0, _positions.filterPositions)(movingPositions, positions);
+    push(movingPositions, positions);
+    const positionsMatch = (0, _positions.matchPositions)(startPositions, movingPositions);
+    if (positionsMatch) {
+        (0, _positions.sortPositions)(movingPositions, startPositions);
+        const movingPositionsLength = movingPositions.length;
+        if (movingPositionsLength === 1) {
+            this.drag(event, element);
+        }
+        if (movingPositionsLength === 2) {
+            this.pinch(event, element);
+        }
+    }
+    let pressInterval = this.getPressSInterval();
+    if (pressInterval !== null) {
+        clearTimeout(pressInterval);
+        pressInterval = null;
+        this.setPressSInterval(pressInterval);
+    }
+}
+function endHandler(event, element, positionsFromEvent) {
+    const positions = positionsFromEvent(event), startPositions = this.getStartPositions(), movingPositions = this.getMovingPositions(), positionsMatch = (0, _positions.matchPositions)(startPositions, movingPositions);
+    if (positionsMatch) {
+        const startPositionsLength = startPositions.length;
+        if (startPositionsLength === 2) {
+            this.pinchStop(event, element);
+        }
+        if (startPositionsLength === 1) {
+            this.possibleTap(event, element);
+            this.possibleSwipe(event, element);
+        }
+    }
+    (0, _positions.filterPositions)(startPositions, positions);
+    (0, _positions.filterPositions)(movingPositions, positions);
+    let pressInterval = this.getPressSInterval();
+    if (pressInterval !== null) {
+        clearTimeout(pressInterval);
+        pressInterval = null;
+        this.setPressSInterval(pressInterval);
+    }
+}
+function possibleTap(event, element) {
+    const startPositions = this.getStartPositions(), movingPositions = this.getMovingPositions(), firstStartPosition = first(startPositions), firstMovingPosition = first(movingPositions), firstPosition = firstStartPosition, secondPosition = firstMovingPosition, relativePosition = _relative.default.fromFirstPositionAndSecondPosition(firstPosition, secondPosition), time = relativePosition.getTime(), speed = relativePosition.getSpeed();
+    if (speed === 0 && time < _constants.MAXIMUM_TAP_TIME) {
+        this.tap(event, element);
+    }
+}
+function possibleSwipe(event, element) {
+    const startPositions = this.getStartPositions(), movingPositions = this.getMovingPositions(), firstStartPosition = first(startPositions), firstMovingPosition = first(movingPositions), firstPosition = firstStartPosition, secondPosition = firstMovingPosition, relativePosition = _relative.default.fromFirstPositionAndSecondPosition(firstPosition, secondPosition), direction = relativePosition.getDirection(), speed = relativePosition.getSpeed();
+    if (speed > _constants.MINIMUM_SWIPE_SPEED) {
+        this.swipe(event, element, speed, direction);
+    }
+}
+function tap(event, element) {
+    const startPositions = this.getStartPositions(), firstStartPosition = first(startPositions), startPosition = firstStartPosition, top = startPosition.getTop(), left = startPosition.getLeft();
+    let tapInterval = this.getTapInterval();
+    if (tapInterval !== null) {
+        clearTimeout(tapInterval);
+        tapInterval = null;
+        this.setTapInterval(tapInterval);
+        this.doubleTap(event, element, top, left);
+        return;
+    }
+    const interval = setTimeout(()=>{
+        tapInterval = null;
+        this.setTapInterval(tapInterval);
+        this.singleTap(event, element, top, left);
+    }, _constants.TAP_DELAY);
+    tapInterval = interval; ///
+    this.setTapInterval(tapInterval);
+}
+function drag(event, element) {
+    const startPositions = this.getStartPositions(), movingPositions = this.getMovingPositions(), firstStartPosition = first(startPositions), firstMovingPosition = first(movingPositions), firstPosition = firstStartPosition, secondPosition = firstMovingPosition, relativePosition = _relative.default.fromFirstPositionAndSecondPosition(firstPosition, secondPosition), top = relativePosition.getTop(), left = relativePosition.getLeft(), direction = relativePosition.getDirection();
+    let customEventType = null;
+    if (Math.abs(direction) < _constants.MAXIMUM_SPREAD) {
+        customEventType = _customEventTypes.DRAG_RIGHT_CUSTOM_EVENT_TYPE;
+    }
+    if (Math.abs(_constants.PI_OVER_TWO - direction) < _constants.MAXIMUM_SPREAD) {
+        customEventType = _customEventTypes.DRAG_UP_CUSTOM_EVENT_TYPE;
+    }
+    if (Math.abs(-_constants.PI_OVER_TWO - direction) < _constants.MAXIMUM_SPREAD) {
+        customEventType = _customEventTypes.DRAG_DOWN_CUSTOM_EVENT_TYPE;
+    }
+    if (_constants.PI - Math.abs(direction) < _constants.MAXIMUM_SPREAD) {
+        customEventType = _customEventTypes.DRAG_LEFT_CUSTOM_EVENT_TYPE;
+    }
+    if (customEventType !== null) {
+        this.callCustomHandlers(customEventType, event, element, top, left);
+    }
+}
+function pinch(event, element) {
+    const movingPositions = this.getMovingPositions(), firstMovingPosition = first(movingPositions), secondMovingPosition = second(movingPositions), relativeMovingPosition = _relative.default.fromFirstPositionAndSecondPosition(firstMovingPosition, secondMovingPosition), customEventType = _customEventTypes.PINCH_MOVE_CUSTOM_EVENT_TYPE, startMagnitude = this.getStartMagnitude(), magnitude = relativeMovingPosition.getMagnitude(), ratio = magnitude / startMagnitude;
+    this.callCustomHandlers(customEventType, event, element, ratio);
+}
+function press(event, element) {
+    const customEventType = _customEventTypes.PRESS_CUSTOM_EVENT_TYPE;
+    this.callCustomHandlers(customEventType, event, element);
+}
+function swipe(event, element, speed, direction) {
+    let customEventType = null;
+    if (Math.abs(direction) < _constants.MAXIMUM_SPREAD) {
+        customEventType = _customEventTypes.SWIPE_RIGHT_CUSTOM_EVENT_TYPE;
+        speed = speed * Math.abs(Math.cos(direction));
+    }
+    if (Math.abs(_constants.PI_OVER_TWO - direction) < _constants.MAXIMUM_SPREAD) {
+        customEventType = _customEventTypes.SWIPE_UP_CUSTOM_EVENT_TYPE;
+        speed = speed * Math.abs(Math.sin(direction));
+    }
+    if (Math.abs(-_constants.PI_OVER_TWO - direction) < _constants.MAXIMUM_SPREAD) {
+        customEventType = _customEventTypes.SWIPE_DOWN_CUSTOM_EVENT_TYPE;
+        speed = speed * Math.abs(Math.sin(direction));
+    }
+    if (_constants.PI - Math.abs(direction) < _constants.MAXIMUM_SPREAD) {
+        customEventType = _customEventTypes.SWIPE_LEFT_CUSTOM_EVENT_TYPE;
+        speed = speed * Math.abs(Math.cos(direction));
+    }
+    if (customEventType !== null) {
+        const startPositions = this.getStartPositions(), firstStartPosition = first(startPositions), startPosition = firstStartPosition, top = startPosition.getTop(), left = startPosition.getLeft();
+        this.callCustomHandlers(customEventType, event, element, top, left, speed);
+    }
+}
+function singleTap(event, element, top, left) {
+    const customEventType = _customEventTypes.SINGLE_TAP_CUSTOM_EVENT_TYPE;
+    this.callCustomHandlers(customEventType, event, element, top, left); ///
+}
+function doubleTap(event, element, top, left) {
+    const customEventType = _customEventTypes.DOUBLE_TAP_CUSTOM_EVENT_TYPE;
+    this.callCustomHandlers(customEventType, event, element, top, left);
+}
+function dragStart(event, element) {
+    const customEventType = _customEventTypes.DRAG_START_CUSTOM_EVENT_TYPE, startPositions = this.getStartPositions(), firstStartPosition = first(startPositions), startPosition = firstStartPosition, top = startPosition.getTop(), left = startPosition.getLeft();
+    this.callCustomHandlers(customEventType, event, element, top, left);
+}
+function pinchStart(event, element) {
+    const customEventType = _customEventTypes.PINCH_START_CUSTOM_EVENT_TYPE, startPositions = this.getStartPositions(), firstStartPosition = first(startPositions), secondStartPosition = second(startPositions), relativeStartPosition = _relative.default.fromFirstPositionAndSecondPosition(firstStartPosition, secondStartPosition), magnitude = relativeStartPosition.getMagnitude(), startMagnitude = magnitude; ///
+    this.setStartMagnitude(startMagnitude);
+    this.callCustomHandlers(customEventType, event, element);
+}
+function pinchStop(event, element) {
+    const customEventType = _customEventTypes.PINCH_STOP_CUSTOM_EVENT_TYPE;
+    this.callCustomHandlers(customEventType, event, element);
+}
+const touchMixins = {
+    enableTouch,
+    disableTouch,
+    onCustomPress,
+    offCustomPress,
+    onCustomDragUp,
+    offCustomDragUp,
+    onCustomDragDown,
+    offCustomDragDown,
+    onCustomDragLeft,
+    offCustomDragLeft,
+    onCustomDragRight,
+    offCustomDragRight,
+    onCustomDragStart,
+    offCustomDragStart,
+    onCustomSwipeUp,
+    offCustomSwipeUp,
+    onCustomSwipeDown,
+    offCustomSwipeDown,
+    onCustomSwipeLeft,
+    offCustomSwipeLeft,
+    onCustomSwipeRight,
+    offCustomSwipeRight,
+    onCustomPinchMove,
+    offCustomPinchMove,
+    onCustomPinchStart,
+    offCustomPinchStart,
+    onCustomPinchStop,
+    offCustomPinchStop,
+    onCustomSingleTap,
+    offCustomSingleTap,
+    onCustomDoubleTap,
+    offCustomDoubleTap,
+    getTapInterval,
+    getPressSInterval,
+    getStartMagnitude,
+    getStartPositions,
+    getMovingPositions,
+    setTapInterval,
+    setPressSInterval,
+    setStartMagnitude,
+    setStartPositions,
+    setMovingPositions,
+    touchStartHandler,
+    mouseDownHandler,
+    touchMoveHandler,
+    mouseMoveHandler,
+    touchEndHandler,
+    mouseUpHandler,
+    startHandler,
+    moveHandler,
+    endHandler,
+    possibleTap,
+    possibleSwipe,
+    tap,
+    drag,
+    pinch,
+    press,
+    swipe,
+    singleTap,
+    doubleTap,
+    dragStart,
+    pinchStart,
+    pinchStop
+};
+const _default = touchMixins;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/mixins/touch.js"],"sourcesContent":["\"use strict\";\n\nimport { window } from \"easy\";\nimport { arrayUtilities } from \"necessary\";\n\nimport RelativePosition from \"../position/relative\";\n\nimport { PI, TAP_DELAY, PRESS_DELAY, PI_OVER_TWO, MAXIMUM_TAP_TIME, MINIMUM_SWIPE_SPEED, MAXIMUM_SPREAD } from \"../constants\";\nimport { sortPositions, matchPositions, filterPositions, positionsFromMouseEvent, positionsFromTouchEvent } from \"../utilities/positions\";\nimport { PRESS_CUSTOM_EVENT_TYPE,\n         DRAG_UP_CUSTOM_EVENT_TYPE,\n         DRAG_DOWN_CUSTOM_EVENT_TYPE,\n         DRAG_LEFT_CUSTOM_EVENT_TYPE,\n         DRAG_RIGHT_CUSTOM_EVENT_TYPE,\n         DRAG_START_CUSTOM_EVENT_TYPE,\n         SWIPE_UP_CUSTOM_EVENT_TYPE,\n         SWIPE_DOWN_CUSTOM_EVENT_TYPE,\n         SWIPE_LEFT_CUSTOM_EVENT_TYPE,\n         SWIPE_RIGHT_CUSTOM_EVENT_TYPE,\n         PINCH_MOVE_CUSTOM_EVENT_TYPE,\n         PINCH_START_CUSTOM_EVENT_TYPE,\n         PINCH_STOP_CUSTOM_EVENT_TYPE,\n         SINGLE_TAP_CUSTOM_EVENT_TYPE,\n         DOUBLE_TAP_CUSTOM_EVENT_TYPE } from \"../customEventTypes\";\n\nconst { push, first, second } = arrayUtilities;\n\nfunction enableTouch() {\n  const tapInterval = null,\n        startMagnitude = null,\n        startPositions = [],\n        movingPositions = [];\n\n  this.updateState({\n    tapInterval,\n    startMagnitude,\n    startPositions,\n    movingPositions\n  });\n\n  this.onMouseDown(this.mouseDownHandler);\n  this.onMouseMove(this.mouseMoveHandler);\n\n  window.onMouseUp(this.mouseUpHandler, this);\n\n  this.onTouchStart(this.touchStartHandler);\n  this.onTouchMove(this.touchMoveHandler);\n  this.onTouchEnd(this.touchEndHandler);\n}\n\nfunction disableTouch() {\n  this.offMouseDown(this.mouseDownHandler);\n  this.offMouseMove(this.mouseMoveHandler);\n\n  window.offMouseUp(this.mouseUpHandler, this);\n\n  this.offTouchStart(this.touchStartHandler);\n  this.offTouchMove(this.touchMoveHandler);\n  this.offTouchEnd(this.touchEndHandler);\n}\n\nfunction onCustomPress(pressCustomHandler, element) {\n  const customEventType = PRESS_CUSTOM_EVENT_TYPE,\n        customHandler = pressCustomHandler; ///\n\n  this.onCustomEvent(customEventType, customHandler, element);\n}\n\nfunction offCustomPress(pressCustomHandler, element) {\n  const customEventType = PRESS_CUSTOM_EVENT_TYPE,\n        customHandler = pressCustomHandler; ///\n\n  this.offCustomEvent(customEventType, customHandler, element);\n}\n\nfunction onCustomDragUp(dragUpCustomHandler, element) {\n  const customEventType = DRAG_UP_CUSTOM_EVENT_TYPE,\n        customHandler = dragUpCustomHandler; ///\n\n  this.onCustomEvent(customEventType, customHandler, element);\n}\n\nfunction offCustomDragUp(dragUpCustomHandler, element) {\n  const customEventType = DRAG_UP_CUSTOM_EVENT_TYPE,\n        customHandler = dragUpCustomHandler; ///\n\n  this.offCustomEvent(customEventType, customHandler, element);\n}\n\nfunction onCustomDragDown(dragDownCustomHandler, element) {\n  const customEventType = DRAG_DOWN_CUSTOM_EVENT_TYPE,\n        customHandler = dragDownCustomHandler; ///\n\n  this.onCustomEvent(customEventType, customHandler, element);\n}\n\nfunction offCustomDragDown(dragDownCustomHandler, element) {\n  const customEventType = DRAG_DOWN_CUSTOM_EVENT_TYPE,\n        customHandler = dragDownCustomHandler; ///\n\n  this.offCustomEvent(customEventType, customHandler, element);\n}\n\nfunction onCustomDragLeft(dragLeftCustomHandler, element) {\n  const customEventType = DRAG_LEFT_CUSTOM_EVENT_TYPE,\n        customHandler = dragLeftCustomHandler; ///\n\n  this.onCustomEvent(customEventType, customHandler, element);\n}\n\nfunction offCustomDragLeft(dragLeftCustomHandler, element) {\n  const customEventType = DRAG_LEFT_CUSTOM_EVENT_TYPE,\n        customHandler = dragLeftCustomHandler; ///\n\n  this.offCustomEvent(customEventType, customHandler, element);\n}\n\nfunction onCustomDragRight(dragRightCustomHandler, element) {\n  const customEventType = DRAG_RIGHT_CUSTOM_EVENT_TYPE,\n        customHandler = dragRightCustomHandler; ///\n\n  this.onCustomEvent(customEventType, customHandler, element);\n}\n\nfunction offCustomDragRight(dragRightCustomHandler, element) {\n  const customEventType = DRAG_RIGHT_CUSTOM_EVENT_TYPE,\n        customHandler = dragRightCustomHandler; ///\n\n  this.offCustomEvent(customEventType, customHandler, element);\n}\n\nfunction onCustomDragStart(dragStartCustomHandler, element) {\n  const customEventType = DRAG_START_CUSTOM_EVENT_TYPE,\n        customHandler = dragStartCustomHandler; ///\n\n  this.onCustomEvent(customEventType, customHandler, element);\n}\n\nfunction offCustomDragStart(dragStartCustomHandler, element) {\n  const customEventType = DRAG_START_CUSTOM_EVENT_TYPE,\n        customHandler = dragStartCustomHandler; ///\n\n  this.offCustomEvent(customEventType, customHandler, element);\n}\n\nfunction onCustomSwipeUp(swipeUpCustomHandler, element) {\n  const customEventType = SWIPE_UP_CUSTOM_EVENT_TYPE,\n        customHandler = swipeUpCustomHandler; ///\n\n  this.onCustomEvent(customEventType, customHandler, element);\n}\n\nfunction offCustomSwipeUp(swipeUpCustomHandler, element) {\n  const customEventType = SWIPE_UP_CUSTOM_EVENT_TYPE,\n        customHandler = swipeUpCustomHandler; ///\n\n  this.offCustomEvent(customEventType, customHandler, element);\n}\n\nfunction onCustomSwipeDown(swipeDownCustomHandler, element) {\n  const customEventType = SWIPE_DOWN_CUSTOM_EVENT_TYPE,\n        customHandler = swipeDownCustomHandler; ///\n\n  this.onCustomEvent(customEventType, customHandler, element);\n}\n\nfunction offCustomSwipeDown(swipeDownCustomHandler, element) {\n  const customEventType = SWIPE_DOWN_CUSTOM_EVENT_TYPE,\n        customHandler = swipeDownCustomHandler; ///\n\n  this.offCustomEvent(customEventType, customHandler, element);\n}\n\nfunction onCustomSwipeLeft(swipeLeftCustomHandler, element) {\n  const customEventType = SWIPE_LEFT_CUSTOM_EVENT_TYPE,\n        customHandler = swipeLeftCustomHandler; ///\n\n  this.onCustomEvent(customEventType, customHandler, element);\n}\n\nfunction offCustomSwipeLeft(swipeLeftCustomHandler, element) {\n  const customEventType = SWIPE_LEFT_CUSTOM_EVENT_TYPE,\n        customHandler = swipeLeftCustomHandler; ///\n\n  this.offCustomEvent(customEventType, customHandler, element);\n}\n\nfunction onCustomSwipeRight(swipeRightCustomHandler, element) {\n  const customEventType = SWIPE_RIGHT_CUSTOM_EVENT_TYPE,\n        customHandler = swipeRightCustomHandler; ///\n\n  this.onCustomEvent(customEventType, customHandler, element);\n}\n\nfunction offCustomSwipeRight(swipeRightCustomHandler, element) {\n  const customEventType = SWIPE_RIGHT_CUSTOM_EVENT_TYPE,\n        customHandler = swipeRightCustomHandler; ///\n\n  this.offCustomEvent(customEventType, customHandler, element);\n}\n\nfunction onCustomPinchMove(pinchMoveCustomHandler, element) {\n  const customEventType = PINCH_MOVE_CUSTOM_EVENT_TYPE,\n        customHandler = pinchMoveCustomHandler; ///\n\n  this.onCustomEvent(customEventType, customHandler, element);\n}\n\nfunction offCustomPinchMove(pinchMoveCustomHandler, element) {\n  const customEventType = PINCH_MOVE_CUSTOM_EVENT_TYPE,\n        customHandler = pinchMoveCustomHandler; ///\n\n  this.offCustomEvent(customEventType, customHandler, element);\n}\n\nfunction onCustomPinchStart(pinchStartCustomHandler, element) {\n  const customEventType = PINCH_START_CUSTOM_EVENT_TYPE,\n        customHandler = pinchStartCustomHandler; ///\n\n  this.onCustomEvent(customEventType, customHandler, element);\n}\n\nfunction offCustomPinchStart(pinchStartCustomHandler, element) {\n  const customEventType = PINCH_START_CUSTOM_EVENT_TYPE,\n        customHandler = pinchStartCustomHandler; ///\n\n  this.offCustomEvent(customEventType, customHandler, element);\n}\n\nfunction onCustomPinchStop(pinchStopCustomHandler, element) {\n  const customEventType = PINCH_STOP_CUSTOM_EVENT_TYPE,\n        customHandler = pinchStopCustomHandler; ///\n\n  this.onCustomEvent(customEventType, customHandler, element);\n}\n\nfunction offCustomPinchStop(pinchStopCustomHandler, element) {\n  const customEventType = PINCH_STOP_CUSTOM_EVENT_TYPE,\n        customHandler = pinchStopCustomHandler; ///\n\n  this.offCustomEvent(customEventType, customHandler, element);\n}\n\nfunction onCustomSingleTap(singleTapCustomHandler, element) {\n  const customEventType = SINGLE_TAP_CUSTOM_EVENT_TYPE,\n        customHandler = singleTapCustomHandler; ///\n\n  this.onCustomEvent(customEventType, customHandler, element);\n}\n\nfunction offCustomSingleTap(singleTapCustomHandler, element) {\n  const customEventType = SINGLE_TAP_CUSTOM_EVENT_TYPE,\n        customHandler = singleTapCustomHandler; ///\n\n  this.offCustomEvent(customEventType, customHandler, element);\n}\n\nfunction onCustomDoubleTap(doubleTapCustomHandler, element) {\n  const customEventType = DOUBLE_TAP_CUSTOM_EVENT_TYPE,\n        customHandler = doubleTapCustomHandler; ///\n\n  this.onCustomEvent(customEventType, customHandler, element);\n}\n\nfunction offCustomDoubleTap(doubleTapCustomHandler, element) {\n  const customEventType = DOUBLE_TAP_CUSTOM_EVENT_TYPE,\n        customHandler = doubleTapCustomHandler; ///\n\n  this.offCustomEvent(customEventType, customHandler, element);\n}\n\nfunction getTapInterval() {\n  const { tapInterval } = this.getState();\n\n  return tapInterval;\n}\n\nfunction getPressSInterval() {\n  const { pressInterval } = this.getState();\n\n  return pressInterval;\n}\n\nfunction getStartMagnitude() {\n  const { startMagnitude } = this.getState();\n\n  return startMagnitude;\n}\n\nfunction getStartPositions() {\n  const { startPositions } = this.getState();\n\n  return startPositions;\n}\n\nfunction getMovingPositions() {\n  const { movingPositions } = this.getState();\n\n  return movingPositions;\n}\n\nfunction setTapInterval(tapInterval) {\n  this.updateState({\n    tapInterval\n  });\n}\n\nfunction setPressSInterval(pressInterval) {\n  this.updateState({\n    pressInterval\n  });\n}\n\nfunction setStartMagnitude(startMagnitude) {\n  this.updateState({\n    startMagnitude\n  });\n}\n\nfunction setStartPositions(startPositions) {\n  this.updateState({\n    startPositions\n  });\n}\n\nfunction setMovingPositions(movingPositions) {\n  this.updateState({\n    movingPositions\n  });\n}\n\nfunction touchStartHandler(event, element) {\n  this.startHandler(event, element, (event) => {\n    const touchEvent = event, ///\n          changed = false,\n          positions = positionsFromTouchEvent(touchEvent, changed);\n\n    return positions;\n  });\n}\n\nfunction mouseDownHandler(event, element) {\n  this.startHandler(event, element, (event) => {\n    const mouseEvent = event, ///\n          positions = positionsFromMouseEvent(mouseEvent);\n\n    return positions;\n  });\n}\n\nfunction touchMoveHandler(event, element) {\n  this.moveHandler(event, element, (event) => {\n    const touchEvent = event, ///\n          changed = false,\n          positions = positionsFromTouchEvent(touchEvent, changed);\n\n    return positions;\n  });\n}\n\nfunction mouseMoveHandler(event, element) {\n  this.moveHandler(event, element, (event) => {\n    const mouseEvent = event, ///\n          positions = positionsFromMouseEvent(mouseEvent);\n\n    return positions;\n  });\n}\n\nfunction touchEndHandler(event, element) {\n  this.endHandler(event, element, (event) => {\n    const touchEvent = event, ///\n          changed = true,\n          positions = positionsFromTouchEvent(touchEvent, changed);\n\n    return positions;\n  });\n}\n\nfunction mouseUpHandler(event, element) {\n  this.endHandler(event, element, (event) => {\n    const mouseEvent = event, ///\n          positions = positionsFromMouseEvent(mouseEvent);\n\n    return positions;\n  });\n}\n\nfunction startHandler(event, element, positionsFromEvent) {\n  const positions = positionsFromEvent(event),\n        startPositions = this.getStartPositions();\n\n  filterPositions(startPositions, positions);\n\n  push(startPositions, positions);\n\n  const startingPositionsLength = startPositions.length;\n\n  if (startingPositionsLength === 1) {\n    this.dragStart(event, element);\n\n    const interval = setTimeout(() => {\n      const pressInterval = null;\n\n      this.setPressSInterval(pressInterval);\n\n      this.press(event, element);\n    }, PRESS_DELAY);\n\n    const pressInterval = interval; ///\n\n    this.setPressSInterval(pressInterval);\n  }\n\n  if (startingPositionsLength === 2) {\n    this.pinchStart(event, element);\n  }\n}\n\nfunction moveHandler(event, element, positionsFromEvent) {\n  const positions = positionsFromEvent(event),\n        startPositions = this.getStartPositions(),\n        movingPositions = this.getMovingPositions();\n\n  filterPositions(movingPositions, positions);\n\n  push(movingPositions, positions);\n\n  const positionsMatch = matchPositions(startPositions, movingPositions);\n\n  if (positionsMatch) {\n    sortPositions(movingPositions, startPositions);\n\n    const movingPositionsLength = movingPositions.length;\n\n    if (movingPositionsLength === 1) {\n      this.drag(event, element);\n    }\n\n    if (movingPositionsLength === 2) {\n      this.pinch(event, element);\n    }\n  }\n\n  let pressInterval = this.getPressSInterval();\n\n  if (pressInterval !== null) {\n    clearTimeout(pressInterval);\n\n    pressInterval = null;\n\n    this.setPressSInterval(pressInterval);\n  }\n}\n\nfunction endHandler(event, element, positionsFromEvent) {\n  const positions = positionsFromEvent(event),\n        startPositions = this.getStartPositions(),\n        movingPositions = this.getMovingPositions(),\n        positionsMatch = matchPositions(startPositions, movingPositions);\n\n  if (positionsMatch) {\n    const startPositionsLength = startPositions.length;\n\n    if (startPositionsLength === 2) {\n      this.pinchStop(event, element);\n    }\n\n    if (startPositionsLength === 1) {\n      this.possibleTap(event, element);\n\n      this.possibleSwipe(event, element);\n    }\n  }\n\n  filterPositions(startPositions, positions);\n\n  filterPositions(movingPositions, positions);\n\n  let pressInterval = this.getPressSInterval();\n\n  if (pressInterval !== null) {\n    clearTimeout(pressInterval);\n\n    pressInterval = null;\n\n    this.setPressSInterval(pressInterval);\n  }\n}\n\nfunction possibleTap(event, element) {\n  const startPositions = this.getStartPositions(),\n        movingPositions = this.getMovingPositions(),\n        firstStartPosition = first(startPositions),\n        firstMovingPosition = first(movingPositions),\n        firstPosition = firstStartPosition, ///\n        secondPosition = firstMovingPosition, ///\n        relativePosition = RelativePosition.fromFirstPositionAndSecondPosition(firstPosition, secondPosition),\n        time = relativePosition.getTime(),\n        speed = relativePosition.getSpeed();\n\n  if ((speed === 0) && (time < MAXIMUM_TAP_TIME)){\n    this.tap(event, element);\n  }\n}\n\nfunction possibleSwipe(event, element) {\n  const startPositions = this.getStartPositions(),\n        movingPositions = this.getMovingPositions(),\n        firstStartPosition = first(startPositions),\n        firstMovingPosition = first(movingPositions),\n        firstPosition = firstStartPosition, ///\n        secondPosition = firstMovingPosition, ///\n        relativePosition = RelativePosition.fromFirstPositionAndSecondPosition(firstPosition, secondPosition),\n        direction = relativePosition.getDirection(),\n        speed = relativePosition.getSpeed();\n\n  if (speed > MINIMUM_SWIPE_SPEED) {\n    this.swipe(event, element, speed, direction);\n  }\n}\n\nfunction tap(event, element) {\n  const startPositions = this.getStartPositions(),\n        firstStartPosition = first(startPositions),\n        startPosition = firstStartPosition, ///\n        top = startPosition.getTop(),\n        left = startPosition.getLeft();\n\n  let tapInterval = this.getTapInterval();\n\n  if (tapInterval !== null) {\n    clearTimeout(tapInterval);\n\n    tapInterval = null;\n\n    this.setTapInterval(tapInterval);\n\n    this.doubleTap(event, element, top, left);\n\n    return;\n  }\n\n  const interval = setTimeout(() => {\n    tapInterval = null;\n\n    this.setTapInterval(tapInterval);\n\n    this.singleTap(event, element, top, left);\n  }, TAP_DELAY);\n\n  tapInterval = interval; ///\n\n  this.setTapInterval(tapInterval);\n}\n\nfunction drag(event, element) {\n  const startPositions = this.getStartPositions(),\n        movingPositions = this.getMovingPositions(),\n        firstStartPosition = first(startPositions),\n        firstMovingPosition = first(movingPositions),\n        firstPosition = firstStartPosition, ///\n        secondPosition = firstMovingPosition, ///\n        relativePosition = RelativePosition.fromFirstPositionAndSecondPosition(firstPosition, secondPosition),\n        top = relativePosition.getTop(),\n        left = relativePosition.getLeft(),\n        direction = relativePosition.getDirection();\n\n  let customEventType = null;\n\n  if ((Math.abs(direction)) < MAXIMUM_SPREAD) {\n    customEventType = DRAG_RIGHT_CUSTOM_EVENT_TYPE;\n  }\n\n  if (Math.abs(PI_OVER_TWO - direction) < MAXIMUM_SPREAD) {\n    customEventType = DRAG_UP_CUSTOM_EVENT_TYPE;\n  }\n\n  if (Math.abs(-PI_OVER_TWO - direction) < MAXIMUM_SPREAD) {\n    customEventType = DRAG_DOWN_CUSTOM_EVENT_TYPE;\n  }\n\n  if ((PI - Math.abs(direction)) < MAXIMUM_SPREAD) {\n    customEventType = DRAG_LEFT_CUSTOM_EVENT_TYPE;\n  }\n\n  if (customEventType !== null) {\n    this.callCustomHandlers(customEventType, event, element, top, left);\n  }\n}\n\nfunction pinch(event, element) {\n  const movingPositions = this.getMovingPositions(),\n        firstMovingPosition = first(movingPositions),\n        secondMovingPosition = second(movingPositions),\n        relativeMovingPosition = RelativePosition.fromFirstPositionAndSecondPosition(firstMovingPosition, secondMovingPosition),\n        customEventType = PINCH_MOVE_CUSTOM_EVENT_TYPE,\n        startMagnitude = this.getStartMagnitude(),\n        magnitude = relativeMovingPosition.getMagnitude(),\n        ratio = magnitude / startMagnitude;\n\n  this.callCustomHandlers(customEventType, event, element, ratio);\n}\n\nfunction press(event, element) {\n  const customEventType = PRESS_CUSTOM_EVENT_TYPE;\n\n  this.callCustomHandlers(customEventType, event, element);\n}\n\nfunction swipe(event, element, speed, direction) {\n  let customEventType = null;\n\n  if ((Math.abs(direction)) < MAXIMUM_SPREAD) {\n    customEventType = SWIPE_RIGHT_CUSTOM_EVENT_TYPE;\n\n    speed = speed * Math.abs(Math.cos(direction));\n  }\n\n  if (Math.abs(PI_OVER_TWO - direction) < MAXIMUM_SPREAD) {\n    customEventType = SWIPE_UP_CUSTOM_EVENT_TYPE;\n\n    speed = speed * Math.abs(Math.sin(direction));\n  }\n\n  if (Math.abs(-PI_OVER_TWO - direction) < MAXIMUM_SPREAD) {\n    customEventType = SWIPE_DOWN_CUSTOM_EVENT_TYPE;\n\n    speed = speed * Math.abs(Math.sin(direction));\n  }\n\n  if ((PI - Math.abs(direction)) < MAXIMUM_SPREAD) {\n    customEventType = SWIPE_LEFT_CUSTOM_EVENT_TYPE;\n\n    speed = speed * Math.abs(Math.cos(direction));\n  }\n\n  if (customEventType !== null) {\n    const startPositions = this.getStartPositions(),\n          firstStartPosition = first(startPositions),\n          startPosition = firstStartPosition, ///\n          top = startPosition.getTop(),\n          left = startPosition.getLeft();\n\n    this.callCustomHandlers(customEventType, event, element, top, left, speed);\n  }\n}\n\nfunction singleTap(event, element, top, left) {\n  const customEventType = SINGLE_TAP_CUSTOM_EVENT_TYPE;\n\n  this.callCustomHandlers(customEventType, event, element, top, left); ///\n}\n\nfunction doubleTap(event, element, top, left) {\n  const customEventType = DOUBLE_TAP_CUSTOM_EVENT_TYPE;\n\n  this.callCustomHandlers(customEventType, event, element, top, left);\n}\n\nfunction dragStart(event, element) {\n  const customEventType = DRAG_START_CUSTOM_EVENT_TYPE,\n        startPositions = this.getStartPositions(),\n        firstStartPosition = first(startPositions),\n        startPosition = firstStartPosition,  ///\n        top = startPosition.getTop(),\n        left = startPosition.getLeft();\n\n  this.callCustomHandlers(customEventType, event, element, top, left);\n}\n\nfunction pinchStart(event, element) {\n  const customEventType = PINCH_START_CUSTOM_EVENT_TYPE,\n    startPositions = this.getStartPositions(),\n    firstStartPosition = first(startPositions),\n    secondStartPosition = second(startPositions),\n    relativeStartPosition = RelativePosition.fromFirstPositionAndSecondPosition(firstStartPosition, secondStartPosition),\n    magnitude = relativeStartPosition.getMagnitude(),\n    startMagnitude = magnitude; ///\n\n  this.setStartMagnitude(startMagnitude);\n\n  this.callCustomHandlers(customEventType, event, element);\n}\n\nfunction pinchStop(event, element) {\n  const customEventType = PINCH_STOP_CUSTOM_EVENT_TYPE;\n\n  this.callCustomHandlers(customEventType, event, element);\n}\n\nconst touchMixins = {\n  enableTouch,\n  disableTouch,\n  onCustomPress,\n  offCustomPress,\n  onCustomDragUp,\n  offCustomDragUp,\n  onCustomDragDown,\n  offCustomDragDown,\n  onCustomDragLeft,\n  offCustomDragLeft,\n  onCustomDragRight,\n  offCustomDragRight,\n  onCustomDragStart,\n  offCustomDragStart,\n  onCustomSwipeUp,\n  offCustomSwipeUp,\n  onCustomSwipeDown,\n  offCustomSwipeDown,\n  onCustomSwipeLeft,\n  offCustomSwipeLeft,\n  onCustomSwipeRight,\n  offCustomSwipeRight,\n  onCustomPinchMove,\n  offCustomPinchMove,\n  onCustomPinchStart,\n  offCustomPinchStart,\n  onCustomPinchStop,\n  offCustomPinchStop,\n  onCustomSingleTap,\n  offCustomSingleTap,\n  onCustomDoubleTap,\n  offCustomDoubleTap,\n  getTapInterval,\n  getPressSInterval,\n  getStartMagnitude,\n  getStartPositions,\n  getMovingPositions,\n  setTapInterval,\n  setPressSInterval,\n  setStartMagnitude,\n  setStartPositions,\n  setMovingPositions,\n  touchStartHandler,\n  mouseDownHandler,\n  touchMoveHandler,\n  mouseMoveHandler,\n  touchEndHandler,\n  mouseUpHandler,\n  startHandler,\n  moveHandler,\n  endHandler,\n  possibleTap,\n  possibleSwipe,\n  tap,\n  drag,\n  pinch,\n  press,\n  swipe,\n  singleTap,\n  doubleTap,\n  dragStart,\n  pinchStart,\n  pinchStop\n};\n\nexport default touchMixins;\n"],"names":["push","first","second","arrayUtilities","enableTouch","tapInterval","startMagnitude","startPositions","movingPositions","updateState","onMouseDown","mouseDownHandler","onMouseMove","mouseMoveHandler","window","onMouseUp","mouseUpHandler","onTouchStart","touchStartHandler","onTouchMove","touchMoveHandler","onTouchEnd","touchEndHandler","disableTouch","offMouseDown","offMouseMove","offMouseUp","offTouchStart","offTouchMove","offTouchEnd","onCustomPress","pressCustomHandler","element","customEventType","PRESS_CUSTOM_EVENT_TYPE","customHandler","onCustomEvent","offCustomPress","offCustomEvent","onCustomDragUp","dragUpCustomHandler","DRAG_UP_CUSTOM_EVENT_TYPE","offCustomDragUp","onCustomDragDown","dragDownCustomHandler","DRAG_DOWN_CUSTOM_EVENT_TYPE","offCustomDragDown","onCustomDragLeft","dragLeftCustomHandler","DRAG_LEFT_CUSTOM_EVENT_TYPE","offCustomDragLeft","onCustomDragRight","dragRightCustomHandler","DRAG_RIGHT_CUSTOM_EVENT_TYPE","offCustomDragRight","onCustomDragStart","dragStartCustomHandler","DRAG_START_CUSTOM_EVENT_TYPE","offCustomDragStart","onCustomSwipeUp","swipeUpCustomHandler","SWIPE_UP_CUSTOM_EVENT_TYPE","offCustomSwipeUp","onCustomSwipeDown","swipeDownCustomHandler","SWIPE_DOWN_CUSTOM_EVENT_TYPE","offCustomSwipeDown","onCustomSwipeLeft","swipeLeftCustomHandler","SWIPE_LEFT_CUSTOM_EVENT_TYPE","offCustomSwipeLeft","onCustomSwipeRight","swipeRightCustomHandler","SWIPE_RIGHT_CUSTOM_EVENT_TYPE","offCustomSwipeRight","onCustomPinchMove","pinchMoveCustomHandler","PINCH_MOVE_CUSTOM_EVENT_TYPE","offCustomPinchMove","onCustomPinchStart","pinchStartCustomHandler","PINCH_START_CUSTOM_EVENT_TYPE","offCustomPinchStart","onCustomPinchStop","pinchStopCustomHandler","PINCH_STOP_CUSTOM_EVENT_TYPE","offCustomPinchStop","onCustomSingleTap","singleTapCustomHandler","SINGLE_TAP_CUSTOM_EVENT_TYPE","offCustomSingleTap","onCustomDoubleTap","doubleTapCustomHandler","DOUBLE_TAP_CUSTOM_EVENT_TYPE","offCustomDoubleTap","getTapInterval","getState","getPressSInterval","pressInterval","getStartMagnitude","getStartPositions","getMovingPositions","setTapInterval","setPressSInterval","setStartMagnitude","setStartPositions","setMovingPositions","event","startHandler","touchEvent","changed","positions","positionsFromTouchEvent","mouseEvent","positionsFromMouseEvent","moveHandler","endHandler","positionsFromEvent","filterPositions","startingPositionsLength","length","dragStart","interval","setTimeout","press","PRESS_DELAY","pinchStart","positionsMatch","matchPositions","sortPositions","movingPositionsLength","drag","pinch","clearTimeout","startPositionsLength","pinchStop","possibleTap","possibleSwipe","firstStartPosition","firstMovingPosition","firstPosition","secondPosition","relativePosition","RelativePosition","fromFirstPositionAndSecondPosition","time","getTime","speed","getSpeed","MAXIMUM_TAP_TIME","tap","direction","getDirection","MINIMUM_SWIPE_SPEED","swipe","startPosition","top","getTop","left","getLeft","doubleTap","singleTap","TAP_DELAY","Math","abs","MAXIMUM_SPREAD","PI_OVER_TWO","PI","callCustomHandlers","secondMovingPosition","relativeMovingPosition","magnitude","getMagnitude","ratio","cos","sin","secondStartPosition","relativeStartPosition","touchMixins"],"mappings":"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"}

package/lib/position/relative.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return RelativePosition;
+    }
+});
+const _constants = require("../constants");
+class RelativePosition {
+    constructor(top, left, time, speed, magnitude, direction){
+        this.top = top;
+        this.left = left;
+        this.time = time;
+        this.speed = speed;
+        this.magnitude = magnitude;
+        this.direction = direction;
+    }
+    getTop() {
+        return this.top;
+    }
+    getLeft() {
+        return this.left;
+    }
+    getTime() {
+        return this.time;
+    }
+    getSpeed() {
+        return this.speed;
+    }
+    getMagnitude() {
+        return this.magnitude;
+    }
+    getDirection() {
+        return this.direction;
+    }
+    static fromFirstPositionAndSecondPosition(firstPosition, secondPosition) {
+        const position = secondPosition.minus(firstPosition), top = position.getTop(), left = position.getLeft(), time = position.getTime(), magnitude = Math.sqrt(top * top + left * left), speed = time === 0 ? 0 : magnitude / time;
+        let direction;
+        if (left === 0) {
+            direction = top < 0 ? +_constants.PI / 2 : -_constants.PI / 2;
+        } else {
+            direction = Math.atan2(-top, left);
+        }
+        const relativePosition = new RelativePosition(top, left, time, speed, magnitude, direction);
+        return relativePosition;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/position.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return Position;
+    }
+});
+class Position {
+    constructor(top, left, time, identifier){
+        this.top = top;
+        this.left = left;
+        this.time = time;
+        this.identifier = identifier;
+    }
+    getTop() {
+        return this.top;
+    }
+    getLeft() {
+        return this.left;
+    }
+    getTime() {
+        return this.time;
+    }
+    getIdentifier() {
+        return this.identifier;
+    }
+    minus(position) {
+        const positionTop = position.getTop(), positionLeft = position.getLeft(), positionTime = position.getTime(), top = this.top - positionTop, left = this.left - positionLeft, time = this.time - positionTime, identifier = this.identifier;
+        position = new Position(top, left, time, identifier); ///
+        return position;
+    }
+    match(position) {
+        const identifier = position.getIdentifier(), matches = this.identifier === identifier;
+        return matches;
+    }
+    static fromTouch(touch) {
+        const { pageX, pageY, identifier } = touch, top = pageY, left = pageX, time = getTime(), position = new Position(top, left, time, identifier);
+        return position;
+    }
+    static fromMouseEvent(mouseEvent) {
+        const { pageX, pageY } = mouseEvent, top = pageY, left = pageX, time = getTime(), identifier = null, position = new Position(top, left, time, identifier);
+        return position;
+    }
+}
+function getTime() {
+    const time = Date.now(); ///
+    return time;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/preamble.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _easy = require("easy");
+Object.assign(globalThis, {
+    React: _easy.React
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9wcmVhbWJsZS5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuaW1wb3J0IHsgUmVhY3QgfSBmcm9tIFwiZWFzeVwiO1xuXG5PYmplY3QuYXNzaWduKGdsb2JhbFRoaXMsIHtcbiAgUmVhY3Rcbn0pO1xuIl0sIm5hbWVzIjpbIk9iamVjdCIsImFzc2lnbiIsImdsb2JhbFRoaXMiLCJSZWFjdCJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7c0JBRXNCO0FBRXRCQSxPQUFPQyxNQUFNLENBQUNDLFlBQVk7SUFDeEJDLE9BQUFBLFdBQUs7QUFDUCJ9

package/lib/selectors.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DIVS_SELECTOR () {
+        return DIVS_SELECTOR;
+    },
+    get DIV_SELECTOR () {
+        return DIV_SELECTOR;
+    },
+    get LOADING_DIV_SELECTOR () {
+        return LOADING_DIV_SELECTOR;
+    }
+});
+const DIV_SELECTOR = "div";
+const DIVS_SELECTOR = "body > div:not(.loading)"; ///
+const LOADING_DIV_SELECTOR = "body > div.loading";
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9zZWxlY3RvcnMuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmV4cG9ydCBjb25zdCBESVZfU0VMRUNUT1IgPSBcImRpdlwiO1xuZXhwb3J0IGNvbnN0IERJVlNfU0VMRUNUT1IgPSBcImJvZHkgPiBkaXY6bm90KC5sb2FkaW5nKVwiOyAvLy9cbmV4cG9ydCBjb25zdCBMT0FESU5HX0RJVl9TRUxFQ1RPUiA9IFwiYm9keSA+IGRpdi5sb2FkaW5nXCI7XG4iXSwibmFtZXMiOlsiRElWU19TRUxFQ1RPUiIsIkRJVl9TRUxFQ1RPUiIsIkxPQURJTkdfRElWX1NFTEVDVE9SIl0sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7UUFHYUE7ZUFBQUE7O1FBREFDO2VBQUFBOztRQUVBQztlQUFBQTs7O0FBRk4sTUFBTUQsZUFBZTtBQUNyQixNQUFNRCxnQkFBZ0IsNEJBQTRCLEdBQUc7QUFDckQsTUFBTUUsdUJBQXVCIn0=

package/lib/utilities/positions.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get filterPositions () {
+        return filterPositions;
+    },
+    get matchPositions () {
+        return matchPositions;
+    },
+    get positionsFromMouseEvent () {
+        return positionsFromMouseEvent;
+    },
+    get positionsFromTouchEvent () {
+        return positionsFromTouchEvent;
+    },
+    get sortPositions () {
+        return sortPositions;
+    }
+});
+const _necessary = require("necessary");
+const _position = /*#__PURE__*/ _interop_require_default(require("../position"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const { clear, filter } = _necessary.arrayUtilities;
+function sortPositions(positionsA, positionsB) {
+    const positionAMap = positionsA.reduce((positionAMap, positionA)=>{
+        const identifier = positionA.getIdentifier();
+        positionAMap[identifier] = positionA;
+        return positionAMap;
+    }, {});
+    clear(positionsA);
+    positionsB.forEach((positionB)=>{
+        const identifier = positionB.getIdentifier(), positionA = positionAMap[identifier];
+        positionsA.push(positionA);
+    });
+}
+function matchPositions(positionsA, positionsB) {
+    let positionsMatch = false;
+    const positionsALength = positionsA.length, positionsBLength = positionsB.length;
+    if (positionsALength === positionsBLength) {
+        const identifiersA = identifiersFromPositions(positionsA), identifiersB = identifiersFromPositions(positionsB);
+        identifiersA.sort();
+        identifiersB.sort();
+        const identifiersMatch = identifiersA.every((identifierA, index)=>{
+            const identifierB = identifiersB[index];
+            if (identifierA === identifierB) {
+                return true;
+            }
+        });
+        positionsMatch = identifiersMatch; ///
+    }
+    return positionsMatch;
+}
+function filterPositions(positionsA, positionsB) {
+    filter(positionsA, (positionA)=>{
+        const matches = positionsB.some((positionB)=>{
+            const matches = positionA.match(positionB);
+            if (matches) {
+                return true;
+            }
+        });
+        if (!matches) {
+            return true;
+        }
+    });
+}
+function positionsFromMouseEvent(mouseEvent) {
+    const position = _position.default.fromMouseEvent(mouseEvent), positions = [
+        position
+    ];
+    return positions;
+}
+function positionsFromTouchEvent(touchEvent, changed = true) {
+    let touchesNodeList;
+    if (changed) {
+        ({ changedTouches: touchesNodeList } = touchEvent);
+    } else {
+        ({ touches: touchesNodeList } = touchEvent);
+    }
+    const touches = [
+        ...touchesNodeList
+    ], positions = touches.map((touch)=>{
+        const position = _position.default.fromTouch(touch);
+        return position;
+    });
+    compressPositions(positions);
+    return positions;
+}
+function compressPositions(positions) {
+    const positionMap = positions.reduce((positionMap, position)=>{
+        const identifier = position.getIdentifier();
+        positionMap[identifier] = position;
+        return positionMap;
+    }, {});
+    positions = Object.values(positionMap);
+    return positions;
+}
+function identifiersFromPositions(positions) {
+    const identifiers = positions.map((position)=>{
+        const identifier = position.getIdentifier();
+        return identifier;
+    });
+    return identifiers;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "easy-gestures",
   "author": "James Smith",
-  "version": "2.0.47",
+  "version": "2.0.49",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/easy-gestures",
   "description": "Touch gestures for web applications.",
@@ -19,7 +19,7 @@
     "esbuild": "0.11.14",
     "express": "^4.17.1",
     "lively-cli": "^3.0.3",
-    "watchful-cli": "^1.7.91"
+    "watchful-cli": "^1.7.96"
   },
   "scripts": {
     "start": "node ./bin/main.js",

package/src/mixins/touch.js

@@ -399,14 +399,16 @@ function startHandler(event, element, positionsFromEvent) {
   if (startingPositionsLength === 1) {
     this.dragStart(event, element);
 
-    let pressInterval = setTimeout(() => {
-      pressInterval = null;
+    const interval = setTimeout(() => {
+      const pressInterval = null;
 
       this.setPressSInterval(pressInterval);
 
       this.press(event, element);
     }, PRESS_DELAY);
 
+    const pressInterval = interval; ///
+
     this.setPressSInterval(pressInterval);
   }
 
@@ -539,7 +541,7 @@ function tap(event, element) {
     return;
   }
 
-  tapInterval = setTimeout(() => {
+  const interval = setTimeout(() => {
     tapInterval = null;
 
     this.setTapInterval(tapInterval);
@@ -547,6 +549,8 @@ function tap(event, element) {
     this.singleTap(event, element, top, left);
   }, TAP_DELAY);
 
+  tapInterval = interval; ///
+
   this.setTapInterval(tapInterval);
 }