define( [

"../core",
"../var/document",
"../data/var/dataPriv",
"../data/var/acceptData",
"../var/hasOwn",
"../var/isFunction",
"../var/isWindow",
"../event"

], function( jQuery, document, dataPriv, acceptData, hasOwn, isFunction, isWindow ) {

“use strict”;

var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,

stopPropagationCallback = function( e ) {
        e.stopPropagation();
};

jQuery.extend( jQuery.event, {

trigger: function( event, data, elem, onlyHandlers ) {

        var i, cur, tmp, bubbleType, ontype, handle, special, lastElement,
                eventPath = [ elem || document ],
                type = hasOwn.call( event, "type" ) ? event.type : event,
                namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];

        cur = lastElement = tmp = elem = elem || document;

        // Don't do events on text and comment nodes
        if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
                return;
        }

        // focus/blur morphs to focusin/out; ensure we're not firing them right now
        if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
                return;
        }

        if ( type.indexOf( "." ) > -1 ) {

                // Namespaced trigger; create a regexp to match event type in handle()
                namespaces = type.split( "." );
                type = namespaces.shift();
                namespaces.sort();
        }
        ontype = type.indexOf( ":" ) < 0 && "on" + type;

        // Caller can pass in a jQuery.Event object, Object, or just an event type string
        event = event[ jQuery.expando ] ?
                event :
                new jQuery.Event( type, typeof event === "object" && event );

        // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
        event.isTrigger = onlyHandlers ? 2 : 3;
        event.namespace = namespaces.join( "." );
        event.rnamespace = event.namespace ?
                new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
                null;

        // Clean up the event in case it is being reused
        event.result = undefined;
        if ( !event.target ) {
                event.target = elem;
        }

        // Clone any incoming data and prepend the event, creating the handler arg list
        data = data == null ?
                [ event ] :
                jQuery.makeArray( data, [ event ] );

        // Allow special events to draw outside the lines
        special = jQuery.event.special[ type ] || {};
        if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
                return;
        }

        // Determine event propagation path in advance, per W3C events spec (#9951)
        // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
        if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {

                bubbleType = special.delegateType || type;
                if ( !rfocusMorph.test( bubbleType + type ) ) {
                        cur = cur.parentNode;
                }
                for ( ; cur; cur = cur.parentNode ) {
                        eventPath.push( cur );
                        tmp = cur;
                }

                // Only add window if we got to document (e.g., not plain obj or detached DOM)
                if ( tmp === ( elem.ownerDocument || document ) ) {
                        eventPath.push( tmp.defaultView || tmp.parentWindow || window );
                }
        }

        // Fire handlers on the event path
        i = 0;
        while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
                lastElement = cur;
                event.type = i > 1 ?
                        bubbleType :
                        special.bindType || type;

                // jQuery handler
                handle = (
                                dataPriv.get( cur, "events" ) || Object.create( null )
                        )[ event.type ] &&
                        dataPriv.get( cur, "handle" );
                if ( handle ) {
                        handle.apply( cur, data );
                }

                // Native handler
                handle = ontype && cur[ ontype ];
                if ( handle && handle.apply && acceptData( cur ) ) {
                        event.result = handle.apply( cur, data );
                        if ( event.result === false ) {
                                event.preventDefault();
                        }
                }
        }
        event.type = type;

        // If nobody prevented the default action, do it now
        if ( !onlyHandlers && !event.isDefaultPrevented() ) {

                if ( ( !special._default ||
                        special._default.apply( eventPath.pop(), data ) === false ) &&
                        acceptData( elem ) ) {

                        // Call a native DOM method on the target with the same name as the event.
                        // Don't do default actions on window, that's where global variables be (#6170)
                        if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {

                                // Don't re-trigger an onFOO event when we call its FOO() method
                                tmp = elem[ ontype ];

                                if ( tmp ) {
                                        elem[ ontype ] = null;
                                }

                                // Prevent re-triggering of the same event, since we already bubbled it above
                                jQuery.event.triggered = type;

                                if ( event.isPropagationStopped() ) {
                                        lastElement.addEventListener( type, stopPropagationCallback );
                                }

                                elem[ type ]();

                                if ( event.isPropagationStopped() ) {
                                        lastElement.removeEventListener( type, stopPropagationCallback );
                                }

                                jQuery.event.triggered = undefined;

                                if ( tmp ) {
                                        elem[ ontype ] = tmp;
                                }
                        }
                }
        }

        return event.result;
},

// Piggyback on a donor event to simulate a different one
// Used only for `focus(in | out)` events
simulate: function( type, elem, event ) {
        var e = jQuery.extend(
                new jQuery.Event(),
                event,
                {
                        type: type,
                        isSimulated: true
                }
        );

        jQuery.event.trigger( e, null, elem );
}

} );

jQuery.fn.extend( {

trigger: function( type, data ) {
        return this.each( function() {
                jQuery.event.trigger( type, data, this );
        } );
},
triggerHandler: function( type, data ) {
        var elem = this[ 0 ];
        if ( elem ) {
                return jQuery.event.trigger( type, data, elem, true );
        }
}

} );

return jQuery; } );