UNPKG

jquery/src/event.js

Version:
24.5 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 rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
21
22function returnTrue() {
return true;
24}
25
26function returnFalse() {
return false;
28}
29
30// Support: IE <=9 - 11+
31// focus() and blur() are asynchronous, except when they are no-op.
32// So expect focus to be synchronous when the element is already active,
33// and blur to be synchronous when the element is not already active.
34// (focus and blur are always synchronous in other supported browsers,
35// this just defines when we can count on it).
36function expectSync( elem, type ) {
return ( elem === safeActiveElement() ) === ( type === "focus" );
38}
39
40// Support: IE <=9 only
41// Accessing document.activeElement can throw unexpectedly
42// https://bugs.jquery.com/ticket/13393
43function safeActiveElement() {
try {
return document.activeElement;
} catch ( err ) { }
47}
48
49function on( elem, types, selector, data, fn, one ) {
var origFn, type;
51
// Types can be a map of types/handlers
if ( typeof types === "object" ) {
54
// ( types-Object, selector, data )
if ( typeof selector !== "string" ) {
57
	// ( types-Object, data )
	data = data || selector;
	selector = undefined;
}
for ( type in types ) {
	on( elem, type, selector, data, types[ type ], one );
}
return elem;
}
67
if ( data == null && fn == null ) {
69
// ( types, fn )
fn = selector;
data = selector = undefined;
} else if ( fn == null ) {
if ( typeof selector === "string" ) {
75
	// ( types, selector, fn )
	fn = data;
	data = undefined;
} else {
80
	// ( types, data, fn )
	fn = data;
	data = selector;
	selector = undefined;
}
}
if ( fn === false ) {
fn = returnFalse;
} else if ( !fn ) {
return elem;
}
92
if ( one === 1 ) {
origFn = fn;
fn = function( event ) {
96
	// Can use an empty set, since event contains the info
	jQuery().off( event );
	return origFn.apply( this, arguments );
};
101
// 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 );
} );
108}
109
110/*
* Helper functions for managing events -- not part of the public interface.
* Props to Dean Edwards' addEvent library for many of the ideas.
*/
114jQuery.event = {
115
global: {},
117
add: function( elem, types, handler, data, selector ) {
119
var handleObjIn, eventHandle, tmp,
	events, t, handleObj,
	special, handlers, type, namespaces, origType,
	elemData = dataPriv.get( elem );
124
// Only attach events to objects that accept data
if ( !acceptData( elem ) ) {
	return;
}
129
// 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;
}
136
// 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 );
}
142
// Make sure that the handler has a unique ID, used to find/remove it later
if ( !handler.guid ) {
	handler.guid = jQuery.guid++;
}
147
// 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 ) {
154
		// 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;
	};
}
161
// 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();
169
	// There *must* be a type, no attaching namespace-only handlers
	if ( !type ) {
		continue;
	}
174
	// If event changes its type, use the special event handlers for the changed type
	special = jQuery.event.special[ type ] || {};
177
	// If selector defined, determine special event api type, otherwise given type
	type = ( selector ? special.delegateType : special.bindType ) || type;
180
	// Update special based on newly reset type
	special = jQuery.event.special[ type ] || {};
183
	// 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 );
195
	// Init the event handler queue if we're the first
	if ( !( handlers = events[ type ] ) ) {
		handlers = events[ type ] = [];
		handlers.delegateCount = 0;
200
		// Only use addEventListener if the special events handler returns false
		if ( !special.setup ||
			special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
204
			if ( elem.addEventListener ) {
				elem.addEventListener( type, eventHandle );
			}
		}
	}
210
	if ( special.add ) {
		special.add.call( elem, handleObj );
213
		if ( !handleObj.handler.guid ) {
			handleObj.handler.guid = handler.guid;
		}
	}
218
	// Add to the element's handler list, delegates in front
	if ( selector ) {
		handlers.splice( handlers.delegateCount++, 0, handleObj );
	} else {
		handlers.push( handleObj );
	}
225
	// Keep track of which events have ever been used, for event optimization
	jQuery.event.global[ type ] = true;
}
229
},
231
// Detach an event or set of events from an element
remove: function( elem, types, handler, selector, mappedTypes ) {
234
var j, origCount, tmp,
	events, t, handleObj,
	special, handlers, type, namespaces, origType,
	elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
239
if ( !elemData || !( events = elemData.events ) ) {
	return;
}
243
// 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();
251
	// 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;
	}
259
	special = jQuery.event.special[ type ] || {};
	type = ( selector ? special.delegateType : special.bindType ) || type;
	handlers = events[ type ] || [];
	tmp = tmp[ 2 ] &&
		new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
265
	// Remove matching events
	origCount = j = handlers.length;
	while ( j-- ) {
		handleObj = handlers[ j ];
270
		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 );
277
			if ( handleObj.selector ) {
				handlers.delegateCount--;
			}
			if ( special.remove ) {
				special.remove.call( elem, handleObj );
			}
		}
	}
286
	// 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 ) {
292
			jQuery.removeEvent( elem, type, elemData.handle );
		}
295
		delete events[ type ];
	}
}
299
// Remove data and the expando if it's no longer used
if ( jQuery.isEmptyObject( events ) ) {
	dataPriv.remove( elem, "handle events" );
}
},
305
dispatch: function( nativeEvent ) {
307
var i, j, ret, matched, handleObj, handlerQueue,
	args = new Array( arguments.length ),
310
	// Make a writable jQuery.Event from the native event object
	event = jQuery.event.fix( nativeEvent ),
313
	handlers = (
		dataPriv.get( this, "events" ) || Object.create( null )
	)[ event.type ] || [],
	special = jQuery.event.special[ event.type ] || {};
318
// Use the fix-ed jQuery.Event rather than the (read-only) native event
args[ 0 ] = event;
321
for ( i = 1; i < arguments.length; i++ ) {
	args[ i ] = arguments[ i ];
}
325
event.delegateTarget = this;
327
// Call the preDispatch hook for the mapped type, and let it bail if desired
if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
	return;
}
332
// Determine handlers
handlerQueue = jQuery.event.handlers.call( this, event, handlers );
335
// Run delegates first; they may want to stop propagation beneath us
i = 0;
while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
	event.currentTarget = matched.elem;
340
	j = 0;
	while ( ( handleObj = matched.handlers[ j++ ] ) &&
		!event.isImmediatePropagationStopped() ) {
344
		// 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 ) ) {
349
			event.handleObj = handleObj;
			event.data = handleObj.data;
352
			ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
				handleObj.handler ).apply( matched.elem, args );
355
			if ( ret !== undefined ) {
				if ( ( event.result = ret ) === false ) {
					event.preventDefault();
					event.stopPropagation();
				}
			}
		}
	}
}
365
// Call the postDispatch hook for the mapped type
if ( special.postDispatch ) {
	special.postDispatch.call( this, event );
}
370
return event.result;
},
373
handlers: function( event, handlers ) {
var i, handleObj, sel, matchedHandlers, matchedSelectors,
	handlerQueue = [],
	delegateCount = handlers.delegateCount,
	cur = event.target;
379
// Find delegate handlers
if ( delegateCount &&
382
	// Support: IE <=9
	// Black-hole SVG <use> instance trees (trac-13180)
	cur.nodeType &&
386
	// 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 ) ) {
393
	for ( ; cur !== this; cur = cur.parentNode || this ) {
395
		// Don't check non-elements (trac-13208)
		// Don't process clicks on disabled elements (trac-6911, trac-8165, trac-11382, trac-11764)
		if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
			matchedHandlers = [];
			matchedSelectors = {};
			for ( i = 0; i < delegateCount; i++ ) {
				handleObj = handlers[ i ];
403
				// Don't conflict with Object.prototype properties (trac-13203)
				sel = handleObj.selector + " ";
406
				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 } );
			}
		}
	}
}
422
// Add the remaining (directly-bound) handlers
cur = this;
if ( delegateCount < handlers.length ) {
	handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
}
428
return handlerQueue;
},
431
addProp: function( name, hook ) {
Object.defineProperty( jQuery.Event.prototype, name, {
	enumerable: true,
	configurable: true,
436
	get: isFunction( hook ) ?
		function() {
			if ( this.originalEvent ) {
				return hook( this.originalEvent );
			}
		} :
		function() {
			if ( this.originalEvent ) {
				return this.originalEvent[ name ];
			}
		},
448
	set: function( value ) {
		Object.defineProperty( this, name, {
			enumerable: true,
			configurable: true,
			writable: true,
			value: value
		} );
	}
} );
},
459
fix: function( originalEvent ) {
return originalEvent[ jQuery.expando ] ?
	originalEvent :
	new jQuery.Event( originalEvent );
},
465
special: {
load: {
468
	// Prevent triggered image.load events from bubbling to window.load
	noBubble: true
},
click: {
473
	// Utilize native event to ensure correct state for checkable inputs
	setup: function( data ) {
476
		// 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;
480
		// Claim the first handler
		if ( rcheckableType.test( el.type ) &&
			el.click && nodeName( el, "input" ) ) {
484
			// dataPriv.set( el, "click", ... )
			leverageNative( el, "click", returnTrue );
		}
488
		// Return false to allow normal processing in the caller
		return false;
	},
	trigger: function( data ) {
493
		// 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;
497
		// Force setup before triggering a click
		if ( rcheckableType.test( el.type ) &&
			el.click && nodeName( el, "input" ) ) {
501
			leverageNative( el, "click" );
		}
504
		// Return non-false to allow normal event-path propagation
		return true;
	},
508
	// 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" );
	}
},
519
beforeunload: {
	postDispatch: function( event ) {
522
		// 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;
		}
	}
}
}
531};
532
533// Ensure the presence of an event listener that handles manually-triggered
534// synthetic events by interrupting progress until reinvoked in response to
535// *native* events that it fires directly, ensuring that state changes have
536// already occurred before other listeners are invoked.
537function leverageNative( el, type, expectSync ) {
538
// 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;
}
546
// 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 );
554
	if ( ( event.isTrigger & 1 ) && this[ type ] ) {
556
		// 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 ) {
561
			// 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 );
567
			// 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 ) {
580
				// Cancel the outer synthetic event
				event.stopImmediatePropagation();
				event.preventDefault();
584
				// Support: Chrome 86+
				// In Chrome, if an element having a focusout handler is blurred by
				// clicking outside of it, it invokes the handler synchronously. If
				// that handler calls `.remove()` on the element, the data is cleared,
				// leaving `result` undefined. We need to guard against this.
				return result && result.value;
			}
592
		// 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();
		}
602
	// 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 ) {
606
		// ...and capture the result
		dataPriv.set( this, type, {
			value: jQuery.event.trigger(
610
				// Support: IE <=9 - 11+
				// Extend with the prototype to reset the above stopImmediatePropagation()
				jQuery.extend( saved[ 0 ], jQuery.Event.prototype ),
				saved.slice( 1 ),
				this
			)
		} );
618
		// Abort handling of the native event
		event.stopImmediatePropagation();
	}
}
} );
624}
625
626jQuery.removeEvent = function( elem, type, handle ) {
627
// This "if" is needed for plain objects
if ( elem.removeEventListener ) {
elem.removeEventListener( type, handle );
}
632};
633
634jQuery.Event = function( src, props ) {
635
// Allow instantiation without the 'new' keyword
if ( !( this instanceof jQuery.Event ) ) {
return new jQuery.Event( src, props );
}
640
// Event object
if ( src && src.type ) {
this.originalEvent = src;
this.type = src.type;
645
// 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 &&
650
		// Support: Android <=2.3 only
		src.returnValue === false ?
	returnTrue :
	returnFalse;
655
// Create target properties
// Support: Safari <=6 - 7 only
// Target should not be a text node (trac-504, trac-13143)
this.target = ( src.target && src.target.nodeType === 3 ) ?
	src.target.parentNode :
	src.target;
662
this.currentTarget = src.currentTarget;
this.relatedTarget = src.relatedTarget;
665
// Event type
} else {
this.type = src;
}
670
// Put explicitly provided properties onto the event object
if ( props ) {
jQuery.extend( this, props );
}
675
// Create a timestamp if incoming event doesn't have one
this.timeStamp = src && src.timeStamp || Date.now();
678
// Mark it as fixed
this[ jQuery.expando ] = true;
681};
682
683// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
684// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
685jQuery.Event.prototype = {
constructor: jQuery.Event,
isDefaultPrevented: returnFalse,
isPropagationStopped: returnFalse,
isImmediatePropagationStopped: returnFalse,
isSimulated: false,
691
preventDefault: function() {
var e = this.originalEvent;
694
this.isDefaultPrevented = returnTrue;
696
if ( e && !this.isSimulated ) {
	e.preventDefault();
}
},
stopPropagation: function() {
var e = this.originalEvent;
703
this.isPropagationStopped = returnTrue;
705
if ( e && !this.isSimulated ) {
	e.stopPropagation();
}
},
stopImmediatePropagation: function() {
var e = this.originalEvent;
712
this.isImmediatePropagationStopped = returnTrue;
714
if ( e && !this.isSimulated ) {
	e.stopImmediatePropagation();
}
718
this.stopPropagation();
}
721};
722
723// Includes all common event props including KeyEvent and MouseEvent specific props
724jQuery.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,
which: true
756}, jQuery.event.addProp );
757
758jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) {
jQuery.event.special[ type ] = {
760
// Utilize native event if possible so blur/focus sequence is correct
setup: function() {
763
	// Claim the first handler
	// dataPriv.set( this, "focus", ... )
	// dataPriv.set( this, "blur", ... )
	leverageNative( this, type, expectSync );
768
	// Return false to allow normal processing in the caller
	return false;
},
trigger: function() {
773
	// Force setup before trigger
	leverageNative( this, type );
776
	// Return non-false to allow normal event-path propagation
	return true;
},
780
// Suppress native focus or blur if we're currently inside
// a leveraged native-event stack
_default: function( event ) {
	return dataPriv.get( event.target, type );
},
786
delegateType: delegateType
};
789} );
790
791// Create mouseenter/leave events using mouseover/out and event-time checks
792// so that event delegation works in jQuery.
793// Do the same for pointerenter/pointerleave and pointerover/pointerout
794//
795// Support: Safari 7 only
796// Safari sends mouseenter too often; see:
797// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
798// for the description of the bug (it existed in older Chrome versions as well).
799jQuery.each( {
mouseenter: "mouseover",
mouseleave: "mouseout",
pointerenter: "pointerover",
pointerleave: "pointerout"
804}, function( orig, fix ) {
jQuery.event.special[ orig ] = {
delegateType: fix,
bindType: fix,
808
handle: function( event ) {
	var ret,
		target = this,
		related = event.relatedTarget,
		handleObj = event.handleObj;
814
	// 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;
}
};
825} );
826
827jQuery.fn.extend( {
828
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 ) {
838
	// ( 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" ) {
851
	// ( types-object [, selector] )
	for ( type in types ) {
		this.off( type, selector, types[ type ] );
	}
	return this;
}
if ( selector === false || typeof selector === "function" ) {
859
	// ( types [, fn] )
	fn = selector;
	selector = undefined;
}
if ( fn === false ) {
	fn = returnFalse;
}
return this.each( function() {
	jQuery.event.remove( this, types, fn, selector );
} );
}
871} );
872
873return jQuery;
874} );
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 rtypenamespace = /^([^.]*)(?:\.(.+)\|)/;`
21
22	`function returnTrue() {`
23	`return true;`
24	`}`
25
26	`function returnFalse() {`
27	`return false;`
28	`}`
29
30	`// Support: IE <=9 - 11+`
31	`// focus() and blur() are asynchronous, except when they are no-op.`
32	`// So expect focus to be synchronous when the element is already active,`
33	`// and blur to be synchronous when the element is not already active.`
34	`// (focus and blur are always synchronous in other supported browsers,`
35	`// this just defines when we can count on it).`
36	`function expectSync( elem, type ) {`
37	`return ( elem === safeActiveElement() ) === ( type === "focus" );`
38	`}`
39
40	`// Support: IE <=9 only`