diff -r d334a616c023 -r e16a97fb364a src/cm/media/js/lib/yui/yui3-3.15.0/build/event-tap/event-tap-debug.js
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui3-3.15.0/build/event-tap/event-tap-debug.js	Mon Mar 10 15:19:48 2014 +0100
@@ -0,0 +1,299 @@
+YUI.add('event-tap', function (Y, NAME) {
+
+/**
+The tap module provides a gesture events, "tap", which normalizes user interactions
+across touch and mouse or pointer based input devices.  This can be used by application developers
+to build input device agnostic components which behave the same in response to either touch or mouse based
+interaction.
+
+'tap' is like a touchscreen 'click', only it requires much less finger-down time since it listens to touch events,
+but reverts to mouse events if touch is not supported.
+
+@example
+
+    YUI().use('event-tap', function (Y) {
+        Y.one('#my-button').on('tap', function (e) {
+            Y.log('Button was tapped on');
+        });
+    });
+
+@module event
+@submodule event-tap
+@author Andres Garza, matuzak and tilo mitra
+@since 3.7.0
+
+*/
+var doc = Y.config.doc,
+    GESTURE_MAP = Y.Event._GESTURE_MAP,
+    EVT_START = GESTURE_MAP.start,
+    EVT_TAP = 'tap',
+    POINTER_EVENT_TEST = /pointer/i,
+
+    HANDLES = {
+        START: 'Y_TAP_ON_START_HANDLE',
+        END: 'Y_TAP_ON_END_HANDLE',
+        CANCEL: 'Y_TAP_ON_CANCEL_HANDLE'
+    };
+
+function detachHandles(subscription, handles) {
+    handles = handles || Y.Object.values(HANDLES);
+
+    Y.Array.each(handles, function (item) {
+        var handle = subscription[item];
+        if (handle) {
+            handle.detach();
+            subscription[item] = null;
+        }
+    });
+
+}
+
+
+/**
+Sets up a "tap" event, that is fired on touch devices in response to a tap event (finger down, finder up).
+This event can be used instead of listening for click events which have a 500ms delay on most touch devices.
+This event can also be listened for using node.delegate().
+
+@event tap
+@param type {string} "tap"
+@param fn {function} The method the event invokes. It receives the event facade of the underlying DOM event.
+@for Event
+@return {EventHandle} the detach handle
+*/
+Y.Event.define(EVT_TAP, {
+    publishConfig: {
+        preventedFn: function (e) {
+            var sub = e.target.once('click', function (click) {
+                click.preventDefault();
+            });
+
+            // Make sure to detach the subscription during the next event loop
+            // so this doesn't `preventDefault()` on the wrong click event.
+            setTimeout(function () {
+                sub.detach();
+            //Setting this to `0` causes the detachment to occur before the click
+            //comes in on Android 4.0.3-4.0.4. 100ms seems to be a reliable number here
+            //that works across the board.
+            }, 100);
+        }
+    },
+
+    processArgs: function (args, isDelegate) {
+
+        //if we return for the delegate use case, then the `filter` argument
+        //returns undefined, and we have to get the filter from sub._extra[0] (ugly)
+
+        if (!isDelegate) {
+            var extra = args[3];
+            // remove the extra arguments from the array as specified by
+            // http://yuilibrary.com/yui/docs/event/synths.html
+            args.splice(3,1);
+            return extra;
+        }
+    },
+    /**
+    This function should set up the node that will eventually fire the event.
+
+    Usage:
+
+        node.on('tap', function (e) {
+            Y.log('the node was tapped on');
+        });
+
+    @method on
+    @param {Node} node
+    @param {Array} subscription
+    @param {Boolean} notifier
+    @public
+    @static
+    **/
+    on: function (node, subscription, notifier) {
+        subscription[HANDLES.START] = node.on(EVT_START, this._start, this, node, subscription, notifier);
+    },
+
+    /**
+    Detaches all event subscriptions set up by the event-tap module
+
+    @method detach
+    @param {Node} node
+    @param {Array} subscription
+    @param {Boolean} notifier
+    @public
+    @static
+    **/
+    detach: function (node, subscription, notifier) {
+        detachHandles(subscription);
+    },
+
+    /**
+    Event delegation for the 'tap' event. The delegated event will use a
+    supplied selector or filtering function to test if the event references at least one
+    node that should trigger the subscription callback.
+
+    Usage:
+
+        node.delegate('tap', function (e) {
+            Y.log('li a inside node was tapped.');
+        }, 'li a');
+
+    @method delegate
+    @param {Node} node
+    @param {Array} subscription
+    @param {Boolean} notifier
+    @param {String | Function} filter
+    @public
+    @static
+    **/
+    delegate: function (node, subscription, notifier, filter) {
+        subscription[HANDLES.START] = Y.delegate(EVT_START, function (e) {
+            this._start(e, node, subscription, notifier, true);
+        }, node, filter, this);
+    },
+
+    /**
+    Detaches the delegated event subscriptions set up by the event-tap module.
+    Only used if you use node.delegate(...) instead of node.on(...);
+
+    @method detachDelegate
+    @param {Node} node
+    @param {Array} subscription
+    @param {Boolean} notifier
+    @public
+    @static
+    **/
+    detachDelegate: function (node, subscription, notifier) {
+        detachHandles(subscription);
+    },
+
+    /**
+    Called when the monitor(s) are tapped on, either through touchstart or mousedown.
+
+    @method _start
+    @param {DOMEventFacade} event
+    @param {Node} node
+    @param {Array} subscription
+    @param {Boolean} notifier
+    @param {Boolean} delegate
+    @protected
+    @static
+    **/
+    _start: function (event, node, subscription, notifier, delegate) {
+
+        var context = {
+                canceled: false,
+                eventType: event.type
+            },
+            preventMouse = subscription.preventMouse || false;
+
+        //move ways to quit early to the top.
+        // no right clicks
+        if (event.button && event.button === 3) {
+            return;
+        }
+
+        // for now just support a 1 finger count (later enhance via config)
+        if (event.touches && event.touches.length !== 1) {
+            return;
+        }
+
+        context.node = delegate ? event.currentTarget : node;
+
+        //There is a double check in here to support event simulation tests, in which
+        //event.touches can be undefined when simulating 'touchstart' on touch devices.
+        if (event.touches) {
+          context.startXY = [ event.touches[0].pageX, event.touches[0].pageY ];
+        }
+        else {
+          context.startXY = [ event.pageX, event.pageY ];
+        }
+
+        //If `onTouchStart()` was called by a touch event, set up touch event subscriptions.
+        //Otherwise, set up mouse/pointer event event subscriptions.
+        if (event.touches) {
+
+            subscription[HANDLES.END] = node.once('touchend', this._end, this, node, subscription, notifier, delegate, context);
+            subscription[HANDLES.CANCEL] = node.once('touchcancel', this.detach, this, node, subscription, notifier, delegate, context);
+
+            //Since this is a touch* event, there will be corresponding mouse events
+            //that will be fired. We don't want these events to get picked up and fire
+            //another `tap` event, so we'll set this variable to `true`.
+            subscription.preventMouse = true;
+        }
+
+        //Only add these listeners if preventMouse is `false`
+        //ie: not when touch events have already been subscribed to
+        else if (context.eventType.indexOf('mouse') !== -1 && !preventMouse) {
+            subscription[HANDLES.END] = node.once('mouseup', this._end, this, node, subscription, notifier, delegate, context);
+            subscription[HANDLES.CANCEL] = node.once('mousecancel', this.detach, this, node, subscription, notifier, delegate, context);
+        }
+
+        //If a mouse event comes in after a touch event, it will go in here and
+        //reset preventMouse to `true`.
+        //If a mouse event comes in without a prior touch event, preventMouse will be
+        //false in any case, so this block doesn't do anything.
+        else if (context.eventType.indexOf('mouse') !== -1 && preventMouse) {
+            subscription.preventMouse = false;
+        }
+
+        else if (POINTER_EVENT_TEST.test(context.eventType)) {
+            subscription[HANDLES.END] = node.once(GESTURE_MAP.end, this._end, this, node, subscription, notifier, delegate, context);
+            subscription[HANDLES.CANCEL] = node.once(GESTURE_MAP.cancel, this.detach, this, node, subscription, notifier, delegate, context);
+        }
+
+    },
+
+
+    /**
+    Called when the monitor(s) fires a touchend event (or the mouse equivalent).
+    This method fires the 'tap' event if certain requirements are met.
+
+    @method _end
+    @param {DOMEventFacade} event
+    @param {Node} node
+    @param {Array} subscription
+    @param {Boolean} notifier
+    @param {Boolean} delegate
+    @param {Object} context
+    @protected
+    @static
+    **/
+    _end: function (event, node, subscription, notifier, delegate, context) {
+        var startXY = context.startXY,
+            endXY,
+            clientXY,
+            sensitivity = 15;
+
+        if (subscription._extra && subscription._extra.sensitivity >= 0) {
+            sensitivity = subscription._extra.sensitivity;
+        }
+
+        //There is a double check in here to support event simulation tests, in which
+        //event.touches can be undefined when simulating 'touchstart' on touch devices.
+        if (event.changedTouches) {
+          endXY = [ event.changedTouches[0].pageX, event.changedTouches[0].pageY ];
+          clientXY = [event.changedTouches[0].clientX, event.changedTouches[0].clientY];
+        }
+        else {
+          endXY = [ event.pageX, event.pageY ];
+          clientXY = [event.clientX, event.clientY];
+        }
+
+        // make sure mouse didn't move
+        if (Math.abs(endXY[0] - startXY[0]) <= sensitivity && Math.abs(endXY[1] - startXY[1]) <= sensitivity) {
+
+            event.type = EVT_TAP;
+            event.pageX = endXY[0];
+            event.pageY = endXY[1];
+            event.clientX = clientXY[0];
+            event.clientY = clientXY[1];
+            event.currentTarget = context.node;
+
+            notifier.fire(event);
+        }
+
+        detachHandles(subscription, [HANDLES.END, HANDLES.CANCEL]);
+    }
+});
+
+
+}, '@VERSION@', {"requires": ["node-base", "event-base", "event-touch", "event-synthetic"]});