/**

         * Used to check if it the recognizer receives valid input, like input.distance > 10.

         * @memberof AttrRecognizer

         * @param {Object} input

         * @returns {Boolean} recognized

         */

        attrTest: function(input) {

            var optionPointers = this.options.pointers;

            return optionPointers === 0 || input.pointers.length === optionPointers;

        },

        /**

         * Process the input and return the state for the recognizer

         * @memberof AttrRecognizer

         * @param {Object} input

         * @returns {*} State

         */

        process: function(input) {

            var state = this.state;

            var eventType = input.eventType;

            var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);

            var isValid = this.attrTest(input);

            // on cancel input and we've recognized before, return STATE_CANCELLED

            if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {

                return state | STATE_CANCELLED;

            } else if (isRecognized || isValid) {

                if (eventType & INPUT_END) {

                    return state | STATE_ENDED;

                } else if (!(state & STATE_BEGAN)) {

                    return STATE_BEGAN;

                }

                return state | STATE_CHANGED;

            }

            return STATE_FAILED;

        }

    });

    /**

     * Pan

     * Recognized when the pointer is down and moved in the allowed direction.

     * @constructor

     * @extends AttrRecognizer

     */

    function PanRecognizer() {

        AttrRecognizer.apply(this, arguments);

        this.pX = null;

        this.pY = null;

    }

    inherit(PanRecognizer, AttrRecognizer, {

        /**

         * @namespace

         * @memberof PanRecognizer

         */

        defaults: {

            event: 'pan',

            threshold: 10,

            pointers: 1,

            direction: DIRECTION_ALL

        },

        getTouchAction: function() {

            var direction = this.options.direction;

            var actions = [];

            if (direction & DIRECTION_HORIZONTAL) {

                actions.push(TOUCH_ACTION_PAN_Y);

            }

            if (direction & DIRECTION_VERTICAL) {

                actions.push(TOUCH_ACTION_PAN_X);

            }

            return actions;

        },

        directionTest: function(input) {

            var options = this.options;

            var hasMoved = true;

            var distance = input.distance;

            var direction = input.direction;

            var x = input.deltaX;

            var y = input.deltaY;

            // lock to axis?

            if (!(direction & options.direction)) {

                if (options.direction & DIRECTION_HORIZONTAL) {

                    direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;

                    hasMoved = x != this.pX;

                    distance = Math.abs(input.deltaX);

                } else {

                    direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;

                    hasMoved = y != this.pY;

                    distance = Math.abs(input.deltaY);

                }

            }

            input.direction = direction;

            return hasMoved && distance > options.threshold && direction & options.direction;

        },

        attrTest: function(input) {

            return AttrRecognizer.prototype.attrTest.call(this, input) &&

              (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));

        },

        emit: function(input) {

        // reset when we've reached the end

        if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {

            this.state = STATE_POSSIBLE;

        }

            this.pX = input.deltaX;

            this.pY = input.deltaY;

        this.state = this.process(inputDataClone);

            var direction = directionStr(input.direction);

        // the recognizer has recognized a gesture

        // so trigger an event

        if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {

            this.tryEmit(inputDataClone);

            if (direction) {

                input.additionalEvent = this.options.event + direction;

            }

            this._super.emit.call(this, input);

        }

    },

    /**

     * return the state of the recognizer

     * the actual recognizing happens in this method

     * @virtual

     * @param {Object} inputData

     * @returns {Const} STATE

     */

    process: function(inputData) { }, // jshint ignore:line

    });

    /**

     * return the preferred touch-action

     * @virtual

     * @returns {Array}

     * Pinch

     * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).

     * @constructor

     * @extends AttrRecognizer

     */

    getTouchAction: function() { },

    function PinchRecognizer() {

        AttrRecognizer.apply(this, arguments);

    }

    /**

     * called when the gesture isn't allowed to recognize

     * like when another is being recognized or it is disabled

     * @virtual

     */

    reset: function() { }

};

/**

 * get a usable string, used as event postfix

 * @param {Const} state

 * @returns {String} state

 */

function stateStr(state) {

    if (state & STATE_CANCELLED) {

        return 'cancel';

    } else if (state & STATE_ENDED) {

        return 'end';

    } else if (state & STATE_CHANGED) {

        return 'move';

    } else if (state & STATE_BEGAN) {

        return 'start';

    }

    return '';

}

/**

 * direction cons to string

 * @param {Const} direction

 * @returns {String}

 */

function directionStr(direction) {

    if (direction == DIRECTION_DOWN) {

        return 'down';

    } else if (direction == DIRECTION_UP) {

        return 'up';

    } else if (direction == DIRECTION_LEFT) {

        return 'left';

    } else if (direction == DIRECTION_RIGHT) {

        return 'right';

    }

    return '';

}

/**

 * get a recognizer by name if it is bound to a manager

 * @param {Recognizer|String} otherRecognizer

 * @param {Recognizer} recognizer

 * @returns {Recognizer}

 */

function getRecognizerByNameIfManager(otherRecognizer, recognizer) {

    var manager = recognizer.manager;

    if (manager) {

        return manager.get(otherRecognizer);

    }

    return otherRecognizer;

}

/**

 * This recognizer is just used as a base for the simple attribute recognizers.

 * @constructor

 * @extends Recognizer

 */

function AttrRecognizer() {

    Recognizer.apply(this, arguments);

}

inherit(AttrRecognizer, Recognizer, {

    /**

     * @namespace

     * @memberof AttrRecognizer

     */

    defaults: {

    inherit(PinchRecognizer, AttrRecognizer, {

        /**

         * @type {Number}

         * @default 1

         * @namespace

         * @memberof PinchRecognizer

         */

        pointers: 1

    },

    /**

     * Used to check if it the recognizer receives valid input, like input.distance > 10.

     * @memberof AttrRecognizer

     * @param {Object} input

     * @returns {Boolean} recognized

     */

    attrTest: function(input) {

        var optionPointers = this.options.pointers;

        return optionPointers === 0 || input.pointers.length === optionPointers;

    },

        defaults: {

            event: 'pinch',

            threshold: 0,

            pointers: 2

        },

        getTouchAction: function() {

            return [TOUCH_ACTION_NONE];

        },

        attrTest: function(input) {

            return this._super.attrTest.call(this, input) &&

              (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);

        },

        emit: function(input) {

            if (input.scale !== 1) {

                var inOut = input.scale < 1 ? 'in' : 'out';

                input.additionalEvent = this.options.event + inOut;

            }

            this._super.emit.call(this, input);

        }

    });

    /**

     * Process the input and return the state for the recognizer

     * @memberof AttrRecognizer

     * @param {Object} input

     * @returns {*} State

     * Press

     * Recognized when the pointer is down for x ms without any movement.

     * @constructor

     * @extends Recognizer

     */

    process: function(input) {

        var state = this.state;

        var eventType = input.eventType;

        var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);

        var isValid = this.attrTest(input);

    function PressRecognizer() {

        Recognizer.apply(this, arguments);

        // on cancel input and we've recognized before, return STATE_CANCELLED

        if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {

            return state | STATE_CANCELLED;

        } else if (isRecognized || isValid) {

            if (eventType & INPUT_END) {

                return state | STATE_ENDED;

            } else if (!(state & STATE_BEGAN)) {

                return STATE_BEGAN;

            }

            return state | STATE_CHANGED;

        }

        return STATE_FAILED;

        this._timer = null;

        this._input = null;

    }

});

/**

 * Pan

 * Recognized when the pointer is down and moved in the allowed direction.

 * @constructor

 * @extends AttrRecognizer

 */

function PanRecognizer() {

    AttrRecognizer.apply(this, arguments);

    inherit(PressRecognizer, Recognizer, {

        /**

         * @namespace

         * @memberof PressRecognizer

         */

        defaults: {

            event: 'press',

            pointers: 1,

            time: 251, // minimal time of the pointer to be pressed

            threshold: 9 // a minimal movement is ok, but keep it low

        },

        getTouchAction: function() {

            return [TOUCH_ACTION_AUTO];

        },

        process: function(input) {

            var options = this.options;

            var validPointers = input.pointers.length === options.pointers;

            var validMovement = input.distance < options.threshold;

            var validTime = input.deltaTime > options.time;

    this.pX = null;

    this.pY = null;

}

            this._input = input;

inherit(PanRecognizer, AttrRecognizer, {

    /**

     * @namespace

     * @memberof PanRecognizer

     */

    defaults: {

        event: 'pan',

        threshold: 10,

        pointers: 1,

        direction: DIRECTION_ALL

    },

    getTouchAction: function() {

        var direction = this.options.direction;

        var actions = [];

        if (direction & DIRECTION_HORIZONTAL) {

            actions.push(TOUCH_ACTION_PAN_Y);

        }

        if (direction & DIRECTION_VERTICAL) {

            actions.push(TOUCH_ACTION_PAN_X);

        }

        return actions;

    },

    directionTest: function(input) {

        var options = this.options;

        var hasMoved = true;

        var distance = input.distance;

        var direction = input.direction;

        var x = input.deltaX;

        var y = input.deltaY;

        // lock to axis?

        if (!(direction & options.direction)) {

            if (options.direction & DIRECTION_HORIZONTAL) {

                direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;

                hasMoved = x != this.pX;

                distance = Math.abs(input.deltaX);

            } else {

                direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;

                hasMoved = y != this.pY;

                distance = Math.abs(input.deltaY);

            // we only allow little movement

            // and we've reached an end event, so a tap is possible

            if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {

                this.reset();

            } else if (input.eventType & INPUT_START) {

                this.reset();

                this._timer = setTimeoutContext(function() {

                    this.state = STATE_RECOGNIZED;

                    this.tryEmit();

                }, options.time, this);

            } else if (input.eventType & INPUT_END) {

                return STATE_RECOGNIZED;

            }

        }

        input.direction = direction;

        return hasMoved && distance > options.threshold && direction & options.direction;

    },

            return STATE_FAILED;

        },

    attrTest: function(input) {

        return AttrRecognizer.prototype.attrTest.call(this, input) &&

            (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));

    },

        reset: function() {

            clearTimeout(this._timer);

        },

    emit: function(input) {

        this.pX = input.deltaX;

        this.pY = input.deltaY;

        var direction = directionStr(input.direction);

        emit: function(input) {

            if (this.state !== STATE_RECOGNIZED) {

                return;

            }

        if (direction) {

            input.additionalEvent = this.options.event + direction;

            if (input && (input.eventType & INPUT_END)) {

                this.manager.emit(this.options.event + 'up', input);

            } else {

                this._input.timeStamp = now();

                this.manager.emit(this.options.event, this._input);

            }

        }

        this._super.emit.call(this, input);

    }

});

/**

 * Pinch

 * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).

 * @constructor

 * @extends AttrRecognizer

 */

function PinchRecognizer() {

    AttrRecognizer.apply(this, arguments);

}

    });

inherit(PinchRecognizer, AttrRecognizer, {

    /**

     * @namespace

     * @memberof PinchRecognizer

     * Rotate

     * Recognized when two or more pointer are moving in a circular motion.

     * @constructor

     * @extends AttrRecognizer

     */

    defaults: {

        event: 'pinch',

        threshold: 0,

        pointers: 2

    },

    getTouchAction: function() {

        return [TOUCH_ACTION_NONE];

    },

    attrTest: function(input) {

        return this._super.attrTest.call(this, input) &&

            (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);

    },

    emit: function(input) {

        if (input.scale !== 1) {

            var inOut = input.scale < 1 ? 'in' : 'out';

            input.additionalEvent = this.options.event + inOut;

        }

        this._super.emit.call(this, input);

    function RotateRecognizer() {

        AttrRecognizer.apply(this, arguments);

    }

});

/**

 * Press

 * Recognized when the pointer is down for x ms without any movement.

 * @constructor

 * @extends Recognizer

 */

function PressRecognizer() {

    Recognizer.apply(this, arguments);

    inherit(RotateRecognizer, AttrRecognizer, {

        /**

         * @namespace

         * @memberof RotateRecognizer

         */

        defaults: {

            event: 'rotate',

            threshold: 0,

            pointers: 2

        },

        getTouchAction: function() {

            return [TOUCH_ACTION_NONE];

        },

    this._timer = null;

    this._input = null;

}

        attrTest: function(input) {

            return this._super.attrTest.call(this, input) &&

              (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);

        }

    });

inherit(PressRecognizer, Recognizer, {

    /**

     * @namespace

     * @memberof PressRecognizer

     * Swipe

     * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.

     * @constructor

     * @extends AttrRecognizer

     */

    defaults: {

        event: 'press',

        pointers: 1,

        time: 251, // minimal time of the pointer to be pressed

        threshold: 9 // a minimal movement is ok, but keep it low

    },

    getTouchAction: function() {

        return [TOUCH_ACTION_AUTO];

    },

    process: function(input) {

        var options = this.options;

        var validPointers = input.pointers.length === options.pointers;

        var validMovement = input.distance < options.threshold;

        var validTime = input.deltaTime > options.time;

        this._input = input;

        // we only allow little movement

        // and we've reached an end event, so a tap is possible

        if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {

            this.reset();

        } else if (input.eventType & INPUT_START) {

            this.reset();

            this._timer = setTimeoutContext(function() {

                this.state = STATE_RECOGNIZED;

                this.tryEmit();

            }, options.time, this);

        } else if (input.eventType & INPUT_END) {

            return STATE_RECOGNIZED;

        }

        return STATE_FAILED;

    },

    function SwipeRecognizer() {

        AttrRecognizer.apply(this, arguments);

    }

    reset: function() {

        clearTimeout(this._timer);

    },

    inherit(SwipeRecognizer, AttrRecognizer, {

        /**

         * @namespace

         * @memberof SwipeRecognizer

         */

        defaults: {

            event: 'swipe',

            threshold: 10,

            velocity: 0.3,

            direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,

            pointers: 1

        },

        getTouchAction: function() {

            return PanRecognizer.prototype.getTouchAction.call(this);

        },

        attrTest: function(input) {

            var direction = this.options.direction;

            var velocity;

            if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {

                velocity = input.overallVelocity;

            } else if (direction & DIRECTION_HORIZONTAL) {

                velocity = input.overallVelocityX;

            } else if (direction & DIRECTION_VERTICAL) {

                velocity = input.overallVelocityY;

            }

    emit: function(input) {

        if (this.state !== STATE_RECOGNIZED) {

            return;

        }

            return this._super.attrTest.call(this, input) &&

              direction & input.offsetDirection &&

              input.distance > this.options.threshold &&

              input.maxPointers == this.options.pointers &&

              abs(velocity) > this.options.velocity && input.eventType & INPUT_END;

        },

        emit: function(input) {

            var direction = directionStr(input.offsetDirection);

            if (direction) {

                this.manager.emit(this.options.event + direction, input);

            }

        if (input && (input.eventType & INPUT_END)) {

            this.manager.emit(this.options.event + 'up', input);

        } else {

            this._input.timeStamp = now();

            this.manager.emit(this.options.event, this._input);

            this.manager.emit(this.options.event, input);

        }

    }

});

/**

 * Rotate

 * Recognized when two or more pointer are moving in a circular motion.

 * @constructor

 * @extends AttrRecognizer

 */

function RotateRecognizer() {

    AttrRecognizer.apply(this, arguments);

}

    });

inherit(RotateRecognizer, AttrRecognizer, {

    /**

     * @namespace

     * @memberof RotateRecognizer

     */

    defaults: {

        event: 'rotate',

        threshold: 0,

        pointers: 2

    },

    getTouchAction: function() {

        return [TOUCH_ACTION_NONE];

    },

    attrTest: function(input) {

        return this._super.attrTest.call(this, input) &&

            (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);

    }

});

/**

 * Swipe

 * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.

 * @constructor

 * @extends AttrRecognizer

 */

function SwipeRecognizer() {

    AttrRecognizer.apply(this, arguments);

}

inherit(SwipeRecognizer, AttrRecognizer, {

    /**

     * @namespace

     * @memberof SwipeRecognizer

     * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur

     * between the given interval and position. The delay option can be used to recognize multi-taps without firing

     * a single tap.

     *

     * The eventData from the emitted event contains the property `tapCount`, which contains the amount of

     * multi-taps being recognized.

     * @constructor

     * @extends Recognizer

     */

    defaults: {

        event: 'swipe',

        threshold: 10,

        velocity: 0.3,

        direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,

        pointers: 1

    },

    getTouchAction: function() {

        return PanRecognizer.prototype.getTouchAction.call(this);

    },

    attrTest: function(input) {

        var direction = this.options.direction;

        var velocity;

        if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {

            velocity = input.overallVelocity;

        } else if (direction & DIRECTION_HORIZONTAL) {

            velocity = input.overallVelocityX;

        } else if (direction & DIRECTION_VERTICAL) {

            velocity = input.overallVelocityY;

        }

    function TapRecognizer() {

        Recognizer.apply(this, arguments);

        return this._super.attrTest.call(this, input) &&

            direction & input.offsetDirection &&

            input.distance > this.options.threshold &&

            input.maxPointers == this.options.pointers &&

            abs(velocity) > this.options.velocity && input.eventType & INPUT_END;

    },

    emit: function(input) {

        var direction = directionStr(input.offsetDirection);

        if (direction) {

            this.manager.emit(this.options.event + direction, input);

        }

        // previous time and center,

        // used for tap counting

        this.pTime = false;

        this.pCenter = false;

        this.manager.emit(this.options.event, input);

        this._timer = null;

        this._input = null;

        this.count = 0;

    }

});

/**

 * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur

 * between the given interval and position. The delay option can be used to recognize multi-taps without firing

 * a single tap.

 *

 * The eventData from the emitted event contains the property `tapCount`, which contains the amount of

 * multi-taps being recognized.

 * @constructor

 * @extends Recognizer

 */

function TapRecognizer() {

    Recognizer.apply(this, arguments);

    // previous time and center,

    // used for tap counting

    this.pTime = false;

    this.pCenter = false;

    this._timer = null;

    this._input = null;

    this.count = 0;

}

inherit(TapRecognizer, Recognizer, {

    /**

     * @namespace

     * @memberof PinchRecognizer

     */

    defaults: {

        event: 'tap',

        pointers: 1,

        taps: 1,

        interval: 300, // max time between the multi-tap taps

        time: 250, // max time of the pointer to be down (like finger on the screen)

        threshold: 9, // a minimal movement is ok, but keep it low

        posThreshold: 10 // a multi-tap can be a bit off the initial position

    },

    getTouchAction: function() {

        return [TOUCH_ACTION_MANIPULATION];

    },

    process: function(input) {

        var options = this.options;

        var validPointers = input.pointers.length === options.pointers;

        var validMovement = input.distance < options.threshold;

        var validTouchTime = input.deltaTime < options.time;

        this.reset();

        if ((input.eventType & INPUT_START) && (this.count === 0)) {

            return this.failTimeout();

        }

    inherit(TapRecognizer, Recognizer, {

        /**

         * @namespace

         * @memberof PinchRecognizer

         */

        defaults: {

            event: 'tap',

            pointers: 1,

            taps: 1,

            interval: 300, // max time between the multi-tap taps

            time: 250, // max time of the pointer to be down (like finger on the screen)

            threshold: 9, // a minimal movement is ok, but keep it low

            posThreshold: 10 // a multi-tap can be a bit off the initial position

        },

        getTouchAction: function() {

            return [TOUCH_ACTION_MANIPULATION];

        },

        process: function(input) {

            var options = this.options;

            var validPointers = input.pointers.length === options.pointers;

            var validMovement = input.distance < options.threshold;

            var validTouchTime = input.deltaTime < options.time;

            this.reset();

        // we only allow little movement

        // and we've reached an end event, so a tap is possible

        if (validMovement && validTouchTime && validPointers) {

            if (input.eventType != INPUT_END) {

            if ((input.eventType & INPUT_START) && (this.count === 0)) {

                return this.failTimeout();

            }

            var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;

            var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;

            this.pTime = input.timeStamp;

            this.pCenter = input.center;

            // we only allow little movement

            // and we've reached an end event, so a tap is possible

            if (validMovement && validTouchTime && validPointers) {

                if (input.eventType != INPUT_END) {

                    return this.failTimeout();

                }

            if (!validMultiTap || !validInterval) {

                this.count = 1;

            } else {

                this.count += 1;

            }

                var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;

                var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;

            this._input = input;

                this.pTime = input.timeStamp;

                this.pCenter = input.center;

            // if tap count matches we have recognized it,

            // else it has began recognizing...

            var tapCount = this.count % options.taps;

            if (tapCount === 0) {

                // no failing requirements, immediately trigger the tap event

                // or wait as long as the multitap interval to trigger

                if (!this.hasRequireFailures()) {

                    return STATE_RECOGNIZED;

                if (!validMultiTap || !validInterval) {

                    this.count = 1;

                } else {

                    this._timer = setTimeoutContext(function() {

                        this.state = STATE_RECOGNIZED;

                        this.tryEmit();

                    }, options.interval, this);

                    return STATE_BEGAN;

                    this.count += 1;

                }

                this._input = input;

                // if tap count matches we have recognized it,

                // else it has began recognizing...

                var tapCount = this.count % options.taps;

                if (tapCount === 0) {

                    // no failing requirements, immediately trigger the tap event

                    // or wait as long as the multitap interval to trigger

                    if (!this.hasRequireFailures()) {

                        return STATE_RECOGNIZED;

                    } else {

                        this._timer = setTimeoutContext(function() {

                            this.state = STATE_RECOGNIZED;

                            this.tryEmit();

                        }, options.interval, this);

                        return STATE_BEGAN;

                    }

                }

            }

        }

        return STATE_FAILED;

    },

            return STATE_FAILED;

        },

    failTimeout: function() {

        this._timer = setTimeoutContext(function() {

            this.state = STATE_FAILED;

        }, this.options.interval, this);

        return STATE_FAILED;

    },

    reset: function() {

        clearTimeout(this._timer);

    },

    emit: function() {

        if (this.state == STATE_RECOGNIZED) {

            this._input.tapCount = this.count;

            this.manager.emit(this.options.event, this._input);

        failTimeout: function() {

            this._timer = setTimeoutContext(function() {

                this.state = STATE_FAILED;

            }, this.options.interval, this);

            return STATE_FAILED;

        },

        reset: function() {

            clearTimeout(this._timer);

        },

        emit: function() {

            if (this.state == STATE_RECOGNIZED) {

                this._input.tapCount = this.count;

                this.manager.emit(this.options.event, this._input);

            }

        }

    }

});

/**

 * Simple way to create a manager with a default set of recognizers.

 * @param {HTMLElement} element

 * @param {Object} [options]

 * @constructor

 */

function Hammer(element, options) {

    options = options || {};

    options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);

    return new Manager(element, options);

}

/**

 * @const {string}

 */

Hammer.VERSION = '2.0.7';

/**

 * default settings

 * @namespace

 */

Hammer.defaults = {

    /**

     * set if DOM events are being triggered.

     * But this is slower and unused by simple implementations, so disabled by default.

     * @type {Boolean}

     * @default false

     */

    domEvents: false,

    /**

     * The value for the touchAction property/fallback.

     * When set to `compute` it will magically set the correct value based on the added recognizers.

     * @type {String}

     * @default compute

     */

    touchAction: TOUCH_ACTION_COMPUTE,

    /**

     * @type {Boolean}

     * @default true

     */

    enable: true,

    /**

     * EXPERIMENTAL FEATURE -- can be removed/changed

     * Change the parent input target element.

     * If Null, then it is being set the to main element.

     * @type {Null|EventTarget}

     * @default null

     */

    inputTarget: null,

    });

    /**

     * force an input class

     * @type {Null|Function}

     * @default null

     * Simple way to create a manager with a default set of recognizers.

     * @param {HTMLElement} element

     * @param {Object} [options]

     * @constructor

     */

    inputClass: null,

    function Hammer(element, options) {

        options = options || {};

        options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);

        return new Manager(element, options);

    }

    /**

     * Default recognizer setup when calling `Hammer()`

     * When creating a new Manager these will be skipped.

     * @type {Array}

     * @const {string}

     */

    preset: [

        // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]

        [RotateRecognizer, {enable: false}],

        [PinchRecognizer, {enable: false}, ['rotate']],

        [SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],

        [PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],

        [TapRecognizer],

        [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],

        [PressRecognizer]

    ],

    Hammer.VERSION = '2.0.7';

    /**

     * Some CSS properties can be used to improve the working of Hammer.

     * Add them to this method and they will be set when creating a new Manager.

     * default settings

     * @namespace

     */

    cssProps: {

    Hammer.defaults = {

        /**

         * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.

         * @type {String}

         * @default 'none'

         * set if DOM events are being triggered.

         * But this is slower and unused by simple implementations, so disabled by default.

         * @type {Boolean}

         * @default false

         */

        userSelect: 'none',

        domEvents: false,

        /**

         * Disable the Windows Phone grippers when pressing an element.

         * The value for the touchAction property/fallback.

         * When set to `compute` it will magically set the correct value based on the added recognizers.

         * @type {String}

         * @default 'none'

         * @default compute

         */

        touchSelect: 'none',

        touchAction: TOUCH_ACTION_COMPUTE,

        /**

         * Disables the default callout shown when you touch and hold a touch target.

         * On iOS, when you touch and hold a touch target such as a link, Safari displays

         * a callout containing information about the link. This property allows you to disable that callout.

         * @type {String}

         * @default 'none'

         * @type {Boolean}

         * @default true

         */

        touchCallout: 'none',

        enable: true,

        /**

         * Specifies whether zooming is enabled. Used by IE10>

         * @type {String}

         * @default 'none'

         * EXPERIMENTAL FEATURE -- can be removed/changed

         * Change the parent input target element.

         * If Null, then it is being set the to main element.

         * @type {Null|EventTarget}

         * @default null

         */

        contentZooming: 'none',

        inputTarget: null,

        /**

         * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.

         * @type {String}

         * @default 'none'

         * force an input class

         * @type {Null|Function}

         * @default null

         */

        userDrag: 'none',

        inputClass: null,

        /**

         * Overrides the highlight color shown when the user taps a link or a JavaScript

         * clickable element in iOS. This property obeys the alpha value, if specified.

         * @type {String}

         * @default 'rgba(0,0,0,0)'

         * Default recognizer setup when calling `Hammer()`

         * When creating a new Manager these will be skipped.

         * @type {Array}

         */

        tapHighlightColor: 'rgba(0,0,0,0)'

    }

};

        preset: [

            // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]

            [RotateRecognizer, {enable: false}],

            [PinchRecognizer, {enable: false}, ['rotate']],

            [SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],

            [PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],

            [TapRecognizer],

            [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],

            [PressRecognizer]

        ],

var STOP = 1;

var FORCED_STOP = 2;

        /**

         * Some CSS properties can be used to improve the working of Hammer.

         * Add them to this method and they will be set when creating a new Manager.

         * @namespace

         */

        cssProps: {

            /**

             * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.

             * @type {String}

             * @default 'none'

             */

            userSelect: 'none',

            /**

             * Disable the Windows Phone grippers when pressing an element.

             * @type {String}

             * @default 'none'

             */

            touchSelect: 'none',

            /**

             * Disables the default callout shown when you touch and hold a touch target.

             * On iOS, when you touch and hold a touch target such as a link, Safari displays

             * a callout containing information about the link. This property allows you to disable that callout.

             * @type {String}

             * @default 'none'

             */

            touchCallout: 'none',

            /**

             * Specifies whether zooming is enabled. Used by IE10>

             * @type {String}

             * @default 'none'

             */

            contentZooming: 'none',

            /**

             * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.

             * @type {String}

             * @default 'none'

             */

            userDrag: 'none',

            /**

             * Overrides the highlight color shown when the user taps a link or a JavaScript

             * clickable element in iOS. This property obeys the alpha value, if specified.

             * @type {String}

             * @default 'rgba(0,0,0,0)'

             */

            tapHighlightColor: 'rgba(0,0,0,0)'

        }

    };

/**

 * Manager

 * @param {HTMLElement} element

 * @param {Object} [options]

 * @constructor

 */

function Manager(element, options) {

    this.options = assign({}, Hammer.defaults, options || {});

    var STOP = 1;

    var FORCED_STOP = 2;

    this.options.inputTarget = this.options.inputTarget || element;

    /**

     * Manager

     * @param {HTMLElement} element

     * @param {Object} [options]

     * @constructor

     */

    function Manager(element, options) {

        this.options = assign({}, Hammer.defaults, options || {});

    this.handlers = {};

    this.session = {};

    this.recognizers = [];

    this.oldCssProps = {};

        this.options.inputTarget = this.options.inputTarget || element;

    this.element = element;

    this.input = createInputInstance(this);

    this.touchAction = new TouchAction(this, this.options.touchAction);

        this.handlers = {};

        this.session = {};

        this.recognizers = [];

        this.oldCssProps = {};

    toggleCssProps(this, true);

        this.element = element;

        this.input = createInputInstance(this);

        this.touchAction = new TouchAction(this, this.options.touchAction);

    each(this.options.recognizers, function(item) {

        var recognizer = this.add(new (item[0])(item[1]));

        item[2] && recognizer.recognizeWith(item[2]);

        item[3] && recognizer.requireFailure(item[3]);

    }, this);

}

        toggleCssProps(this, true);

Manager.prototype = {

    /**

     * set options

     * @param {Object} options

     * @returns {Manager}

     */

    set: function(options) {

        assign(this.options, options);

        each(this.options.recognizers, function(item) {

            var recognizer = this.add(new (item[0])(item[1]));

            item[2] && recognizer.recognizeWith(item[2]);

            item[3] && recognizer.requireFailure(item[3]);

        }, this);

    }

        // Options that need a little more setup

        if (options.touchAction) {

            this.touchAction.update();

        }

        if (options.inputTarget) {

            // Clean up existing event listeners and reinitialize

            this.input.destroy();

            this.input.target = options.inputTarget;

            this.input.init();

        }

        return this;

    },

    Manager.prototype = {

        /**

         * set options

         * @param {Object} options

         * @returns {Manager}

         */

        set: function(options) {

            assign(this.options, options);

    /**

     * stop recognizing for this session.

     * This session will be discarded, when a new [input]start event is fired.

     * When forced, the recognizer cycle is stopped immediately.

     * @param {Boolean} [force]

     */

    stop: function(force) {

        this.session.stopped = force ? FORCED_STOP : STOP;

    },

            // Options that need a little more setup

            if (options.touchAction) {

                this.touchAction.update();

            }

            if (options.inputTarget) {

                // Clean up existing event listeners and reinitialize

                this.input.destroy();

                this.input.target = options.inputTarget;

                this.input.init();

            }

            return this;

        },

    /**

     * run the recognizers!

     * called by the inputHandler function on every movement of the pointers (touches)

     * it walks through all the recognizers and tries to detect the gesture that is being made

     * @param {Object} inputData

     */

    recognize: function(inputData) {

        var session = this.session;

        if (session.stopped) {

            return;

        }

        /**

         * stop recognizing for this session.

         * This session will be discarded, when a new [input]start event is fired.

         * When forced, the recognizer cycle is stopped immediately.

         * @param {Boolean} [force]

         */

        stop: function(force) {

            this.session.stopped = force ? FORCED_STOP : STOP;

        },

        // run the touch-action polyfill

        this.touchAction.preventDefaults(inputData);

        /**

         * run the recognizers!

         * called by the inputHandler function on every movement of the pointers (touches)

         * it walks through all the recognizers and tries to detect the gesture that is being made

         * @param {Object} inputData

         */

        recognize: function(inputData) {

            var session = this.session;

            if (session.stopped) {

                return;

            }

        var recognizer;

        var recognizers = this.recognizers;

            // run the touch-action polyfill

            this.touchAction.preventDefaults(inputData);

        // this holds the recognizer that is being recognized.

        // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED

        // if no recognizer is detecting a thing, it is set to `null`

        var curRecognizer = session.curRecognizer;

            var recognizer;

            var recognizers = this.recognizers;

        // reset when the last recognizer is recognized

        // or when we're in a new session

        if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {

            curRecognizer = session.curRecognizer = null;

        }

            // this holds the recognizer that is being recognized.

            // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED

            // if no recognizer is detecting a thing, it is set to `null`

            var curRecognizer = session.curRecognizer;

        var i = 0;

        while (i < recognizers.length) {

            recognizer = recognizers[i];

            // find out if we are allowed try to recognize the input for this one.

            // 1.   allow if the session is NOT forced stopped (see the .stop() method)

            // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one

            //      that is being recognized.

            // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.

            //      this can be setup with the `recognizeWith()` method on the recognizer.

            if (session.stopped !== FORCED_STOP && ( // 1

                    !curRecognizer || recognizer == curRecognizer || // 2

                    recognizer.canRecognizeWith(curRecognizer))) { // 3

                recognizer.recognize(inputData);

            } else {

                recognizer.reset();

            // reset when the last recognizer is recognized

            // or when we're in a new session

            if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {

                curRecognizer = session.curRecognizer = null;

            }

            // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the

            // current active recognizer. but only if we don't already have an active recognizer

            if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {

                curRecognizer = session.curRecognizer = recognizer;

            var i = 0;

            while (i < recognizers.length) {

                recognizer = recognizers[i];

                // find out if we are allowed try to recognize the input for this one.

                // 1.   allow if the session is NOT forced stopped (see the .stop() method)

                // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one

                //      that is being recognized.

                // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.

                //      this can be setup with the `recognizeWith()` method on the s can be setup with the `recognizeWith()` method on the recognizer.

                if (session.stopped !== FORCED_STOP && ( // 1

                  !curRecognizer || recognizer == curRecognizer || // 2

                  recognizer.canRecognizeWith(curRecognizer))) { // 3

                    recognizer.recognize(inputData);

                } else {

                    recognizer.reset();

                }

                // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the

                // current active recognizer. but only if we don't already have an active recognizer

                if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {

                    curRecognizer = session.curRecognizer = recognizer;

                }

                i++;

            }

            i++;

        }

    },

        },

    /**

     * get a recognizer by its event name.

     * @param {Recognizer|String} recognizer

     * @returns {Recognizer|Null}

     */

    get: function(recognizer) {

        if (recognizer instanceof Recognizer) {

        /**

         * get a recognizer by its event name.

         * @param {Recognizer|String} recognizer

         * @returns {Recognizer|Null}

         */

        get: function(recognizer) {

            if (recognizer instanceof Recognizer) {

                return recognizer;

            }

            var recognizers = this.recognizers;

            for (var i = 0; i < recognizers.length; i++) {

                if (recognizers[i].options.event == recognizer) {

                    return recognizers[i];

                }

            }

            return null;

        },

        /**

         * add a recognizer to the manager

         * existing recognizers with the same event name will be removed

         * @param {Recognizer} recognizer

         * @returns {Recognizer|Manager}

         */

        add: function(recognizer) {

            if (invokeArrayArg(recognizer, 'add', this)) {

                return this;

            }

            // remove existing

            var existing = this.get(recognizer.options.event);

            if (existing) {

                this.remove(existing);

            }

            this.recognizers.push(recognizer);

            recognizer.manager = this;

            this.touchAction.update();

            return recognizer;

        }

        },

        var recognizers = this.recognizers;

        for (var i = 0; i < recognizers.length; i++) {

            if (recognizers[i].options.event == recognizer) {

                return recognizers[i];

        /**

         * remove a recognizer by name or instance

         * @param {Recognizer|String} recognizer

         * @returns {Manager}

         */

        remove: function(recognizer) {

            if (invokeArrayArg(recognizer, 'remove', this)) {

                return this;

            }

            recognizer = this.get(recognizer);

            // let's make sure this recognizer exists

            if (recognizer) {

                var recognizers = this.recognizers;

                var index = inArray(recognizers, recognizer);

                if (index !== -1) {

                    recognizers.splice(index, 1);

                    this.touchAction.update();

                }

            }

        }

        return null;

    },

    /**

     * add a recognizer to the manager

     * existing recognizers with the same event name will be removed

     * @param {Recognizer} recognizer

     * @returns {Recognizer|Manager}

     */

    add: function(recognizer) {

        if (invokeArrayArg(recognizer, 'add', this)) {

            return this;

        }

        },

        // remove existing

        var existing = this.get(recognizer.options.event);

        if (existing) {

            this.remove(existing);

        }

        /**

         * bind event

         * @param {String} events

         * @param {Function} handler

         * @returns {EventEmitter} this

         */

        on: function(events, handler) {

            if (events === undefinedVar) {

                return;

            }

            if (handler === undefinedVar) {

                return;

            }

        this.recognizers.push(recognizer);

        recognizer.manager = this;

            var handlers = this.handlers;

            each(splitStr(events), function(event) {

                handlers[event] = handlers[event] || [];

                handlers[event].push(handler);

            });

            return this;

        },

        this.touchAction.update();

        return recognizer;

    },

        /**

         * unbind event, leave emit blank to remove all handlers

         * @param {String} events

         * @param {Function} [handler]

         * @returns {EventEmitter} this

         */

        off: function(events, handler) {

            if (events === undefinedVar) {

                return;

            }

    /**

     * remove a recognizer by name or instance

     * @param {Recognizer|String} recognizer

     * @returns {Manager}

     */

    remove: function(recognizer) {

        if (invokeArrayArg(recognizer, 'remove', this)) {

            var handlers = this.handlers;

            each(splitStr(events), function(event) {

                if (!handler) {

                    delete handlers[event];

                } else {

                    handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);

                }

            });

            return this;

        }

        },

        recognizer = this.get(recognizer);

        /**

         * emit event to the listeners

         * @param {String} event

         * @param {Object} data

         */

        emit: function(event, data) {

            // we also want to trigger dom events

            if (this.options.domEvents) {

                triggerDomEvent(event, data);

            }

        // let's make sure this recognizer exists

        if (recognizer) {

            var recognizers = this.recognizers;

            var index = inArray(recognizers, recognizer);

            // no handlers, so skip it all

            var handlers = this.handlers[event] && this.handlers[event].slice();

            if (!handlers || !handlers.length) {

                return;

            }

            if (index !== -1) {

                recognizers.splice(index, 1);

                this.touchAction.update();

            data.type = event;

            data.preventDefault = function() {

                data.srcEvent.preventDefault();

            };

            var i = 0;

            while (i < handlers.length) {

                handlers[i](data);

                i++;

            }

        }

        },

        return this;

    },

        /**

         * destroy the manager and unbinds all events

         * it doesn't unbind dom events, that is the user own responsibility

         */

        destroy: function() {

            this.element && toggleCssProps(this, false);

    /**

     * bind event

     * @param {String} events

     * @param {Function} handler

     * @returns {EventEmitter} this

     */

    on: function(events, handler) {

        if (events === undefined) {

            return;

        }

        if (handler === undefined) {

            return;

            this.handlers = {};

            this.session = {};

            this.input.destroy();

            this.element = null;

        }

        var handlers = this.handlers;

        each(splitStr(events), function(event) {

            handlers[event] = handlers[event] || [];

            handlers[event].push(handler);

        });

        return this;

    },

    };

    /**

     * unbind event, leave emit blank to remove all handlers

     * @param {String} events

     * @param {Function} [handler]

     * @returns {EventEmitter} this

     * add/remove the css properties as defined in manager.options.cssProps

     * @param {Manager} manager

     * @param {Boolean} add

     */

    off: function(events, handler) {

        if (events === undefined) {

    function toggleCssProps(manager, add) {

        var element = manager.element;

        if (!element.style) {

            return;

        }

        var handlers = this.handlers;

        each(splitStr(events), function(event) {

            if (!handler) {

                delete handlers[event];

        var prop;

        each(manager.options.cssProps, function(value, name) {

            prop = prefixed(element.style, name);

            if (add) {

                manager.oldCssProps[prop] = element.style[prop];

                element.style[prop] = value;

            } else {

                handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);

                element.style[prop] = manager.oldCssProps[prop] || '';

            }

        });

        return this;

    },

        if (!add) {

            manager.oldCssProps = {};

        }

    }

    /**

     * emit event to the listeners

     * trigger dom event

     * @param {String} event

     * @param {Object} data

     */

    emit: function(event, data) {

        // we also want to trigger dom events

        if (this.options.domEvents) {

            triggerDomEvent(event, data);

        }

        // no handlers, so skip it all

        var handlers = this.handlers[event] && this.handlers[event].slice();

        if (!handlers || !handlers.length) {

            return;

        }

        data.type = event;

        data.preventDefault = function() {

            data.srcEvent.preventDefault();

        };

        var i = 0;

        while (i < handlers.length) {

            handlers[i](data);

            i++;

        }

    },

    /**

     * destroy the manager and unbinds all events

     * it doesn't unbind dom events, that is the user own responsibility

     */

    destroy: function() {

        this.element && toggleCssProps(this, false);

    function triggerDomEvent(event, data) {

        var gestureEvent = document.createEvent('Event');

        gestureEvent.initEvent(event, true, true);

        gestureEvent.gesture = data;

        data.target.dispatchEvent(gestureEvent);

    }

        this.handlers = {};

        this.session = {};

        this.input.destroy();

        this.element = null;

    }

};

/**

 * add/remove the css properties as defined in manager.options.cssProps

 * @param {Manager} manager

 * @param {Boolean} add

 */

function toggleCssProps(manager, add) {

    var element = manager.element;

    if (!element.style) {

        return;

    }

    var prop;

    each(manager.options.cssProps, function(value, name) {

        prop = prefixed(element.style, name);

        if (add) {

            manager.oldCssProps[prop] = element.style[prop];

            element.style[prop] = value;

        } else {

            element.style[prop] = manager.oldCssProps[prop] || '';

        }

    assign(Hammer, {

        INPUT_START: INPUT_START,

        INPUT_MOVE: INPUT_MOVE,

        INPUT_END: INPUT_END,

        INPUT_CANCEL: INPUT_CANCEL,

        STATE_POSSIBLE: STATE_POSSIBLE,

        STATE_BEGAN: STATE_BEGAN,

        STATE_CHANGED: STATE_CHANGED,

        STATE_ENDED: STATE_ENDED,

        STATE_RECOGNIZED: STATE_RECOGNIZED,

        STATE_CANCELLED: STATE_CANCELLED,

        STATE_FAILED: STATE_FAILED,

        DIRECTION_NONE: DIRECTION_NONE,

        DIRECTION_LEFT: DIRECTION_LEFT,

        DIRECTION_RIGHT: DIRECTION_RIGHT,

        DIRECTION_UP: DIRECTION_UP,

        DIRECTION_DOWN: DIRECTION_DOWN,

        DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,

        DIRECTION_VERTICAL: DIRECTION_VERTICAL,

        DIRECTION_ALL: DIRECTION_ALL,

        Manager: Manager,

        Input: Input,

        TouchAction: TouchAction,

        TouchInput: TouchInput,

        MouseInput: MouseInput,

        PointerEventInput: PointerEventInput,

        TouchMouseInput: TouchMouseInput,

        SingleTouchInput: SingleTouchInput,

        Recognizer: Recognizer,

        AttrRecognizer: AttrRecognizer,

        Tap: TapRecognizer,

        Pan: PanRecognizer,

        Swipe: SwipeRecognizer,

        Pinch: PinchRecognizer,

        Rotate: RotateRecognizer,

        Press: PressRecognizer,

        on: addEventListeners,

        off: removeEventListeners,

        each: each,

        merge: merge,

        extend: extend,

        assign: assign,

        inherit: inherit,

        bindFn: bindFn,

        prefixed: prefixed