define(["./core", "./var/document", "./var/rnotwhite", "./var/hasOwn", "./var/slice", "./event/support", "./data/var/acceptData", "./core/init", "./data", "./selector"] , function (jQuery, document, rnotwhite, hasOwn, slice, support, acceptData){ 
var rformElems = /^(?:input|select|textarea)$/i, rkeyEvent = /^key/, rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/, rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, rtypenamespace = /^([^.]*)(?:\.(.+)|)/; 
function returnTrue(){ 
return true ; 
} 
function returnFalse(){ 
return false ; 
} 
function safeActiveElement(){ 
try { 
return document.activeElement; 
} 
catch (err) { 
} 
} 
function on(elem, types, selector, data, fn, one){ 
var origFn, type; 
if (typeof types === "object") { 
if (typeof selector !== "string") { 
data = data || selector; 
selector = undefined; 
} 
for (type in types){ 
on(elem, type, selector, data, types[type], one); 
} 
return elem; 
} 
if (data == null  && fn == null ) { 
fn = selector; 
data = selector = undefined; 
} 
 else if (fn == null ) { 
if (typeof selector === "string") { 
fn = data; 
data = undefined; 
} 
 else { 
fn = data; 
data = selector; 
selector = undefined; 
} 
} 
if (fn === false ) { 
fn = returnFalse; 
} 
if (one === 1) { 
origFn = fn; 
fn = function (event){ 
jQuery().off(event); 
return origFn.apply(this, arguments); 
} 
; 
fn.guid = origFn.guid || (origFn.guid = jQuery.guid++ ); 
} 
return elem.each(function (){ 
jQuery.event.add(this, types, fn, data, selector); 
} 
); 
} 
jQuery.event = { 
global: { 
}
,
add: function (elem, types, handler, data, selector){ 
var tmp, events, t, handleObjIn, special, eventHandle, handleObj, handlers, type, namespaces, origType, elemData = jQuery._data(elem); 
if (!elemData) { 
return ; 
} 
if (handler.handler) { 
handleObjIn = handler; 
handler = handleObjIn.handler; 
selector = handleObjIn.selector; 
} 
if (!handler.guid) { 
handler.guid = jQuery.guid++ ; 
} 
if (!(events = elemData.events)) { 
events = elemData.events = { 
}
; 
} 
if (!(eventHandle = elemData.handle)) { 
eventHandle = elemData.handle = function (e){ 
return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type)? jQuery.event.dispatch.apply(eventHandle.elem, arguments): undefined; 
} 
; 
eventHandle.elem = elem; 
} 
types = (types || "").match(rnotwhite) || [""] ; 
t = _AN_Read_length("length", types); 
while (t-- ){ 
tmp = rtypenamespace.exec(types[t]) || [] ; 
type = origType = tmp[1]; 
namespaces = (tmp[2] || "").split(".").sort(); 
if (!type) { 
continue ; 
} 
special = jQuery.event.special[type] || { 
}
; 
type = (selector? special.delegateType: special.bindType) || type; 
special = jQuery.event.special[type] || { 
}
; 
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); 
if (!(handlers = events[type])) { 
handlers = events[type] = [] ; 
handlers.delegateCount = 0; 
if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false ) { 
if (elem.addEventListener) { 
elem.addEventListener(type, eventHandle, false ); 
} 
 else if (elem.attachEvent) { 
elem.attachEvent("on" + type, eventHandle); 
} 
} 
} 
if (special.add) { 
special.add.call(elem, handleObj); 
if (!handleObj.handler.guid) { 
handleObj.handler.guid = handler.guid; 
} 
} 
if (selector) { 
handlers.splice(handlers.delegateCount++ , 0, handleObj); 
} 
 else { 
handlers.push(handleObj); 
} 
jQuery.event.global[type] = true ; 
} 
elem = null ; 
} 
,
remove: function (elem, types, handler, selector, mappedTypes){ 
var j, handleObj, tmp, origCount, t, events, special, handlers, type, namespaces, origType, elemData = jQuery.hasData(elem) && jQuery._data(elem); 
if (!elemData || !(events = elemData.events)) { 
return ; 
} 
types = (types || "").match(rnotwhite) || [""] ; 
t = _AN_Read_length("length", types); 
while (t-- ){ 
tmp = rtypenamespace.exec(types[t]) || [] ; 
type = origType = tmp[1]; 
namespaces = (tmp[2] || "").split(".").sort(); 
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("\\.(?:.*\\.|)") + "(\\.|$)"); 
origCount = j = _AN_Read_length("length", handlers); 
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); 
} 
} 
} 
if (origCount && !_AN_Read_length("length", handlers)) { 
if (!special.teardown || special.teardown.call(elem, namespaces, elemData.handle) === false ) { 
jQuery.removeEvent(elem, type, elemData.handle); 
} 
delete events[type]; 
} 
} 
if (jQuery.isEmptyObject(events)) { 
delete elemData.handle; 
jQuery._removeData(elem, "events"); 
} 
} 
,
trigger: function (event, data, elem, onlyHandlers){ 
var handle, ontype, cur, bubbleType, special, tmp, i, eventPath = [elem || document] , type = hasOwn.call(event, "type")? event.type: event, namespaces = hasOwn.call(event, "namespace")? event.namespace.split("."): [] ; 
cur = tmp = elem = elem || document; 
if (elem.nodeType === 3 || elem.nodeType === 8) { 
return ; 
} 
if (rfocusMorph.test(type + jQuery.event.triggered)) { 
return ; 
} 
if (type.indexOf(".") > -1) { 
namespaces = type.split("."); 
type = namespaces.shift(); 
namespaces.sort(); 
} 
ontype = type.indexOf(":") < 0 && "on" + type; 
event = event[jQuery.expando]? event: new jQuery.Event(type, typeof event === "object" && event); 
event.isTrigger = onlyHandlers? 2: 3; 
event.namespace = namespaces.join("."); 
event.rnamespace = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)"): null ; 
event.result = undefined; 
if (!_AN_Read_target("target", event)) { 
_AN_Write_target("target", event, false , elem); 
} 
data = data == null ? [event] : jQuery.makeArray(data, [event] ); 
special = jQuery.event.special[type] || { 
}
; 
if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false ) { 
return ; 
} 
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; 
} 
if (tmp === (elem.ownerDocument || document)) { 
eventPath.push(tmp.defaultView || tmp.parentWindow || window); 
} 
} 
i = 0; 
while ((cur = eventPath[i++ ]) && !event.isPropagationStopped()){ 
event.type = i > 1? bubbleType: special.bindType || type; 
handle = (jQuery._data(cur, "events") || { 
}
)[event.type] && jQuery._data(cur, "handle"); 
if (handle) { 
handle.apply(cur, data); 
} 
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 (!onlyHandlers && !event.isDefaultPrevented()) { 
if ((!special._default || special._default.apply(eventPath.pop(), data) === false ) && acceptData(elem)) { 
if (ontype && elem[type] && !jQuery.isWindow(elem)) { 
tmp = elem[ontype]; 
if (tmp) { 
elem[ontype] = null ; 
} 
jQuery.event.triggered = type; 
try { 
elem[type](); 
} 
catch (e) { 
} 
jQuery.event.triggered = undefined; 
if (tmp) { 
elem[ontype] = tmp; 
} 
} 
} 
} 
return event.result; 
} 
,
dispatch: function (event){ 
event = jQuery.event.fix(event); 
var i, j, ret, matched, handleObj, handlerQueue = [] , args = slice.call(arguments), handlers = (jQuery._data(this, "events") || { 
}
)[event.type] || [] , special = jQuery.event.special[event.type] || { 
}
; 
args[0] = event; 
event.delegateTarget = this; 
if (special.preDispatch && special.preDispatch.call(this, event) === false ) { 
return ; 
} 
handlerQueue = jQuery.event.handlers.call(this, event, handlers); 
i = 0; 
while ((matched = handlerQueue[i++ ]) && !event.isPropagationStopped()){ 
event.currentTarget = matched.elem; 
j = 0; 
while ((handleObj = matched.handlers[j++ ]) && !event.isImmediatePropagationStopped()){ 
if (!event.rnamespace || event.rnamespace.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(); 
} 
} 
} 
} 
} 
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 = _AN_Read_target("target", event); 
if (delegateCount && cur.nodeType && (!event.button || event.type !== "click")) { 
for (; cur != this; cur = cur.parentNode || this){ 
if (cur.nodeType === 1 && (cur.disabled !== true  || event.type !== "click")) { 
matches = [] ; 
for (i = 0; i < delegateCount; i++ ){ 
handleObj = handlers[i]; 
sel = handleObj.selector + " "; 
if (matches[sel] === undefined) { 
matches[sel] = handleObj.needsContext? jQuery(sel, this).index(cur) > -1: _AN_Read_length("length", jQuery.find(sel, this, null , [cur] )); 
} 
if (matches[sel]) { 
matches.push(handleObj); 
} 
} 
if (matches.length) { 
handlerQueue.push({ 
elem: cur,
handlers: matches}
); 
} 
} 
} 
} 
if (delegateCount < _AN_Read_length("length", handlers)) { 
handlerQueue.push({ 
elem: this,
handlers: handlers.slice(delegateCount)}
); 
} 
return handlerQueue; 
} 
,
fix: function (event){ 
if (event[jQuery.expando]) { 
return event; 
} 
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 = _AN_Read_length("length", copy); 
while (i-- ){ 
prop = copy[i]; 
event[prop] = originalEvent[prop]; 
} 
if (!_AN_Read_target("target", event)) { 
_AN_Write_target("target", event, false , originalEvent.srcElement || document); 
} 
if (_AN_Read_target("target", event).nodeType === 3) { 
_AN_Write_target("target", event, false , _AN_Read_target("target", event).parentNode); 
} 
event.metaKey = !!event.metaKey; 
return fixHook.filter? fixHook.filter(event, originalEvent): event; 
} 
,
props: ("altKey bubbles cancelable ctrlKey currentTarget detail eventPhase " + "metaKey relatedTarget shiftKey target timeStamp view which").split(" "),
fixHooks: { 
}
,
keyHooks: { 
props: "char charCode key keyCode".split(" "),
filter: function (event, original){ 
if (event.which == null ) { 
event.which = original.charCode != null ? original.charCode: original.keyCode; 
} 
return event; 
} 
}
,
mouseHooks: { 
props: ("button buttons clientX clientY fromElement offsetX offsetY " + "pageX pageY screenX screenY toElement").split(" "),
filter: function (event, original){ 
var body, eventDoc, doc, button = original.button, fromElement = original.fromElement; 
if (event.pageX == null  && original.clientX != null ) { 
eventDoc = _AN_Read_target("target", event).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); 
} 
if (!event.relatedTarget && fromElement) { 
event.relatedTarget = fromElement === _AN_Read_target("target", event)? original.toElement: fromElement; 
} 
if (!event.which && button !== undefined) { 
event.which = (button & 1? 1: (button & 2? 3: (button & 4? 2: 0))); 
} 
return event; 
} 
}
,
special: { 
load: { 
noBubble: true }
,
focus: { 
trigger: function (){ 
if (this !== safeActiveElement() && this.focus) { 
try { 
this.focus(); 
return false ; 
} 
catch (e) { 
} 
} 
} 
,
delegateType: "focusin"}
,
blur: { 
trigger: function (){ 
if (this === safeActiveElement() && this.blur) { 
this.blur(); 
return false ; 
} 
} 
,
delegateType: "focusout"}
,
click: { 
trigger: function (){ 
if (jQuery.nodeName(this, "input") && this.type === "checkbox" && this.click) { 
this.click(); 
return false ; 
} 
} 
,
_default: function (event){ 
return jQuery.nodeName(_AN_Read_target("target", event), "a"); 
} 
}
,
beforeunload: { 
postDispatch: function (event){ 
if (event.result !== undefined && event.originalEvent) { 
event.originalEvent.returnValue = event.result; 
} 
} 
}
}
,
simulate: function (type, elem, event){ 
var e = jQuery.extend(new jQuery.Event(), event, { 
type: type,
isSimulated: true }
); 
jQuery.event.trigger(e, null , elem); 
if (e.isDefaultPrevented()) { 
event.preventDefault(); 
} 
} 
}
; 
jQuery.removeEvent = document.removeEventListener? function (elem, type, handle){ 
if (elem.removeEventListener) { 
elem.removeEventListener(type, handle); 
} 
} 
: function (elem, type, handle){ 
var name = "on" + type; 
if (elem.detachEvent) { 
if (typeof elem[name] === "undefined") { 
elem[name] = null ; 
} 
elem.detachEvent(name, handle); 
} 
} 
; 
jQuery.Event = function (src, props){ 
if (!(this instanceof jQuery.Event)) { 
return new jQuery.Event(src, props); 
} 
if (src && src.type) { 
this.originalEvent = src; 
this.type = src.type; 
this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === undefined && src.returnValue === false ? returnTrue: returnFalse; 
} 
 else { 
this.type = src; 
} 
if (props) { 
jQuery.extend(this, props); 
} 
this.timeStamp = src && src.timeStamp || jQuery.now(); 
this[jQuery.expando] = true ; 
} 
; 
jQuery.Event.prototype = { 
constructor: jQuery.Event,
isDefaultPrevented: returnFalse,
isPropagationStopped: returnFalse,
isImmediatePropagationStopped: returnFalse,
preventDefault: function (){ 
var e = this.originalEvent; 
this.isDefaultPrevented = returnTrue; 
if (!e) { 
return ; 
} 
if (e.preventDefault) { 
e.preventDefault(); 
} 
 else { 
e.returnValue = false ; 
} 
} 
,
stopPropagation: function (){ 
var e = this.originalEvent; 
this.isPropagationStopped = returnTrue; 
if (!e || this.isSimulated) { 
return ; 
} 
if (e.stopPropagation) { 
e.stopPropagation(); 
} 
e.cancelBubble = true ; 
} 
,
stopImmediatePropagation: function (){ 
var e = this.originalEvent; 
this.isImmediatePropagationStopped = returnTrue; 
if (e && e.stopImmediatePropagation) { 
e.stopImmediatePropagation(); 
} 
this.stopPropagation(); 
} 
}
; 
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; 
if (!related || (related !== target && !jQuery.contains(target, related))) { 
event.type = handleObj.origType; 
ret = handleObj.handler.apply(this, arguments); 
event.type = fix; 
} 
return ret; 
} 
}
; 
} 
); 
if (!support.submit) { 
jQuery.event.special.submit = { 
setup: function (){ 
if (jQuery.nodeName(this, "form")) { 
return false ; 
} 
jQuery.event.add(this, "click._submit keypress._submit", function (e){ 
var elem = _AN_Read_target("target", e), form = jQuery.nodeName(elem, "input") || jQuery.nodeName(elem, "button")? jQuery.prop(elem, "form"): undefined; 
if (form && !jQuery._data(form, "submit")) { 
jQuery.event.add(form, "submit._submit", function (event){ 
event._submitBubble = true ; 
} 
); 
jQuery._data(form, "submit", true ); 
} 
} 
); 
} 
,
postDispatch: function (event){ 
if (event._submitBubble) { 
delete event._submitBubble; 
if (this.parentNode && !event.isTrigger) { 
jQuery.event.simulate("submit", this.parentNode, event); 
} 
} 
} 
,
teardown: function (){ 
if (jQuery.nodeName(this, "form")) { 
return false ; 
} 
jQuery.event.remove(this, "._submit"); 
} 
}
; 
} 
if (!support.change) { 
jQuery.event.special.change = { 
setup: function (){ 
if (rformElems.test(this.nodeName)) { 
if (this.type === "checkbox" || this.type === "radio") { 
jQuery.event.add(this, "propertychange._change", function (event){ 
if (event.originalEvent.propertyName === "checked") { 
this._justChanged = true ; 
} 
} 
); 
jQuery.event.add(this, "click._change", function (event){ 
if (this._justChanged && !event.isTrigger) { 
this._justChanged = false ; 
} 
jQuery.event.simulate("change", this, event); 
} 
); 
} 
return false ; 
} 
jQuery.event.add(this, "beforeactivate._change", function (e){ 
var elem = _AN_Read_target("target", e); 
if (rformElems.test(elem.nodeName) && !jQuery._data(elem, "change")) { 
jQuery.event.add(elem, "change._change", function (event){ 
if (this.parentNode && !event.isSimulated && !event.isTrigger) { 
jQuery.event.simulate("change", this.parentNode, event); 
} 
} 
); 
jQuery._data(elem, "change", true ); 
} 
} 
); 
} 
,
handle: function (event){ 
var elem = _AN_Read_target("target", event); 
if (this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox")) { 
return event.handleObj.handler.apply(this, arguments); 
} 
} 
,
teardown: function (){ 
jQuery.event.remove(this, "._change"); 
return !rformElems.test(this.nodeName); 
} 
}
; 
} 
if (!support.focusin) { 
jQuery.each({ 
focus: "focusin",
blur: "focusout"}
, function (orig, fix){ 
var handler = function (event){ 
jQuery.event.simulate(fix, _AN_Read_target("target", event), jQuery.event.fix(event)); 
} 
; 
jQuery.event.special[fix] = { 
setup: function (){ 
var doc = this.ownerDocument || this, attaches = jQuery._data(doc, fix); 
if (!attaches) { 
doc.addEventListener(orig, handler, true ); 
} 
jQuery._data(doc, fix, (attaches || 0) + 1); 
} 
,
teardown: function (){ 
var doc = this.ownerDocument || this, attaches = jQuery._data(doc, fix) - 1; 
if (!attaches) { 
doc.removeEventListener(orig, handler, true ); 
jQuery._removeData(doc, fix); 
} 
 else { 
jQuery._data(doc, fix, attaches); 
} 
} 
}
; 
} 
); 
} 
jQuery.fn.extend({ 
on: function (types, selector, data, fn){ 
return on(this, types, selector, data, fn); 
} 
,
one: function (types, selector, data, fn){ 
return on(this, types, selector, data, fn, 1); 
} 
,
off: function (types, selector, fn){ 
var handleObj, type; 
if (types && types.preventDefault && types.handleObj) { 
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") { 
for (type in types){ 
this.off(type, selector, types[type]); 
} 
return this; 
} 
if (selector === false  || typeof selector === "function") { 
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; 
} 
);