UNPKG

jquery/src/event.js

Version:
24.6 kBJavaScriptView Raw
1define( [
"./core",
"./var/document",
"./var/documentElement",
"./var/isFunction",
"./var/rnothtmlwhite",
"./var/rcheckableType",
"./var/slice",
"./data/var/acceptData",
"./data/var/dataPriv",
"./core/nodeName",
12
"./core/init",
"./selector"
15], function( jQuery, document, documentElement, isFunction, rnothtmlwhite,
rcheckableType, slice, acceptData, dataPriv, nodeName ) {
17
18"use strict";
19
20var
rkeyEvent = /^key/,
rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
24
25function returnTrue() {
return true;
27}
28
29function returnFalse() {
return false;
31}
32
33// Support: IE <=9 - 11+
34// focus() and blur() are asynchronous, except when they are no-op.
35// So expect focus to be synchronous when the element is already active,
36// and blur to be synchronous when the element is not already active.
37// (focus and blur are always synchronous in other supported browsers,
38// this just defines when we can count on it).
39function expectSync( elem, type ) {
return ( elem === safeActiveElement() ) === ( type === "focus" );
41}
42
43// Support: IE <=9 only
44// Accessing document.activeElement can throw unexpectedly
45// https://bugs.jquery.com/ticket/13393
46function safeActiveElement() {
try {
return document.activeElement;
} catch ( err ) { }
50}
51
52function on( elem, types, selector, data, fn, one ) {
var origFn, type;
54
// Types can be a map of types/handlers
if ( typeof types === "object" ) {
57
// ( types-Object, selector, data )
if ( typeof selector !== "string" ) {
60
	// ( types-Object, data )
	data = data || selector;
	selector = undefined;
}
for ( type in types ) {
	on( elem, type, selector, data, types[ type ], one );
}
return elem;
}
70
if ( data == null && fn == null ) {
72
// ( types, fn )
fn = selector;
data = selector = undefined;
} else if ( fn == null ) {
if ( typeof selector === "string" ) {
78
	// ( types, selector, fn )
	fn = data;
	data = undefined;
} else {
83
	// ( types, data, fn )
	fn = data;
	data = selector;
	selector = undefined;
}
}
if ( fn === false ) {
fn = returnFalse;
} else if ( !fn ) {
return elem;
}
95
if ( one === 1 ) {
origFn = fn;
fn = function( event ) {
99
	// Can use an empty set, since event contains the info
	jQuery().off( event );
	return origFn.apply( this, arguments );
};
104
// Use same guid so caller can remove using origFn
fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
}
return elem.each( function() {
jQuery.event.add( this, types, fn, data, selector );
} );
111}
112
113/*
* Helper functions for managing events -- not part of the public interface.
* Props to Dean Edwards' addEvent library for many of the ideas.
*/
117jQuery.event = {
118
global: {},
120
add: function( elem, types, handler, data, selector ) {
122
var handleObjIn, eventHandle, tmp,
	events, t, handleObj,
	special, handlers, type, namespaces, origType,
	elemData = dataPriv.get( elem );
127
// Only attach events to objects that accept data
if ( !acceptData( elem ) ) {
	return;
}
132
// 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;
}
139
// Ensure that invalid selectors throw exceptions at attach time
// Evaluate against documentElement in case elem is a non-element node (e.g., document)
if ( selector ) {
	jQuery.find.matchesSelector( documentElement, selector );
}
145
// Make sure that the handler has a unique ID, used to find/remove it later
if ( !handler.guid ) {
	handler.guid = jQuery.guid++;
}
150
// Init the element's event structure and main handler, if this is the first
if ( !( events = elemData.events ) ) {
	events = elemData.events = Object.create( null );
}
if ( !( eventHandle = elemData.handle ) ) {
	eventHandle = elemData.handle = function( e ) {
157
		// Discard the second event of a jQuery.event.trigger() and
		// when an event is called after a page has unloaded
		return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
			jQuery.event.dispatch.apply( elem, arguments ) : undefined;
	};
}
164
// Handle multiple events separated by a space
types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
t = types.length;
while ( t-- ) {
	tmp = rtypenamespace.exec( types[ t ] ) || [];
	type = origType = tmp[ 1 ];
	namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
172
	// There *must* be a type, no attaching namespace-only handlers
	if ( !type ) {
		continue;
	}
177
	// If event changes its type, use the special event handlers for the changed type
	special = jQuery.event.special[ type ] || {};
180
	// If selector defined, determine special event api type, otherwise given type
	type = ( selector ? special.delegateType : special.bindType ) || type;
183
	// Update special based on newly reset type
	special = jQuery.event.special[ type ] || {};
186
	// 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 );
198
	// Init the event handler queue if we're the first
	if ( !( handlers = events[ type ] ) ) {
		handlers = events[ type ] = [];
		handlers.delegateCount = 0;
203
		// Only use addEventListener if the special events handler returns false
		if ( !special.setup ||
			special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
207
			if ( elem.addEventListener ) {
				elem.addEventListener( type, eventHandle );
			}
		}
	}
213
	if ( special.add ) {
		special.add.call( elem, handleObj );
216
		if ( !handleObj.handler.guid ) {
			handleObj.handler.guid = handler.guid;
		}
	}
221
	// Add to the element's handler list, delegates in front
	if ( selector ) {
		handlers.splice( handlers.delegateCount++, 0, handleObj );
	} else {
		handlers.push( handleObj );
	}
228
	// Keep track of which events have ever been used, for event optimization
	jQuery.event.global[ type ] = true;
}
232
},
234
// Detach an event or set of events from an element
remove: function( elem, types, handler, selector, mappedTypes ) {
237
var j, origCount, tmp,
	events, t, handleObj,
	special, handlers, type, namespaces, origType,
	elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
242
if ( !elemData || !( events = elemData.events ) ) {
	return;
}
246
// Once for each type.namespace in types; type may be omitted
types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
t = types.length;
while ( t-- ) {
	tmp = rtypenamespace.exec( types[ t ] ) || [];
	type = origType = tmp[ 1 ];
	namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
254
	// 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;
	}
262
	special = jQuery.event.special[ type ] || {};
	type = ( selector ? special.delegateType : special.bindType ) || type;
	handlers = events[ type ] || [];
	tmp = tmp[ 2 ] &&
		new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
268
	// Remove matching events
	origCount = j = handlers.length;
	while ( j-- ) {
		handleObj = handlers[ j ];
273
		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 );
280
			if ( handleObj.selector ) {
				handlers.delegateCount--;
			}
			if ( special.remove ) {
				special.remove.call( elem, handleObj );
			}
		}
	}
289
	// 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 ) {
295
			jQuery.removeEvent( elem, type, elemData.handle );
		}
298
		delete events[ type ];
	}
}
302
// Remove data and the expando if it's no longer used
if ( jQuery.isEmptyObject( events ) ) {
	dataPriv.remove( elem, "handle events" );
}
},
308
dispatch: function( nativeEvent ) {
310
var i, j, ret, matched, handleObj, handlerQueue,
	args = new Array( arguments.length ),
313
	// Make a writable jQuery.Event from the native event object
	event = jQuery.event.fix( nativeEvent ),
316
	handlers = (
			dataPriv.get( this, "events" ) || Object.create( null )
		)[ event.type ] || [],
	special = jQuery.event.special[ event.type ] || {};
321
// Use the fix-ed jQuery.Event rather than the (read-only) native event
args[ 0 ] = event;
324
for ( i = 1; i < arguments.length; i++ ) {
	args[ i ] = arguments[ i ];
}
328
event.delegateTarget = this;
330
// Call the preDispatch hook for the mapped type, and let it bail if desired
if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
	return;
}
335
// Determine handlers
handlerQueue = jQuery.event.handlers.call( this, event, handlers );
338
// Run delegates first; they may want to stop propagation beneath us
i = 0;
while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
	event.currentTarget = matched.elem;
343
	j = 0;
	while ( ( handleObj = matched.handlers[ j++ ] ) &&
		!event.isImmediatePropagationStopped() ) {
347
		// If the event is namespaced, then each handler is only invoked if it is
		// specially universal or its namespaces are a superset of the event's.
		if ( !event.rnamespace || handleObj.namespace === false ||
			event.rnamespace.test( handleObj.namespace ) ) {
352
			event.handleObj = handleObj;
			event.data = handleObj.data;
355
			ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
				handleObj.handler ).apply( matched.elem, args );
358
			if ( ret !== undefined ) {
				if ( ( event.result = ret ) === false ) {
					event.preventDefault();
					event.stopPropagation();
				}
			}
		}
	}
}
368
// Call the postDispatch hook for the mapped type
if ( special.postDispatch ) {
	special.postDispatch.call( this, event );
}
373
return event.result;
},
376
handlers: function( event, handlers ) {
var i, handleObj, sel, matchedHandlers, matchedSelectors,
	handlerQueue = [],
	delegateCount = handlers.delegateCount,
	cur = event.target;
382
// Find delegate handlers
if ( delegateCount &&
385
	// Support: IE <=9
	// Black-hole SVG <use> instance trees (trac-13180)
	cur.nodeType &&
389
	// Support: Firefox <=42
	// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
	// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
	// Support: IE 11 only
	// ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
	!( event.type === "click" && event.button >= 1 ) ) {
396
	for ( ; cur !== this; cur = cur.parentNode || this ) {
398
		// Don't check non-elements (#13208)
		// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
		if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
			matchedHandlers = [];
			matchedSelectors = {};
			for ( i = 0; i < delegateCount; i++ ) {
				handleObj = handlers[ i ];
406
				// Don't conflict with Object.prototype properties (#13203)
				sel = handleObj.selector + " ";
409
				if ( matchedSelectors[ sel ] === undefined ) {
					matchedSelectors[ sel ] = handleObj.needsContext ?
						jQuery( sel, this ).index( cur ) > -1 :
						jQuery.find( sel, this, null, [ cur ] ).length;
				}
				if ( matchedSelectors[ sel ] ) {
					matchedHandlers.push( handleObj );
				}
			}
			if ( matchedHandlers.length ) {
				handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
			}
		}
	}
}
425
// Add the remaining (directly-bound) handlers
cur = this;
if ( delegateCount < handlers.length ) {
	handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
}
431
return handlerQueue;
},
434
addProp: function( name, hook ) {
Object.defineProperty( jQuery.Event.prototype, name, {
	enumerable: true,
	configurable: true,
439
	get: isFunction( hook ) ?
		function() {
			if ( this.originalEvent ) {
					return hook( this.originalEvent );
			}
		} :
		function() {
			if ( this.originalEvent ) {
					return this.originalEvent[ name ];
			}
		},
451
	set: function( value ) {
		Object.defineProperty( this, name, {
			enumerable: true,
			configurable: true,
			writable: true,
			value: value
		} );
	}
} );
},
462
fix: function( originalEvent ) {
return originalEvent[ jQuery.expando ] ?
	originalEvent :
	new jQuery.Event( originalEvent );
},
468
special: {
load: {
471
	// Prevent triggered image.load events from bubbling to window.load
	noBubble: true
},
click: {
476
	// Utilize native event to ensure correct state for checkable inputs
	setup: function( data ) {
479
		// For mutual compressibility with _default, replace `this` access with a local var.
		// `|| data` is dead code meant only to preserve the variable through minification.
		var el = this || data;
483
		// Claim the first handler
		if ( rcheckableType.test( el.type ) &&
			el.click && nodeName( el, "input" ) ) {
487
			// dataPriv.set( el, "click", ... )
			leverageNative( el, "click", returnTrue );
		}
491
		// Return false to allow normal processing in the caller
		return false;
	},
	trigger: function( data ) {
496
		// For mutual compressibility with _default, replace `this` access with a local var.
		// `|| data` is dead code meant only to preserve the variable through minification.
		var el = this || data;
500
		// Force setup before triggering a click
		if ( rcheckableType.test( el.type ) &&
			el.click && nodeName( el, "input" ) ) {
504
			leverageNative( el, "click" );
		}
507
		// Return non-false to allow normal event-path propagation
		return true;
	},
511
	// For cross-browser consistency, suppress native .click() on links
	// Also prevent it if we're currently inside a leveraged native-event stack
	_default: function( event ) {
		var target = event.target;
		return rcheckableType.test( target.type ) &&
			target.click && nodeName( target, "input" ) &&
			dataPriv.get( target, "click" ) ||
			nodeName( target, "a" );
	}
},
522
beforeunload: {
	postDispatch: function( event ) {
525
		// 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;
		}
	}
}
}
534};
535
536// Ensure the presence of an event listener that handles manually-triggered
537// synthetic events by interrupting progress until reinvoked in response to
538// *native* events that it fires directly, ensuring that state changes have
539// already occurred before other listeners are invoked.
540function leverageNative( el, type, expectSync ) {
541
// Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add
if ( !expectSync ) {
if ( dataPriv.get( el, type ) === undefined ) {
	jQuery.event.add( el, type, returnTrue );
}
return;
}
549
// Register the controller as a special universal handler for all event namespaces
dataPriv.set( el, type, false );
jQuery.event.add( el, type, {
namespace: false,
handler: function( event ) {
	var notAsync, result,
		saved = dataPriv.get( this, type );
557
	if ( ( event.isTrigger & 1 ) && this[ type ] ) {
559
		// Interrupt processing of the outer synthetic .trigger()ed event
		// Saved data should be false in such cases, but might be a leftover capture object
		// from an async native handler (gh-4350)
		if ( !saved.length ) {
564
			// Store arguments for use when handling the inner native event
			// There will always be at least one argument (an event object), so this array
			// will not be confused with a leftover capture object.
			saved = slice.call( arguments );
			dataPriv.set( this, type, saved );
570
			// Trigger the native event and capture its result
			// Support: IE <=9 - 11+
			// focus() and blur() are asynchronous
			notAsync = expectSync( this, type );
			this[ type ]();
			result = dataPriv.get( this, type );
			if ( saved !== result || notAsync ) {
				dataPriv.set( this, type, false );
			} else {
				result = {};
			}
			if ( saved !== result ) {
583
				// Cancel the outer synthetic event
				event.stopImmediatePropagation();
				event.preventDefault();
				return result.value;
			}
589
		// If this is an inner synthetic event for an event with a bubbling surrogate
		// (focus or blur), assume that the surrogate already propagated from triggering the
		// native event and prevent that from happening again here.
		// This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the
		// bubbling surrogate propagates *after* the non-bubbling base), but that seems
		// less bad than duplication.
		} else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {
			event.stopPropagation();
		}
599
	// If this is a native event triggered above, everything is now in order
	// Fire an inner synthetic event with the original arguments
	} else if ( saved.length ) {
603
		// ...and capture the result
		dataPriv.set( this, type, {
			value: jQuery.event.trigger(
607
				// Support: IE <=9 - 11+
				// Extend with the prototype to reset the above stopImmediatePropagation()
				jQuery.extend( saved[ 0 ], jQuery.Event.prototype ),
				saved.slice( 1 ),
				this
			)
		} );
615
		// Abort handling of the native event
		event.stopImmediatePropagation();
	}
}
} );
621}
622
623jQuery.removeEvent = function( elem, type, handle ) {
624
// This "if" is needed for plain objects
if ( elem.removeEventListener ) {
elem.removeEventListener( type, handle );
}
629};
630
631jQuery.Event = function( src, props ) {
632
// Allow instantiation without the 'new' keyword
if ( !( this instanceof jQuery.Event ) ) {
return new jQuery.Event( src, props );
}
637
// Event object
if ( src && src.type ) {
this.originalEvent = src;
this.type = src.type;
642
// 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 &&
647
		// Support: Android <=2.3 only
		src.returnValue === false ?
	returnTrue :
	returnFalse;
652
// Create target properties
// Support: Safari <=6 - 7 only
// Target should not be a text node (#504, #13143)
this.target = ( src.target && src.target.nodeType === 3 ) ?
	src.target.parentNode :
	src.target;
659
this.currentTarget = src.currentTarget;
this.relatedTarget = src.relatedTarget;
662
// Event type
} else {
this.type = src;
}
667
// Put explicitly provided properties onto the event object
if ( props ) {
jQuery.extend( this, props );
}
672
// Create a timestamp if incoming event doesn't have one
this.timeStamp = src && src.timeStamp || Date.now();
675
// Mark it as fixed
this[ jQuery.expando ] = true;
678};
679
680// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
681// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
682jQuery.Event.prototype = {
constructor: jQuery.Event,
isDefaultPrevented: returnFalse,
isPropagationStopped: returnFalse,
isImmediatePropagationStopped: returnFalse,
isSimulated: false,
688
preventDefault: function() {
var e = this.originalEvent;
691
this.isDefaultPrevented = returnTrue;
693
if ( e && !this.isSimulated ) {
	e.preventDefault();
}
},
stopPropagation: function() {
var e = this.originalEvent;
700
this.isPropagationStopped = returnTrue;
702
if ( e && !this.isSimulated ) {
	e.stopPropagation();
}
},
stopImmediatePropagation: function() {
var e = this.originalEvent;
709
this.isImmediatePropagationStopped = returnTrue;
711
if ( e && !this.isSimulated ) {
	e.stopImmediatePropagation();
}
715
this.stopPropagation();
}
718};
719
720// Includes all common event props including KeyEvent and MouseEvent specific props
721jQuery.each( {
altKey: true,
bubbles: true,
cancelable: true,
changedTouches: true,
ctrlKey: true,
detail: true,
eventPhase: true,
metaKey: true,
pageX: true,
pageY: true,
shiftKey: true,
view: true,
"char": true,
code: true,
charCode: true,
key: true,
keyCode: true,
button: true,
buttons: true,
clientX: true,
clientY: true,
offsetX: true,
offsetY: true,
pointerId: true,
pointerType: true,
screenX: true,
screenY: true,
targetTouches: true,
toElement: true,
touches: true,
752
which: function( event ) {
var button = event.button;
755
// Add which for key events
if ( event.which == null && rkeyEvent.test( event.type ) ) {
	return event.charCode != null ? event.charCode : event.keyCode;
}
760
// Add which for click: 1 === left; 2 === middle; 3 === right
if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {
	if ( button & 1 ) {
		return 1;
	}
766
	if ( button & 2 ) {
		return 3;
	}
770
	if ( button & 4 ) {
		return 2;
	}
774
	return 0;
}
777
return event.which;
}
780}, jQuery.event.addProp );
781
782jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) {
jQuery.event.special[ type ] = {
784
// Utilize native event if possible so blur/focus sequence is correct
setup: function() {
787
	// Claim the first handler
	// dataPriv.set( this, "focus", ... )
	// dataPriv.set( this, "blur", ... )
	leverageNative( this, type, expectSync );
792
	// Return false to allow normal processing in the caller
	return false;
},
trigger: function() {
797
	// Force setup before trigger
	leverageNative( this, type );
800
	// Return non-false to allow normal event-path propagation
	return true;
},
804
delegateType: delegateType
};
807} );
808
809// Create mouseenter/leave events using mouseover/out and event-time checks
810// so that event delegation works in jQuery.
811// Do the same for pointerenter/pointerleave and pointerover/pointerout
812//
813// Support: Safari 7 only
814// Safari sends mouseenter too often; see:
815// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
816// for the description of the bug (it existed in older Chrome versions as well).
817jQuery.each( {
mouseenter: "mouseover",
mouseleave: "mouseout",
pointerenter: "pointerover",
pointerleave: "pointerout"
822}, function( orig, fix ) {
jQuery.event.special[ orig ] = {
delegateType: fix,
bindType: fix,
826
handle: function( event ) {
	var ret,
		target = this,
		related = event.relatedTarget,
		handleObj = event.handleObj;
832
	// For mouseenter/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;
}
};
843} );
844
845jQuery.fn.extend( {
846
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 ) {
856
	// ( 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" ) {
869
	// ( types-object [, selector] )
	for ( type in types ) {
		this.off( type, selector, types[ type ] );
	}
	return this;
}
if ( selector === false || typeof selector === "function" ) {
877
	// ( types [, fn] )
	fn = selector;
	selector = undefined;
}
if ( fn === false ) {
	fn = returnFalse;
}
return this.each( function() {
	jQuery.event.remove( this, types, fn, selector );
} );
}
889} );
890
891return jQuery;
892} );
1	`define( [`
2	`"./core",`
3	`"./var/document",`
4	`"./var/documentElement",`
5	`"./var/isFunction",`
6	`"./var/rnothtmlwhite",`
7	`"./var/rcheckableType",`
8	`"./var/slice",`
9	`"./data/var/acceptData",`
10	`"./data/var/dataPriv",`
11	`"./core/nodeName",`
12
13	`"./core/init",`
14	`"./selector"`
15	`], function( jQuery, document, documentElement, isFunction, rnothtmlwhite,`
16	`rcheckableType, slice, acceptData, dataPriv, nodeName ) {`
17
18	`"use strict";`
19
20	`var`
21	`rkeyEvent = /^key/,`
22	`rmouseEvent = /^(?:mouse\|pointer\|contextmenu\|drag\|drop)\|click/,`
23	`rtypenamespace = /^([^.]*)(?:\.(.+)\|)/;`
24
25	`function returnTrue() {`
26	`return true;`
27	`}`
28
29	`function returnFalse() {`
30	`return false;`
31	`}`
32
33	`// Support: IE <=9 - 11+`
34	`// focus() and blur() are asynchronous, except when they are no-op.`
35	`// So expect focus to be synchronous when the element is already active,`
36	`// and blur to be synchronous when the element is not already active.`
37	`// (focus and blur are always synchronous in other supported browsers,`
38	`// this just defines when we can count on it).`
39	`function expectSync( elem, type ) {`
40	`return ( elem === safeActiveElement() ) === ( type === "focus" );`