/**
                            Adds touch event facade normalization properties (touches, changedTouches, targetTouches etc.) to the DOM event facade. Adds
                            touch events to the DOM events whitelist.
                            
                            @example
                                YUI().use('event-touch', function (Y) {
                                    Y.one('#myDiv').on('touchstart', function(e) {
                                        ...
                                    });
                                });
                            @module event
                            @submodule event-touch
                             */
                            var SCALE = "scale",
                                ROTATION = "rotation",
                                IDENTIFIER = "identifier",
                                win = Y.config.win,
                                GESTURE_MAP = {};
                            
                            /**
                             * Adds touch event facade normalization properties to the DOM event facade
                             *
                             * @method _touch
                             * @for DOMEventFacade
                             * @private
                             * @param ev {Event} the DOM event
                             * @param currentTarget {HTMLElement} the element the listener was attached to
                             * @param wrapper {CustomEvent} the custom event wrapper for this DOM event
                             */
                            Y.DOMEventFacade.prototype._touch = function(e, currentTarget, wrapper) {
                            
                                var i,l, etCached, et,touchCache;
                            
                                Y.log("Calling facade._touch() with e = " + e, "debug", "event-touch");
                            
                                if (e.touches) {
                                    Y.log("Found e.touches. Replicating on facade", "info", "event-touch");
                            
                                    /**
                                     * Array of individual touch events for touch points that are still in
                                     * contact with the touch surface.
                                     *
                                     * @property touches
                                     * @type {DOMEventFacade[]}
                                     */
                                    this.touches = [];
                                    touchCache = {};
                            
                                    for (i = 0, l = e.touches.length; i < l; ++i) {
                                        et = e.touches[i];
                                        touchCache[Y.stamp(et)] = this.touches[i] = new Y.DOMEventFacade(et, currentTarget, wrapper);
                                    }
                                }
                            
                                if (e.targetTouches) {
                                    Y.log("Found e.targetTouches. Replicating on facade", "info", "event-touch");
                            
                                    /**
                                     * Array of individual touch events still in contact with the touch
                                     * surface and whose `touchstart` event occurred inside the same taregt
                                     * element as the current target element.
                                     *
                                     * @property targetTouches
                                     * @type {DOMEventFacade[]}
                                     */
                                    this.targetTouches = [];
                            
                                    for (i = 0, l = e.targetTouches.length; i < l; ++i) {
                                        et = e.targetTouches[i];
                                        etCached = touchCache && touchCache[Y.stamp(et, true)];
                            
                                        this.targetTouches[i] = etCached || new Y.DOMEventFacade(et, currentTarget, wrapper);
                            
                                        if (etCached) { Y.log("Found native event in touches. Using same facade in targetTouches", "info", "event-touch"); }
                                    }
                                }
                            
                                if (e.changedTouches) {
                                    Y.log("Found e.changedTouches. Replicating on facade", "info", "event-touch");
                            
                                    /**
                                    An array of event-specific touch events.
                            
                                    For `touchstart`, the touch points that became active with the current
                                    event.
                            
                                    For `touchmove`, the touch points that have changed since the last
                                    event.
                            
                                    For `touchend`, the touch points that have been removed from the touch
                                    surface.
                            
                                    @property changedTouches
                                    @type {DOMEventFacade[]}
                                    **/
                                    this.changedTouches = [];
                            
                                    for (i = 0, l = e.changedTouches.length; i < l; ++i) {
                                        et = e.changedTouches[i];
                                        etCached = touchCache && touchCache[Y.stamp(et, true)];
                            
                                        this.changedTouches[i] = etCached || new Y.DOMEventFacade(et, currentTarget, wrapper);
                            
                                        if (etCached) { Y.log("Found native event in touches. Using same facade in changedTouches", "info", "event-touch"); }
                                    }
                                }
                            
                                if (SCALE in e) {
                                    this[SCALE] = e[SCALE];
                                }
                            
                                if (ROTATION in e) {
                                    this[ROTATION] = e[ROTATION];
                                }
                            
                                if (IDENTIFIER in e) {
                                    this[IDENTIFIER] = e[IDENTIFIER];
                                }
                            };
                            
                            //Adding MSPointer events to whitelisted DOM Events. MSPointer event payloads
                            //have the same properties as mouse events.
                            if (Y.Node.DOM_EVENTS) {
                                Y.mix(Y.Node.DOM_EVENTS, {
                                    touchstart:1,
                                    touchmove:1,
                                    touchend:1,
                                    touchcancel:1,
                                    gesturestart:1,
                                    gesturechange:1,
                                    gestureend:1,
                                    MSPointerDown:1,
                                    MSPointerUp:1,
                                    MSPointerMove:1,
                                    MSPointerCancel:1,
                                    pointerdown:1,
                                    pointerup:1,
                                    pointermove:1,
                                    pointercancel:1
                                });
                            }
                            
                            //Add properties to Y.EVENT.GESTURE_MAP based on feature detection.
                            if ((win && ("ontouchstart" in win)) && !(Y.UA.chrome && Y.UA.chrome < 6)) {
                                GESTURE_MAP.start = ["touchstart", "mousedown"];
                                GESTURE_MAP.end = ["touchend", "mouseup"];
                                GESTURE_MAP.move = ["touchmove", "mousemove"];
                                GESTURE_MAP.cancel = ["touchcancel", "mousecancel"];
                            }
                            
                            else if (win && win.PointerEvent) {
                                GESTURE_MAP.start = "pointerdown";
                                GESTURE_MAP.end = "pointerup";
                                GESTURE_MAP.move = "pointermove";
                                GESTURE_MAP.cancel = "pointercancel";
                            }
                            
                            else if (win && ("msPointerEnabled" in win.navigator)) {
                                GESTURE_MAP.start = "MSPointerDown";
                                GESTURE_MAP.end = "MSPointerUp";
                                GESTURE_MAP.move = "MSPointerMove";
                                GESTURE_MAP.cancel = "MSPointerCancel";
                            }
                            
                            else {
                                GESTURE_MAP.start = "mousedown";
                                GESTURE_MAP.end = "mouseup";
                                GESTURE_MAP.move = "mousemove";
                                GESTURE_MAP.cancel = "mousecancel";
                            }
                            
                            /**
                             * A object literal with keys "start", "end", and "move". The value for each key is a
                             * string representing the event for that environment. For touch environments, the respective
                             * values are "touchstart", "touchend" and "touchmove". Mouse and MSPointer environments are also
                             * supported via feature detection.
                             *
                             * @property _GESTURE_MAP
                             * @type Object
                             * @static
                             */
                            Y.Event._GESTURE_MAP = GESTURE_MAP;