define([

"./core",
"./var/strundefined",
"./var/rnotwhite",
"./var/hasOwn",
"./var/slice",
"./event/support",
"./data/var/data_priv",

"./core/init",
"./data/accepts",
"./selector"

], function( jQuery, strundefined, rnotwhite, hasOwn, slice, support, data_priv ) {

var

rkeyEvent = /^key/,
rmouseEvent = /^(?:mouse|pointer|contextmenu)|click/,
rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;

function returnTrue() {

return true;

}

function returnFalse() {

return false;

}

function safeActiveElement() {

try {
        return document.activeElement;
} catch ( err ) { }

}

/*

* Helper functions for managing events -- not part of the public interface.
* Props to Dean Edwards' addEvent library for many of the ideas.
*/

jQuery.event = {

global: {},

add: function( elem, types, handler, data, selector ) {

        var handleObjIn, eventHandle, tmp,
                events, t, handleObj,
                special, handlers, type, namespaces, origType,
                elemData = data_priv.get( elem );

        // Don't attach events to noData or text/comment nodes (but allow plain objects)
        if ( !elemData ) {
                return;
        }

        // Caller can pass in an object of custom data in lieu of the handler
        if ( handler.handler ) {
                handleObjIn = handler;
                handler = handleObjIn.handler;
                selector = handleObjIn.selector;
        }

        // Make sure that the handler has a unique ID, used to find/remove it later
        if ( !handler.guid ) {
                handler.guid = jQuery.guid++;
        }

        // Init the element's event structure and main handler, if this is the first
        if ( !(events = elemData.events) ) {
                events = elemData.events = {};
        }
        if ( !(eventHandle = elemData.handle) ) {
                eventHandle = elemData.handle = function( e ) {
                        // Discard the second event of a jQuery.event.trigger() and
                        // when an event is called after a page has unloaded
                        return typeof jQuery !== strundefined && jQuery.event.triggered !== e.type ?
                                jQuery.event.dispatch.apply( elem, arguments ) : undefined;
                };
        }

        // Handle multiple events separated by a space
        types = ( types || "" ).match( rnotwhite ) || [ "" ];
        t = types.length;
        while ( t-- ) {
                tmp = rtypenamespace.exec( types[t] ) || [];
                type = origType = tmp[1];
                namespaces = ( tmp[2] || "" ).split( "." ).sort();

                // There *must* be a type, no attaching namespace-only handlers
                if ( !type ) {
                        continue;
                }

                // If event changes its type, use the special event handlers for the changed type
                special = jQuery.event.special[ type ] || {};

                // If selector defined, determine special event api type, otherwise given type
                type = ( selector ? special.delegateType : special.bindType ) || type;

                // Update special based on newly reset type
                special = jQuery.event.special[ type ] || {};

                // handleObj is passed to all event handlers
                handleObj = jQuery.extend({
                        type: type,
                        origType: origType,
                        data: data,
                        handler: handler,
                        guid: handler.guid,
                        selector: selector,
                        needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
                        namespace: namespaces.join(".")
                }, handleObjIn );

                // Init the event handler queue if we're the first
                if ( !(handlers = events[ type ]) ) {
                        handlers = events[ type ] = [];
                        handlers.delegateCount = 0;

                        // Only use addEventListener if the special events handler returns false
                        if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
                                if ( elem.addEventListener ) {
                                        elem.addEventListener( type, eventHandle, false );
                                }
                        }
                }

                if ( special.add ) {
                        special.add.call( elem, handleObj );

                        if ( !handleObj.handler.guid ) {
                                handleObj.handler.guid = handler.guid;
                        }
                }

                // Add to the element's handler list, delegates in front
                if ( selector ) {
                        handlers.splice( handlers.delegateCount++, 0, handleObj );
                } else {
                        handlers.push( handleObj );
                }

                // Keep track of which events have ever been used, for event optimization
                jQuery.event.global[ type ] = true;
        }

},

// Detach an event or set of events from an element
remove: function( elem, types, handler, selector, mappedTypes ) {

        var j, origCount, tmp,
                events, t, handleObj,
                special, handlers, type, namespaces, origType,
                elemData = data_priv.hasData( elem ) && data_priv.get( elem );

        if ( !elemData || !(events = elemData.events) ) {
                return;
        }

        // Once for each type.namespace in types; type may be omitted
        types = ( types || "" ).match( rnotwhite ) || [ "" ];
        t = types.length;
        while ( t-- ) {
                tmp = rtypenamespace.exec( types[t] ) || [];
                type = origType = tmp[1];
                namespaces = ( tmp[2] || "" ).split( "." ).sort();

                // Unbind all events (on this namespace, if provided) for the element
                if ( !type ) {
                        for ( type in events ) {
                                jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
                        }
                        continue;
                }

                special = jQuery.event.special[ type ] || {};
                type = ( selector ? special.delegateType : special.bindType ) || type;
                handlers = events[ type ] || [];
                tmp = tmp[2] && new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" );

                // Remove matching events
                origCount = j = handlers.length;
                while ( j-- ) {
                        handleObj = handlers[ j ];

                        if ( ( mappedTypes || origType === handleObj.origType ) &&
                                ( !handler || handler.guid === handleObj.guid ) &&
                                ( !tmp || tmp.test( handleObj.namespace ) ) &&
                                ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
                                handlers.splice( j, 1 );

                                if ( handleObj.selector ) {
                                        handlers.delegateCount--;
                                }
                                if ( special.remove ) {
                                        special.remove.call( elem, handleObj );
                                }
                        }
                }

                // Remove generic event handler if we removed something and no more handlers exist
                // (avoids potential for endless recursion during removal of special event handlers)
                if ( origCount && !handlers.length ) {
                        if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
                                jQuery.removeEvent( elem, type, elemData.handle );
                        }

                        delete events[ type ];
                }
        }

        // Remove the expando if it's no longer used
        if ( jQuery.isEmptyObject( events ) ) {
                delete elemData.handle;
                data_priv.remove( elem, "events" );
        }
},

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

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

        cur = 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(".") >= 0 ) {
                // 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.namespace_re = 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 && !jQuery.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() ) {

                event.type = i > 1 ?
                        bubbleType :
                        special.bindType || type;

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

                // Native handler
                handle = ontype && cur[ ontype ];
                if ( handle && handle.apply && jQuery.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) &&
                        jQuery.acceptData( elem ) ) {

                        // Call a native DOM method on the target with the same name name as the event.
                        // Don't do default actions on window, that's where global variables be (#6170)
                        if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.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;
                                elem[ type ]();
                                jQuery.event.triggered = undefined;

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

        return event.result;
},

dispatch: function( event ) {

        // Make a writable jQuery.Event from the native event object
        event = jQuery.event.fix( event );

        var i, j, ret, matched, handleObj,
                handlerQueue = [],
                args = slice.call( arguments ),
                handlers = ( data_priv.get( this, "events" ) || {} )[ event.type ] || [],
                special = jQuery.event.special[ event.type ] || {};

        // Use the fix-ed jQuery.Event rather than the (read-only) native event
        args[0] = event;
        event.delegateTarget = this;

        // Call the preDispatch hook for the mapped type, and let it bail if desired
        if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
                return;
        }

        // Determine handlers
        handlerQueue = jQuery.event.handlers.call( this, event, handlers );

        // Run delegates first; they may want to stop propagation beneath us
        i = 0;
        while ( (matched = handlerQueue[ i++ ]) && !event.isPropagationStopped() ) {
                event.currentTarget = matched.elem;

                j = 0;
                while ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) {

                        // Triggered event must either 1) have no namespace, or 2) have namespace(s)
                        // a subset or equal to those in the bound event (both can have no namespace).
                        if ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) {

                                event.handleObj = handleObj;
                                event.data = handleObj.data;

                                ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
                                                .apply( matched.elem, args );

                                if ( ret !== undefined ) {
                                        if ( (event.result = ret) === false ) {
                                                event.preventDefault();
                                                event.stopPropagation();
                                        }
                                }
                        }
                }
        }

        // Call the postDispatch hook for the mapped type
        if ( special.postDispatch ) {
                special.postDispatch.call( this, event );
        }

        return event.result;
},

handlers: function( event, handlers ) {
        var i, matches, sel, handleObj,
                handlerQueue = [],
                delegateCount = handlers.delegateCount,
                cur = event.target;

        // Find delegate handlers
        // Black-hole SVG <use> instance trees (#13180)
        // Avoid non-left-click bubbling in Firefox (#3861)
        if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) {

                for ( ; cur !== this; cur = cur.parentNode || this ) {

                        // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
                        if ( cur.disabled !== true || event.type !== "click" ) {
                                matches = [];
                                for ( i = 0; i < delegateCount; i++ ) {
                                        handleObj = handlers[ i ];

                                        // Don't conflict with Object.prototype properties (#13203)
                                        sel = handleObj.selector + " ";

                                        if ( matches[ sel ] === undefined ) {
                                                matches[ sel ] = handleObj.needsContext ?
                                                        jQuery( sel, this ).index( cur ) >= 0 :
                                                        jQuery.find( sel, this, null, [ cur ] ).length;
                                        }
                                        if ( matches[ sel ] ) {
                                                matches.push( handleObj );
                                        }
                                }
                                if ( matches.length ) {
                                        handlerQueue.push({ elem: cur, handlers: matches });
                                }
                        }
                }
        }

        // Add the remaining (directly-bound) handlers
        if ( delegateCount < handlers.length ) {
                handlerQueue.push({ elem: this, handlers: handlers.slice( delegateCount ) });
        }

        return handlerQueue;
},

// Includes some event props shared by KeyEvent and MouseEvent
props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),

fixHooks: {},

keyHooks: {
        props: "char charCode key keyCode".split(" "),
        filter: function( event, original ) {

                // Add which for key events
                if ( event.which == null ) {
                        event.which = original.charCode != null ? original.charCode : original.keyCode;
                }

                return event;
        }
},

mouseHooks: {
        props: "button buttons clientX clientY offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
        filter: function( event, original ) {
                var eventDoc, doc, body,
                        button = original.button;

                // Calculate pageX/Y if missing and clientX/Y available
                if ( event.pageX == null && original.clientX != null ) {
                        eventDoc = event.target.ownerDocument || document;
                        doc = eventDoc.documentElement;
                        body = eventDoc.body;

                        event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
                        event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
                }

                // Add which for click: 1 === left; 2 === middle; 3 === right
                // Note: button is not normalized, so don't use it
                if ( !event.which && button !== undefined ) {
                        event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
                }

                return event;
        }
},

fix: function( event ) {
        if ( event[ jQuery.expando ] ) {
                return event;
        }

        // Create a writable copy of the event object and normalize some properties
        var i, prop, copy,
                type = event.type,
                originalEvent = event,
                fixHook = this.fixHooks[ type ];

        if ( !fixHook ) {
                this.fixHooks[ type ] = fixHook =
                        rmouseEvent.test( type ) ? this.mouseHooks :
                        rkeyEvent.test( type ) ? this.keyHooks :
                        {};
        }
        copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;

        event = new jQuery.Event( originalEvent );

        i = copy.length;
        while ( i-- ) {
                prop = copy[ i ];
                event[ prop ] = originalEvent[ prop ];
        }

        // Support: Cordova 2.5 (WebKit) (#13255)
        // All events should have a target; Cordova deviceready doesn't
        if ( !event.target ) {
                event.target = document;
        }

        // Support: Safari 6.0+, Chrome<28
        // Target should not be a text node (#504, #13143)
        if ( event.target.nodeType === 3 ) {
                event.target = event.target.parentNode;
        }

        return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
},

special: {
        load: {
                // Prevent triggered image.load events from bubbling to window.load
                noBubble: true
        },
        focus: {
                // Fire native event if possible so blur/focus sequence is correct
                trigger: function() {
                        if ( this !== safeActiveElement() && this.focus ) {
                                this.focus();
                                return false;
                        }
                },
                delegateType: "focusin"
        },
        blur: {
                trigger: function() {
                        if ( this === safeActiveElement() && this.blur ) {
                                this.blur();
                                return false;
                        }
                },
                delegateType: "focusout"
        },
        click: {
                // For checkbox, fire native event so checked state will be right
                trigger: function() {
                        if ( this.type === "checkbox" && this.click && jQuery.nodeName( this, "input" ) ) {
                                this.click();
                                return false;
                        }
                },

                // For cross-browser consistency, don't fire native .click() on links
                _default: function( event ) {
                        return jQuery.nodeName( event.target, "a" );
                }
        },

        beforeunload: {
                postDispatch: function( event ) {

                        // Support: Firefox 20+
                        // Firefox doesn't alert if the returnValue field is not set.
                        if ( event.result !== undefined && event.originalEvent ) {
                                event.originalEvent.returnValue = event.result;
                        }
                }
        }
},

simulate: function( type, elem, event, bubble ) {
        // Piggyback on a donor event to simulate a different one.
        // Fake originalEvent to avoid donor's stopPropagation, but if the
        // simulated event prevents default then we do the same on the donor.
        var e = jQuery.extend(
                new jQuery.Event(),
                event,
                {
                        type: type,
                        isSimulated: true,
                        originalEvent: {}
                }
        );
        if ( bubble ) {
                jQuery.event.trigger( e, null, elem );
        } else {
                jQuery.event.dispatch.call( elem, e );
        }
        if ( e.isDefaultPrevented() ) {
                event.preventDefault();
        }
}

};

jQuery.removeEvent = function( elem, type, handle ) {

if ( elem.removeEventListener ) {
        elem.removeEventListener( type, handle, false );
}

};

jQuery.Event = function( src, props ) {

// Allow instantiation without the 'new' keyword
if ( !(this instanceof jQuery.Event) ) {
        return new jQuery.Event( src, props );
}

// Event object
if ( src && src.type ) {
        this.originalEvent = src;
        this.type = src.type;

        // Events bubbling up the document may have been marked as prevented
        // by a handler lower down the tree; reflect the correct value.
        this.isDefaultPrevented = src.defaultPrevented ||
                        src.defaultPrevented === undefined &&
                        // Support: Android<4.0
                        src.returnValue === false ?
                returnTrue :
                returnFalse;

// Event type
} else {
        this.type = src;
}

// Put explicitly provided properties onto the event object
if ( props ) {
        jQuery.extend( this, props );
}

// Create a timestamp if incoming event doesn't have one
this.timeStamp = src && src.timeStamp || jQuery.now();

// Mark it as fixed
this[ jQuery.expando ] = true;

};

// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding // www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html jQuery.Event.prototype = {

isDefaultPrevented: returnFalse,
isPropagationStopped: returnFalse,
isImmediatePropagationStopped: returnFalse,

preventDefault: function() {
        var e = this.originalEvent;

        this.isDefaultPrevented = returnTrue;

        if ( e && e.preventDefault ) {
                e.preventDefault();
        }
},
stopPropagation: function() {
        var e = this.originalEvent;

        this.isPropagationStopped = returnTrue;

        if ( e && e.stopPropagation ) {
                e.stopPropagation();
        }
},
stopImmediatePropagation: function() {
        var e = this.originalEvent;

        this.isImmediatePropagationStopped = returnTrue;

        if ( e && e.stopImmediatePropagation ) {
                e.stopImmediatePropagation();
        }

        this.stopPropagation();
}

};

// Create mouseenter/leave events using mouseover/out and event-time checks // Support: Chrome 15+ jQuery.each({

mouseenter: "mouseover",
mouseleave: "mouseout",
pointerenter: "pointerover",
pointerleave: "pointerout"

}, function( orig, fix ) {

jQuery.event.special[ orig ] = {
        delegateType: fix,
        bindType: fix,

        handle: function( event ) {
                var ret,
                        target = this,
                        related = event.relatedTarget,
                        handleObj = event.handleObj;

                // For mousenter/leave call the handler if related is outside the target.
                // NB: No relatedTarget if the mouse left/entered the browser window
                if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
                        event.type = handleObj.origType;
                        ret = handleObj.handler.apply( this, arguments );
                        event.type = fix;
                }
                return ret;
        }
};

});

// Support: Firefox, Chrome, Safari // Create “bubbling” focus and blur events if ( !support.focusinBubbles ) {

jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {

        // Attach a single capturing handler on the document while someone wants focusin/focusout
        var handler = function( event ) {
                        jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
                };

        jQuery.event.special[ fix ] = {
                setup: function() {
                        var doc = this.ownerDocument || this,
                                attaches = data_priv.access( doc, fix );

                        if ( !attaches ) {
                                doc.addEventListener( orig, handler, true );
                        }
                        data_priv.access( doc, fix, ( attaches || 0 ) + 1 );
                },
                teardown: function() {
                        var doc = this.ownerDocument || this,
                                attaches = data_priv.access( doc, fix ) - 1;

                        if ( !attaches ) {
                                doc.removeEventListener( orig, handler, true );
                                data_priv.remove( doc, fix );

                        } else {
                                data_priv.access( doc, fix, attaches );
                        }
                }
        };
});

}

jQuery.fn.extend({

on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
        var origFn, type;

        // Types can be a map of types/handlers
        if ( typeof types === "object" ) {
                // ( types-Object, selector, data )
                if ( typeof selector !== "string" ) {
                        // ( types-Object, data )
                        data = data || selector;
                        selector = undefined;
                }
                for ( type in types ) {
                        this.on( type, selector, data, types[ type ], one );
                }
                return this;
        }

        if ( data == null && fn == null ) {
                // ( types, fn )
                fn = selector;
                data = selector = undefined;
        } else if ( fn == null ) {
                if ( typeof selector === "string" ) {
                        // ( types, selector, fn )
                        fn = data;
                        data = undefined;
                } else {
                        // ( types, data, fn )
                        fn = data;
                        data = selector;
                        selector = undefined;
                }
        }
        if ( fn === false ) {
                fn = returnFalse;
        } else if ( !fn ) {
                return this;
        }

        if ( one === 1 ) {
                origFn = fn;
                fn = function( event ) {
                        // Can use an empty set, since event contains the info
                        jQuery().off( event );
                        return origFn.apply( this, arguments );
                };
                // Use same guid so caller can remove using origFn
                fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
        }
        return this.each( function() {
                jQuery.event.add( this, types, fn, data, selector );
        });
},
one: function( types, selector, data, fn ) {
        return this.on( types, selector, data, fn, 1 );
},
off: function( types, selector, fn ) {
        var handleObj, type;
        if ( types && types.preventDefault && types.handleObj ) {
                // ( event )  dispatched jQuery.Event
                handleObj = types.handleObj;
                jQuery( types.delegateTarget ).off(
                        handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
                        handleObj.selector,
                        handleObj.handler
                );
                return this;
        }
        if ( typeof types === "object" ) {
                // ( types-object [, selector] )
                for ( type in types ) {
                        this.off( type, selector, types[ type ] );
                }
                return this;
        }
        if ( selector === false || typeof selector === "function" ) {
                // ( types [, fn] )
                fn = selector;
                selector = undefined;
        }
        if ( fn === false ) {
                fn = returnFalse;
        }
        return this.each(function() {
                jQuery.event.remove( this, types, fn, selector );
        });
},

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; });