YUI.add('event-mouseenter', function (Y, NAME) {

/**

 * <p>Adds subscription and delegation support for mouseenter and mouseleave

 * events.  Unlike mouseover and mouseout, these events aren't fired from child

 * elements of a subscribed node.</p>

 *

 * <p>This avoids receiving three mouseover notifications from a setup like</p>

 *

 * <pre><code>div#container > p > a[href]</code></pre>

 *

 * <p>where</p>

 *

 * <pre><code>Y.one('#container').on('mouseover', callback)</code></pre>

 *

 * <p>When the mouse moves over the link, one mouseover event is fired from

 * #container, then when the mouse moves over the p, another mouseover event is

 * fired and bubbles to #container, causing a second notification, and finally

 * when the mouse moves over the link, a third mouseover event is fired and

 * bubbles to #container for a third notification.</p>

 *

 * <p>By contrast, using mouseenter instead of mouseover, the callback would be

 * executed only once when the mouse moves over #container.</p>

 *

 * @module event

 * @submodule event-mouseenter

 */

var domEventProxies = Y.Env.evt.dom_wrappers,

    contains = Y.DOM.contains,

    toArray = Y.Array,

    noop = function () {},

    config = {

        proxyType: "mouseover",

        relProperty: "fromElement",

        _notify: function (e, property, notifier) {

            var el = this._node,

                related = e.relatedTarget || e[property];

            if (el !== related && !contains(el, related)) {

                notifier.fire(new Y.DOMEventFacade(e, el,

                    domEventProxies['event:' + Y.stamp(el) + e.type]));

            }

        },

        on: function (node, sub, notifier) {

            var el = Y.Node.getDOMNode(node),

                args = [

                    this.proxyType,

                    this._notify,

                    el,

                    null,

                    this.relProperty,

                    notifier];

            sub.handle = Y.Event._attach(args, { facade: false });

            // node.on(this.proxyType, notify, null, notifier);

        },

        detach: function (node, sub) {

            sub.handle.detach();

        },

        delegate: function (node, sub, notifier, filter) {

            var el = Y.Node.getDOMNode(node),

                args = [

                    this.proxyType,

                    noop,

                    el,

                    null,

                    notifier

                ];

            sub.handle = Y.Event._attach(args, { facade: false });

            sub.handle.sub.filter = filter;

            sub.handle.sub.relProperty = this.relProperty;

            sub.handle.sub._notify = this._filterNotify;

        },

        _filterNotify: function (thisObj, args, ce) {

            args = args.slice();

            if (this.args) {

                args.push.apply(args, this.args);

            }

            var currentTarget = Y.delegate._applyFilter(this.filter, args, ce),

                related = args[0].relatedTarget || args[0][this.relProperty],

                e, i, len, ret, ct;

            if (currentTarget) {

                currentTarget = toArray(currentTarget);

                for (i = 0, len = currentTarget.length && (!e || !e.stopped); i < len; ++i) {

                    ct = currentTarget[0];

                    if (!contains(ct, related)) {

                        if (!e) {

                            e = new Y.DOMEventFacade(args[0], ct, ce);

                            e.container = Y.one(ce.el);

                        }

                        e.currentTarget = Y.one(ct);

                        // TODO: where is notifier? args? this.notifier?

                        ret = args[1].fire(e);

                        if (ret === false) {

                            break;

                        }

                    }

                }

            }

            return ret;

        },

        detachDelegate: function (node, sub) {

            sub.handle.detach();

        }

    };

Y.Event.define("mouseenter", config, true);

Y.Event.define("mouseleave", Y.merge(config, {

    proxyType: "mouseout",

    relProperty: "toElement"

}), true);

}, '@VERSION@', {"requires": ["event-synthetic"]});