,下载次数：84 次
| 关键字：
DALFactory
DALFactory.dll[6KB]
DALFactory.pdb[15KB]
Framework.IDAL.dll[6KB]
Framework.IDAL.pdb[7KB]
Framework.Model.dll[12KB]
Framework.Model.pdb[61KB]
DALFactory.dll[4KB]
DALFactory.dll[6KB]
DALFactory.pdb[15KB]
DesignTimeResolveAssemblyReferencesInput.cache[5KB]
ResolveAssemblyReference.cache[8KB]
Properties
DALFactory.csproj.user[451B]
DBUtility.dll[17KB]
DBUtility.pdb[45KB]
DBUtility.dll[6KB]
DBUtility.dll[17KB]
DBUtility.pdb[45KB]
DesignTimeResolveAssemblyReferencesInput.cache[5KB]
Properties
DBUtility.csproj.user[477B]
Xofly_Framework.mdf[3MB]
Xofly_Framework_log.ldf[1MB]
Framework.BLL
DALFactory.dll[6KB]
DALFactory.pdb[15KB]
Framework.BLL.dll[23KB]
Framework.BLL.pdb[61KB]
mon.dll[11KB]
mon.pdb[29KB]
Framework.IDAL.dll[6KB]
Framework.IDAL.pdb[7KB]
Framework.Model.dll[12KB]
Framework.Model.pdb[61KB]
Framework.BLL.dll[6KB]
DesignTimeResolveAssemblyReferencesInput.cache[6KB]
Framework.BLL.dll[23KB]
Framework.BLL.pdb[61KB]
ResolveAssemblyReference.cache[24KB]
Properties
Framework.BLL.csproj.user[451B]
mon.dll[11KB]
mon.pdb[29KB]
Framework.Model.dll[12KB]
Framework.Model.pdb[61KB]
mon.dll[5KB]
DesignTimeResolveAssemblyReferencesInput.cache[5KB]
mon.dll[11KB]
mon.pdb[29KB]
ResolveAssemblyReference.cache[3KB]
Properties
mon.csproj.user[451B]
Framework.IDAL
Framework.IDAL.dll[6KB]
Framework.IDAL.pdb[7KB]
Framework.Model.dll[12KB]
Framework.Model.pdb[61KB]
Framework.IDAL.dll[5KB]
DesignTimeResolveAssemblyReferencesInput.cache[5KB]
Framework.IDAL.dll[6KB]
Framework.IDAL.pdb[7KB]
Properties
Framework.IDAL.csproj.user[451B]
Framework.Model
Framework.Model.dll[12KB]
Framework.Model.pdb[61KB]
Framework.Model.dll[9KB]
DesignTimeResolveAssemblyReferencesInput.cache[5KB]
Framework.Model.dll[12KB]
Framework.Model.pdb[61KB]
Properties
Framework.Model.csproj.user[451B]
Framework.SQLServerDAL
DBUtility.dll[17KB]
DBUtility.pdb[45KB]
Framework.IDAL.dll[6KB]
Framework.IDAL.pdb[7KB]
Framework.Model.dll[12KB]
Framework.Model.pdb[61KB]
Framework.SQLServerDAL.dll[48KB]
Framework.SQLServerDAL.pdb[63KB]
Framework.SQLServerDAL.dll[5KB]
DesignTimeResolveAssemblyReferencesInput.cache[5KB]
Framework.SQLServerDAL.dll[48KB]
Framework.SQLServerDAL.pdb[63KB]
ResolveAssemblyReference.cache[15KB]
Properties
Framework.SQLServerDAL.csproj.user[451B]
MvcWeb.dll[69KB]
MvcWeb.pdb[131KB]
button_a_bg.gif[1KB]
button_plain_hover.png[144B]
button_span_bg.gif[2KB]
messager_error.gif[1KB]
messager_info.gif[1KB]
messager_question.gif[1KB]
messager_warning.gif[1KB]
panel_tools.gif[737B]
Thumbs.db[72KB]
beijingtiao.gif[192B]
buttonOn_login.gif[996B]
hearBG.jpg[3KB]
hotLine.gif[1KB]
left_hover_icon.GIF[389B]
left_icon.GIF[1KB]
login_bottom.gif[1KB]
login_midbg.gif[177B]
login_pic.gif[18KB]
login_top.gif[5KB]
logo22.jpg[23KB]
mail.gif[232B]
main_34.gif[2KB]
menu2.gif[55B]
menu3.gif[70B]
right_hover_icon.gif[389B]
right_icon.GIF[1KB]
Settings.gif[941B]
tab_bg.gif[376B]
Thumbs.db[31KB]
top_01.jpg[1KB]
add.png[1KB]
Calendar.gif[1KB]
delete.png[1KB]
edit.png[625B]
edit2.png[713B]
search.png[813B]
Thumbs.db[44KB]
titletab_01.gif[69B]
titletab_02.gif[89B]
titletab_03.gif[60B]
titletab_05.gif[113B]
top_01.jpg[1KB]
top_02.jpg[1KB]
top_03.jpg[1KB]
Controllers
FrameWorkModel.edmx[24KB]
edmxResourcesToEmbed
FrameWorkModel.csdl[7KB]
FrameWorkModel.msl[6KB]
FrameWorkModel.ssdl[6KB]
Models.FrameWorkModel.Designer.cs.dll[20KB]
DesignTimeResolveAssemblyReferences.cache[37KB]
DesignTimeResolveAssemblyReferencesInput.cache[14KB]
MvcWeb.dll[69KB]
MvcWeb.pdb[131KB]
Properties
Create.cshtml[2KB]
Edit.cshtml[2KB]
Index.cshtml[8KB]
AuthorizationSet.cshtml[3KB]
Create.cshtml[1KB]
Edit.cshtml[1KB]
Index.cshtml[8KB]
UserSet.cshtml[2KB]
Site.Master[2KB]
_Layout.cshtml[2KB]
MvcWeb.csproj.user[1KB]
AuthorizationHandler.ashx[1KB]
DeptEditHandler.ashx[3KB]
ModelEditHandler.ashx[2KB]
RoleEditHandler.ashx[2KB]
UserEditHandler.ashx[3KB]
UserRoleHandler.ashx[1KB]
DALFactory.dll[6KB]
DALFactory.pdb[15KB]
DBUtility.dll[17KB]
DBUtility.pdb[45KB]
Framework.BLL.dll[23KB]
Framework.BLL.pdb[61KB]
mon.dll[11KB]
mon.pdb[29KB]
Framework.IDAL.dll[6KB]
Framework.IDAL.pdb[7KB]
Framework.Model.dll[12KB]
Framework.Model.pdb[61KB]
Framework.SQLServerDAL.dll[48KB]
Framework.SQLServerDAL.pdb[63KB]
button_a_bg.gif[1KB]
button_plain_hover.png[144B]
button_span_bg.gif[2KB]
messager_error.gif[1KB]
messager_info.gif[1KB]
messager_question.gif[1KB]
messager_warning.gif[1KB]
panel_tools.gif[737B]
Thumbs.db[72KB]
beijingtiao.gif[192B]
buttonOn_login.gif[996B]
hearBG.jpg[3KB]
hotLine.gif[1KB]
left_hover_icon.GIF[389B]
left_icon.GIF[1KB]
login_bottom.gif[1KB]
login_midbg.gif[177B]
login_pic.gif[18KB]
login_top.gif[5KB]
logo22.jpg[23KB]
mail.gif[232B]
main_34.gif[2KB]
menu2.gif[55B]
menu3.gif[70B]
right_hover_icon.gif[389B]
right_icon.GIF[1KB]
Settings.gif[941B]
tab_bg.gif[376B]
Thumbs.db[30KB]
top_01.jpg[1KB]
add.png[1KB]
Calendar.gif[1KB]
delete.png[1KB]
edit.png[625B]
edit2.png[713B]
search.png[813B]
Thumbs.db[43KB]
titletab_01.gif[69B]
titletab_02.gif[89B]
titletab_03.gif[60B]
titletab_05.gif[113B]
top_01.jpg[1KB]
top_02.jpg[1KB]
top_03.jpg[1KB]
MasterPage
LoginHandler.ashx[1KB]
from.gif[4KB]
最新Asp.Net源码下载.url[125B]
权限管理系统.sln[5KB]
权限管理系统.suo[183KB]
当前路径：Web/js/jquery-1.6.2.js
* jQuery JavaScript Library v1.6.2
* Copyright 2011, John Resig
* Dual licensed under the MIT or GPL Version 2 licenses.
* http://jquery.org/license
* Includes Sizzle.js
* Copyright 2011, The Dojo Foundation
* Released under the MIT, BSD, and GPL Licenses.
* Date: Thu Jun 30 14:16:56
(function( window, undefined ) {
// Use the correct document accordingly with window argument (sandbox)
var document = window.document,
navigator = window.navigator,
location = window.
var jQuery = (function() {
// Define a local copy of jQuery
var jQuery = function( selector, context ) {
// The jQuery object is actually just the init constructor 'enhanced'
return new jQuery.fn.init( selector, context, rootjQuery );
// Map over jQuery in case of overwrite
_jQuery = window.jQuery,
// Map over the $ in case of overwrite
_$ = window.$,
// A central reference to the root jQuery(document)
rootjQuery,
// A simple way to check for HTML strings or ID strings
// (both of which we optimize for)
quickExpr = /^(?:[^&]*(&[\w\W]+&)[^&]*$|#([\w\-]*)$)/,
// Check if a string has a non-whitespace character in it
rnotwhite = /\S/,
// Used for trimming whitespace
trimLeft = /^\s+/,
trimRight = /\s+$/,
// Check for digits
rdigit = /\d/,
// Match a standalone tag
rsingleTag = /^&(\w+)\s*\/?&(?:&\/\1&)?$/,
// JSON RegExp
rvalidchars = /^[\],:{}\s]*$/,
rvalidescape = /\\(?:[&\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
rvalidtokens = /&[^&\\\n\r]*&|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
// Useragent RegExp
rwebkit = /(webkit)[ \/]([\w.]+)/,
ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
rmsie = /(msie) ([\w.]+)/,
rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
// Matches dashed string for camelizing
rdashAlpha = /-([a-z])/ig,
// Used by jQuery.camelCase as callback to replace()
fcamelCase = function( all, letter ) {
return letter.toUpperCase();
// Keep a UserAgent string for use with jQuery.browser
userAgent = navigator.userAgent,
// For matching the engine and version of the browser
browserMatch,
// The deferred used on DOM ready
readyList,
// The ready event handler
DOMContentLoaded,
// Save a reference to some core methods
toString = Object.prototype.toString,
hasOwn = Object.prototype.hasOwnProperty,
push = Array.prototype.push,
slice = Array.prototype.slice,
trim = String.prototype.trim,
indexOf = Array.prototype.indexOf,
// [[Class]] -& type pairs
class2type = {};
jQuery.fn = jQuery.prototype = {
constructor: jQuery,
init: function( selector, context, rootjQuery ) {
var match, elem, ret,
// Handle $(&&), $(null), or $(undefined)
if ( !selector ) {
// Handle $(DOMElement)
if ( selector.nodeType ) {
this.context = this[0] =
this.length = 1;
// The body element only exists once, optimize finding it
if ( selector === &body& && !context && document.body ) {
this.context =
this[0] = document.
this.selector =
this.length = 1;
// Handle HTML strings
if ( typeof selector === &string& ) {
// Are we dealing with HTML string or an ID?
if ( selector.charAt(0) === &&& && selector.charAt( selector.length - 1 ) === &&& && selector.length &= 3 ) {
// Assume that strings that start and end with && are HTML and skip the regex check
match = [ null, selector, null ];
match = quickExpr.exec( selector );
// Verify a match, and that no context was specified for #id
if ( match && (match[1] || !context) ) {
// HANDLE: $(html) -& $(array)
if ( match[1] ) {
context = context instanceof jQuery ? context[0] :
doc = (context ? context.ownerDocument || context : document);
// If a single string is passed in and it's a single tag
// just do a createElement and skip the rest
ret = rsingleTag.exec( selector );
if ( ret ) {
if ( jQuery.isPlainObject( context ) ) {
selector = [ document.createElement( ret[1] ) ];
jQuery.fn.attr.call( selector, context, true );
selector = [ doc.createElement( ret[1] ) ];
ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childN
return jQuery.merge( this, selector );
// HANDLE: $(&#id&)
elem = document.getElementById( match[2] );
// Check parentNode to catch when Blackberry 4.6 returns
// nodes that are no longer in the document #6963
if ( elem && elem.parentNode ) {
// Handle the case where IE and Opera return items
// by name instead of ID
if ( elem.id !== match[2] ) {
return rootjQuery.find( selector );
// Otherwise, we inject the element directly into the jQuery object
this.length = 1;
this.context =
this.selector =
// HANDLE: $(expr, $(...))
} else if ( !context || context.jquery ) {
return (context || rootjQuery).find( selector );
// HANDLE: $(expr, context)
// (which is just equivalent to: $(context).find(expr)
return this.constructor( context ).find( selector );
// HANDLE: $(function)
// Shortcut for document ready
} else if ( jQuery.isFunction( selector ) ) {
return rootjQuery.ready( selector );
if (selector.selector !== undefined) {
this.selector = selector.
this.context = selector.
return jQuery.makeArray( selector, this );
// Start with an empty selector
selector: &&,
// The current version of jQuery being used
jquery: &1.6.2&,
// The default length of a jQuery object is 0
length: 0,
// The number of elements contained in the matched element set
size: function() {
return this.
toArray: function() {
return slice.call( this, 0 );
// Get the Nth element in the matched element set OR
// Get the whole matched element set as a clean array
get: function( num ) {
return num == null ?
// Return a 'clean' array
this.toArray() :
// Return just the object
( num & 0 ? this[ this.length + num ] : this[ num ] );
// Take an array of elements and push it onto the stack
// (returning the new matched element set)
pushStack: function( elems, name, selector ) {
// Build a new jQuery matched element set
var ret = this.constructor();
if ( jQuery.isArray( elems ) ) {
push.apply( ret, elems );
jQuery.merge( ret, elems );
// Add the old object onto the stack (as a reference)
ret.prevObject =
ret.context = this.
if ( name === &find& ) {
ret.selector = this.selector + (this.selector ? & & : &&) +
} else if ( name ) {
ret.selector = this.selector + &.& + name + &(& + selector + &)&;
// Return the newly-formed element set
// Execute a callback for every element in the matched set.
// (You can seed the arguments with an array of args, but this is
// only used internally.)
each: function( callback, args ) {
return jQuery.each( this, callback, args );
ready: function( fn ) {
// Attach the listeners
jQuery.bindReady();
// Add the callback
readyList.done( fn );
eq: function( i ) {
return i === -1 ?
this.slice( i ) :
this.slice( i, +i + 1 );
first: function() {
return this.eq( 0 );
last: function() {
return this.eq( -1 );
slice: function() {
return this.pushStack( slice.apply( this, arguments ),
&slice&, slice.call(arguments).join(&,&) );
map: function( callback ) {
return this.pushStack( jQuery.map(this, function( elem, i ) {
return callback.call( elem, i, elem );
end: function() {
return this.prevObject || this.constructor(null);
// For internal use only.
// Behaves like an Array's method, not like a jQuery method.
push: push,
sort: [].sort,
splice: [].splice
// Give the init function the jQuery prototype for later instantiation
jQuery.fn.init.prototype = jQuery.
jQuery.extend = jQuery.fn.extend = function() {
var options, name, src, copy, copyIsArray, clone,
target = arguments[0] || {},
length = arguments.length,
// Handle a deep copy situation
if ( typeof target === &boolean& ) {
target = arguments[1] || {};
// skip the boolean and the target
// Handle case when target is a string or something (possible in deep copy)
if ( typeof target !== &object& && !jQuery.isFunction(target) ) {
target = {};
// extend jQuery itself if only one argument is passed
if ( length === i ) {
for ( ; i & i++ ) {
// Only deal with non-null/undefined values
if ( (options = arguments[ i ]) != null ) {
// Extend the base object
for ( name in options ) {
src = target[ name ];
copy = options[ name ];
// Prevent never-ending loop
if ( target === copy ) {
// Recurse if we're merging plain objects or arrays
if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
if ( copyIsArray ) {
copyIsArray =
clone = src && jQuery.isArray(src) ? src : [];
clone = src && jQuery.isPlainObject(src) ? src : {};
// Never move original objects, clone them
target[ name ] = jQuery.extend( deep, clone, copy );
// Don't bring in undefined values
} else if ( copy !== undefined ) {
target[ name ] =
// Return the modified object
jQuery.extend({
noConflict: function( deep ) {
if ( window.$ === jQuery ) {
window.$ = _$;
if ( deep && window.jQuery === jQuery ) {
window.jQuery = _jQ
// Is the DOM ready to be used? Set to true once it occurs.
isReady: false,
// A counter to track how many items to wait for before
// the ready event fires. See #6781
readyWait: 1,
// Hold (or release) the ready event
holdReady: function( hold ) {
if ( hold ) {
jQuery.readyWait++;
jQuery.ready( true );
// Handle when the DOM is ready
ready: function( wait ) {
// Either a released hold or an DOMready/load event and not yet ready
if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
if ( !document.body ) {
return setTimeout( jQuery.ready, 1 );
// Remember that the DOM is ready
jQuery.isReady =
// If a normal DOM Ready event fired, decrement, and wait if need be
if ( wait !== true && --jQuery.readyWait & 0 ) {
// If there are functions bound, to execute
readyList.resolveWith( document, [ jQuery ] );
// Trigger any bound ready events
if ( jQuery.fn.trigger ) {
jQuery( document ).trigger( &ready& ).unbind( &ready& );
bindReady: function() {
if ( readyList ) {
readyList = jQuery._Deferred();
// Catch cases where $(document).ready() is called after the
// browser event has already occurred.
if ( document.readyState === &complete& ) {
// Handle it asynchronously to allow scripts the opportunity to delay ready
return setTimeout( jQuery.ready, 1 );
// Mozilla, Opera and webkit nightlies currently support this event
if ( document.addEventListener ) {
// Use the handy event callback
document.addEventListener( &DOMContentLoaded&, DOMContentLoaded, false );
// A fallback to window.onload, that will always work
window.addEventListener( &load&, jQuery.ready, false );
// If IE event model is used
} else if ( document.attachEvent ) {
// ensure firing before onload,
// maybe late but safe also for iframes
document.attachEvent( &onreadystatechange&, DOMContentLoaded );
// A fallback to window.onload, that will always work
window.attachEvent( &onload&, jQuery.ready );
// If IE and not a frame
// continually check to see if the document is ready
var toplevel =
toplevel = window.frameElement ==
} catch(e) {}
if ( document.documentElement.doScroll && toplevel ) {
doScrollCheck();
// See test/unit/core.js for details concerning isFunction.
// Since version 1.3, DOM methods and functions like alert
// aren't supported. They return false on IE (#2968).
isFunction: function( obj ) {
return jQuery.type(obj) === &function&;
isArray: Array.isArray || function( obj ) {
return jQuery.type(obj) === &array&;
// A crude way of determining if an object is a window
isWindow: function( obj ) {
return obj && typeof obj === &object& && &setInterval&
isNaN: function( obj ) {
return obj == null || !rdigit.test( obj ) || isNaN( obj );
type: function( obj ) {
return obj == null ?
String( obj ) :
class2type[ toString.call(obj) ] || &object&;
isPlainObject: function( obj ) {
// Must be an Object.
// Because of IE, we also have to check the presence of the constructor property.
// Make sure that DOM nodes and window objects don't pass through, as well
if ( !obj || jQuery.type(obj) !== &object& || obj.nodeType || jQuery.isWindow( obj ) ) {
// Not own constructor property must be Object
if ( obj.constructor &&
!hasOwn.call(obj, &constructor&) &&
!hasOwn.call(obj.constructor.prototype, &isPrototypeOf&) ) {
// Own properties are enumerated firstly, so to speed up,
// if last one is own, then all properties are own.
for ( key in obj ) {}
return key === undefined || hasOwn.call( obj, key );
isEmptyObject: function( obj ) {
for ( var name in obj ) {
error: function( msg ) {
parseJSON: function( data ) {
if ( typeof data !== &string& || !data ) {
// Make sure leading/trailing whitespace is removed (IE can't handle it)
data = jQuery.trim( data );
// Attempt to parse using the native JSON parser first
if ( window.JSON && window.JSON.parse ) {
return window.JSON.parse( data );
// Make sure the incoming data is actual JSON
// Logic borrowed from http://json.org/json2.js
if ( rvalidchars.test( data.replace( rvalidescape, &@& )
.replace( rvalidtokens, &]& )
.replace( rvalidbraces, &&)) ) {
return (new Function( &return & + data ))();
jQuery.error( &Invalid JSON: & + data );
// Cross-browser xml parsing
// (xml & tmp used internally)
parseXML: function( data , xml , tmp ) {
if ( window.DOMParser ) { // Standard
tmp = new DOMParser();
xml = tmp.parseFromString( data , &text/xml& );
} else { // IE
xml = new ActiveXObject( &Microsoft.XMLDOM& );
xml.async = &false&;
xml.loadXML( data );
tmp = xml.documentE
if ( ! tmp || ! tmp.nodeName || tmp.nodeName === &parsererror& ) {
jQuery.error( &Invalid XML: & + data );
noop: function() {},
// Evaluates a script in a global context
// Workarounds based on findings by Jim Driscoll
// http://weblogs.java.net/blog/driscoll/archive//eval-javascript-global-context
globalEval: function( data ) {
if ( data && rnotwhite.test( data ) ) {
// We use execScript on Internet Explorer
// We use an anonymous function so that context is window
// rather than jQuery in Firefox
( window.execScript || function( data ) {
window[ &eval& ].call( window, data );
} )( data );
// Converts a dashed string to camelC
// Used by both the css and data modules
camelCase: function( string ) {
return string.replace( rdashAlpha, fcamelCase );
nodeName: function( elem, name ) {
return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
// args is for internal usage only
each: function( object, callback, args ) {
var name, i = 0,
length = object.length,
isObj = length === undefined || jQuery.isFunction( object );
if ( args ) {
if ( isObj ) {
for ( name in object ) {
if ( callback.apply( object[ name ], args ) === false ) {
for ( ; i & ) {
if ( callback.apply( object[ i++ ], args ) === false ) {
// A special, fast, case for the most common use of each
if ( isObj ) {
for ( name in object ) {
if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
for ( ; i & ) {
if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
// Use native String.trim function wherever possible
trim: trim ?
function( text ) {
return text == null ?
trim.call( text );
// Otherwise use our own trimming functionality
function( text ) {
return text == null ?
text.toString().replace( trimLeft, && ).replace( trimRight, && );
// results is for internal usage only
makeArray: function( array, results ) {
var ret = results || [];
if ( array != null ) {
// The window, strings (and functions) also have 'length'
// The extra typeof function check is to prevent crashes
// in Safari 2 (See: #3039)
// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
var type = jQuery.type( array );
if ( array.length == null || type === &string& || type === &function& || type === &regexp& || jQuery.isWindow( array ) ) {
push.call( ret, array );
jQuery.merge( ret, array );
inArray: function( elem, array ) {
if ( indexOf ) {
return indexOf.call( array, elem );
for ( var i = 0, length = array. i & i++ ) {
if ( array[ i ] === elem ) {
return -1;
merge: function( first, second ) {
var i = first.length,
if ( typeof second.length === &number& ) {
for ( var l = second. j & j++ ) {
first[ i++ ] = second[ j ];
while ( second[j] !== undefined ) {
first[ i++ ] = second[ j++ ];
first.length =
grep: function( elems, callback, inv ) {
var ret = [], retV
// Go through the array, only saving the items
// that pass the validator function
for ( var i = 0, length = elems. i & i++ ) {
retVal = !!callback( elems[ i ], i );
if ( inv !== retVal ) {
ret.push( elems[ i ] );
// arg is for internal usage only
map: function( elems, callback, arg ) {
var value, key, ret = [],
length = elems.length,
// jquery objects are treated as arrays
isArray = elems instanceof jQuery || length !== undefined && typeof length === &number& && ( ( length & 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
// Go through the array, translating each of the items to their
if ( isArray ) {
for ( ; i & i++ ) {
value = callback( elems[ i ], i, arg );
if ( value != null ) {
ret[ ret.length ] =
// Go through every key on the object,
for ( key in elems ) {
value = callback( elems[ key ], key, arg );
if ( value != null ) {
ret[ ret.length ] =
// Flatten any nested arrays
return ret.concat.apply( [], ret );
// A global GUID counter for objects
// Bind a function to a context, optionally partially applying any
// arguments.
proxy: function( fn, context ) {
if ( typeof context === &string& ) {
var tmp = fn[ context ];
// Quick check to determine if target is callable, in the spec
// this throws a TypeError, but we will just return undefined.
if ( !jQuery.isFunction( fn ) ) {
// Simulated bind
var args = slice.call( arguments, 2 ),
proxy = function() {
return fn.apply( context, args.concat( slice.call( arguments ) ) );
// Set the guid of unique handler to the same of original handler, so it can be removed
proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
// Mutifunctional method to get and set values to a collection
// The value/s can optionally be executed if it's a function
access: function( elems, key, value, exec, fn, pass ) {
var length = elems.
// Setting many attributes
if ( typeof key === &object& ) {
for ( var k in key ) {
jQuery.access( elems, k, key[k], exec, fn, value );
// Setting one attribute
if ( value !== undefined ) {
// Optionally, function values get executed if exec is true
exec = !pass && exec && jQuery.isFunction(value);
for ( var i = 0; i & i++ ) {
fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
// Getting an attribute
return length ? fn( elems[0], key ) :
now: function() {
return (new Date()).getTime();
// Use of jQuery.browser is frowned upon.
// More details: /Utilities/jQuery.browser
uaMatch: function( ua ) {
ua = ua.toLowerCase();
var match = rwebkit.exec( ua ) ||
ropera.exec( ua ) ||
rmsie.exec( ua ) ||
ua.indexOf(&compatible&) & 0 && rmozilla.exec( ua ) ||
return { browser: match[1] || &&, version: match[2] || &0& };
sub: function() {
function jQuerySub( selector, context ) {
return new jQuerySub.fn.init( selector, context );
jQuery.extend( true, jQuerySub, this );
jQuerySub.superclass =
jQuerySub.fn = jQuerySub.prototype = this();
jQuerySub.fn.constructor = jQueryS
jQuerySub.sub = this.
jQuerySub.fn.init = function init( selector, context ) {
if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
context = jQuerySub( context );
return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
jQuerySub.fn.init.prototype = jQuerySub.
var rootjQuerySub = jQuerySub(document);
return jQueryS
browser: {}
// Populate the class2type map
jQuery.each(&Boolean Number String Function Array Date RegExp Object&.split(& &), function(i, name) {
class2type[ &[object & + name + &]& ] = name.toLowerCase();
browserMatch = jQuery.uaMatch( userAgent );
if ( browserMatch.browser ) {
jQuery.browser[ browserMatch.browser ] =
jQuery.browser.version = browserMatch.
// Deprecated, use jQuery.browser.webkit instead
if ( jQuery.browser.webkit ) {
jQuery.browser.safari =
// IE doesn't match non-breaking spaces with \s
if ( rnotwhite.test( &\xA0& ) ) {
trimLeft = /^[\s\xA0]+/;
trimRight = /[\s\xA0]+$/;
// All jQuery objects should point back to these
rootjQuery = jQuery(document);
// Cleanup functions for the document ready method
if ( document.addEventListener ) {
DOMContentLoaded = function() {
document.removeEventListener( &DOMContentLoaded&, DOMContentLoaded, false );
jQuery.ready();
} else if ( document.attachEvent ) {
DOMContentLoaded = function() {
// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
if ( document.readyState === &complete& ) {
document.detachEvent( &onreadystatechange&, DOMContentLoaded );
jQuery.ready();
// The DOM ready check for Internet Explorer
function doScrollCheck() {
if ( jQuery.isReady ) {
// If IE is used, use the trick by Diego Perini
// /IEContentLoaded/
document.documentElement.doScroll(&left&);
} catch(e) {
setTimeout( doScrollCheck, 1 );
// and execute any waiting functions
jQuery.ready();
var // Promise methods
promiseMethods = &done fail isResolved isRejected promise then always pipe&.split( & & ),
// Static reference to slice
sliceDeferred = [].
jQuery.extend({
// Create a simple deferred (one callbacks list)
_Deferred: function() {
var // callbacks list
callbacks = [],
// stored [ context , args ]
// to avoid firing when already doing so
// flag to know if the deferred has been cancelled
cancelled,
// the deferred itself
// done( f1, f2, ...)
done: function() {
if ( !cancelled ) {
var args = arguments,
if ( fired ) {
fired = 0;
for ( i = 0, length = args. i & i++ ) {
elem = args[ i ];
type = jQuery.type( elem );
if ( type === &array& ) {
deferred.done.apply( deferred, elem );
} else if ( type === &function& ) {
callbacks.push( elem );
if ( _fired ) {
deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
// resolve with given context and args
resolveWith: function( context, args ) {
if ( !cancelled && !fired && !firing ) {
// make sure args are available (#8421)
args = args || [];
firing = 1;
while( callbacks[ 0 ] ) {
callbacks.shift().apply( context, args );
fired = [ context, args ];
firing = 0;
// resolve with this as context and given arguments
resolve: function() {
deferred.resolveWith( this, arguments );
// Has this deferred been resolved?
isResolved: function() {
return !!( firing || fired );
cancel: function() {
cancelled = 1;
callbacks = [];
// Full fledged deferred (two callbacks list)
Deferred: function( func ) {
var deferred = jQuery._Deferred(),
failDeferred = jQuery._Deferred(),
// Add errorDeferred methods, then and promise
jQuery.extend( deferred, {
then: function( doneCallbacks, failCallbacks ) {
deferred.done( doneCallbacks ).fail( failCallbacks );
always: function() {
return deferred.done.apply( deferred, arguments ).fail.apply( this, arguments );
fail: failDeferred.done,
rejectWith: failDeferred.resolveWith,
reject: failDeferred.resolve,
isRejected: failDeferred.isResolved,
pipe: function( fnDone, fnFail ) {
return jQuery.Deferred(function( newDefer ) {
jQuery.each( {
done: [ fnDone, &resolve& ],
fail: [ fnFail, &reject& ]
}, function( handler, data ) {
var fn = data[ 0 ],
action = data[ 1 ],
if ( jQuery.isFunction( fn ) ) {
deferred[ handler ](function() {
returned = fn.apply( this, arguments );
if ( returned && jQuery.isFunction( returned.promise ) ) {
returned.promise().then( newDefer.resolve, newDefer.reject );
newDefer[ action ]( returned );
deferred[ handler ]( newDefer[ action ] );
}).promise();
// Get a promise for this deferred
// If obj is provided, the promise aspect is added to the object
promise: function( obj ) {
if ( obj == null ) {
if ( promise ) {
promise = obj = {};
var i = promiseMethods.
while( i-- ) {
obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
// Make sure only one callback list will be used
deferred.done( failDeferred.cancel ).fail( deferred.cancel );
// Unexpose cancel
delete deferred.
// Call given func if any
if ( func ) {
func.call( deferred, deferred );
// Deferred helper
when: function( firstParam ) {
var args = arguments,
length = args.length,
count = length,
deferred = length &= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
firstParam :
jQuery.Deferred();
function resolveFunc( i ) {
return function( value ) {
args[ i ] = arguments.length & 1 ? sliceDeferred.call( arguments, 0 ) :
if ( !( --count ) ) {
// Strange bug in FF4:
// Values changed onto the arguments object sometimes end up as undefined values
// outside the $.when method. Cloning the object into a fresh array solves the issue
deferred.resolveWith( deferred, sliceDeferred.call( args, 0 ) );
if ( length & 1 ) {
for( ; i & i++ ) {
if ( args[ i ] && jQuery.isFunction( args[ i ].promise ) ) {
args[ i ].promise().then( resolveFunc(i), deferred.reject );
if ( !count ) {
deferred.resolveWith( deferred, args );
} else if ( deferred !== firstParam ) {
deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
return deferred.promise();
jQuery.support = (function() {
var div = document.createElement( &div& ),
documentElement = document.documentElement,
marginDiv,
testElementParent,
testElement,
testElementStyle,
eventName,
// Preliminary tests
div.setAttribute(&className&, &t&);
div.innerHTML = &
&link/&&table&&/table&&a href='/a' style='top:1float:opacity:.55;'&a&/a&&input type='checkbox'/&&;
all = div.getElementsByTagName( &*& );
a = div.getElementsByTagName( &a& )[ 0 ];
// Can't get basic test support
if ( !all || !all.length || !a ) {
return {};
// First batch of supports tests
select = document.createElement( &select& );
opt = select.appendChild( document.createElement(&option&) );
input = div.getElementsByTagName( &input& )[ 0 ];
support = {
// IE strips leading whitespace when .innerHTML is used
leadingWhitespace: ( div.firstChild.nodeType === 3 ),
// Make sure that tbody elements aren't automatically inserted
// IE will insert them into empty tables
tbody: !div.getElementsByTagName( &tbody& ).length,
// Make sure that link elements get serialized correctly by innerHTML
// This requires a wrapper element in IE
htmlSerialize: !!div.getElementsByTagName( &link& ).length,
// Get the style information from getAttribute
// (IE uses .cssText instead)
style: /top/.test( a.getAttribute(&style&) ),
// Make sure that URLs aren't manipulated
// (IE normalizes it by default)
hrefNormalized: ( a.getAttribute( &href& ) === &/a& ),
// Make sure that element opacity exists
// (IE uses filter instead)
// Use a regex to work around a WebKit issue. See #5145
opacity: /^0.55$/.test( a.style.opacity ),
// Verify style float existence
// (IE uses styleFloat instead of cssFloat)
cssFloat: !!a.style.cssFloat,
// Make sure that if no value is specified for a checkbox
// that it defaults to &on&.
// (WebKit defaults to && instead)
checkOn: ( input.value === &on& ),
// Make sure that a selected-by-default option has a working selected property.
// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
optSelected: opt.selected,
// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
getSetAttribute: div.className !== &t&,
// Will be defined later
submitBubbles: true,
changeBubbles: true,
focusinBubbles: false,
deleteExpando: true,
noCloneEvent: true,
inlineBlockNeedsLayout: false,
shrinkWrapBlocks: false,
reliableMarginRight: true
// Make sure checked status is properly cloned
input.checked =
support.noCloneChecked = input.cloneNode( true ).
// Make sure that the options inside disabled selects aren't marked as disabled
// (WebKit marks them as disabled)
select.disabled =
support.optDisabled = !opt.
// Test to see if it's possible to delete an expando from an element
// Fails in Internet Explorer
delete div.
} catch( e ) {
support.deleteExpando =
if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
div.attachEvent( &onclick&, function() {
// Cloning a node shouldn't copy over any
// bound event handlers (IE does this)
support.noCloneEvent =
div.cloneNode( true ).fireEvent( &onclick& );
// Check if a radio maintains it's value
// after being appended to the DOM
input = document.createElement(&input&);
input.value = &t&;
input.setAttribute(&type&, &radio&);
support.radioValue = input.value === &t&;
input.setAttribute(&checked&, &checked&);
div.appendChild( input );
fragment = document.createDocumentFragment();
fragment.appendChild( div.firstChild );
// WebKit doesn't clone checked state correctly in fragments
support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.
div.innerHTML = &&;
// Figure out if the W3C box model works as expected
div.style.width = div.style.paddingLeft = &1px&;
body = document.getElementsByTagName( &body& )[ 0 ];
// We use our own, invisible, body unless the body is already present
// in which case we use a div (#9239)
testElement = document.createElement( body ? &div& : &body& );
testElementStyle = {
visibility: &hidden&,
height: 0,
border: 0,
if ( body ) {
jQuery.extend( testElementStyle, {
position: &absolute&,
left: -1000,
top: -1000
for ( i in testElementStyle ) {
testElement.style[ i ] = testElementStyle[ i ];
testElement.appendChild( div );
testElementParent = body || documentE
testElementParent.insertBefore( testElement, testElementParent.firstChild );
// Check if a disconnected checkbox will retain its checked
// value of true after appended to the DOM (IE6/7)
support.appendChecked = input.
support.boxModel = div.offsetWidth === 2;
if ( &zoom& in div.style ) {
// Check if natively block-level elements act like inline-block
// elements when setting their display to 'inline' and giving
// them layout
// (IE & 8 does this)
div.style.display = &inline&;
div.style.zoom = 1;
support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
// Check if elements with layout shrink-wrap their children
// (IE 6 does this)
div.style.display = &&;
div.innerHTML = &&div style='width:4'&&/div&&;
support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
div.innerHTML = &&table&&tr&&td style='padding:0;border:0;display:none'&&/td&&td&t&/td&&/tr&&/table&&;
tds = div.getElementsByTagName( &td& );
// Check if table cells still have offsetWidth/Height when they are set
// to display:none and there are still other visible table cells in a
// if so, offsetWidth/Height are not reliable for use when
// determining if an element has been hidden directly using
// display:none (it is still safe to use offsets if a parent element is
// don safety goggles and see bug #4512 for more information).
// (only IE 8 fails this test)
isSupported = ( tds[ 0 ].offsetHeight === 0 );
tds[ 0 ].style.display = &&;
tds[ 1 ].style.display = &none&;
// Check if empty table cells still have offsetWidth/Height
// (IE & 8 fail this test)
support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
div.innerHTML = &&;
// Check if div with explicit width and no margin-right incorrectly
// gets computed margin-right based on width of container. For more
// info see bug #3333
// Fails in WebKit before Feb 2011 nightlies
// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
if ( document.defaultView && document.defaultView.getComputedStyle ) {
marginDiv = document.createElement( &div& );
marginDiv.style.width = &0&;
marginDiv.style.marginRight = &0&;
div.appendChild( marginDiv );
support.reliableMarginRight =
( parseInt( ( document.defaultView.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
// Remove the body element we added
testElement.innerHTML = &&;
testElementParent.removeChild( testElement );
// Technique from Juriy Zaytsev
// /projects/prototype/detecting-event-support-without-browser-sniffing/
// We only care about the case where non-standard event systems
// are used, namely in IE. Short-circuiting here helps us to
// avoid an eval call (in setAttribute) which can cause CSP
// to go haywire. See: https://developer.mozilla.org/en/Security/CSP
if ( div.attachEvent ) {
for( i in {
submit: 1,
change: 1,
focusin: 1
eventName = &on& +
isSupported = ( eventName in div );
if ( !isSupported ) {
div.setAttribute( eventName, && );
isSupported = ( typeof div[ eventName ] === &function& );
support[ i + &Bubbles& ] = isS
// Null connected elements to avoid leaks in IE
testElement = fragment = select = opt = body = marginDiv = div = input =
// Keep track of boxModel
jQuery.boxModel = jQuery.support.boxM
var rbrace = /^(?:\{.*\}|\[.*\])$/,
rmultiDash = /([a-z])([A-Z])/g;
jQuery.extend({
cache: {},
// Please use with caution
// Unique for each copy of jQuery on the page
// Non-digits removed to match rinlinejQuery
expando: &jQuery& + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, && ),
// The following elements throw uncatchable exceptions if you
// attempt to add expando properties to them.
&embed&: true,
// Ban all objects except for Flash (which handle expandos)
&object&: &clsid:D27CDB6E-AE6D-11cf-96B8-&,
&applet&: true
hasData: function( elem ) {
elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
return !!elem && !isEmptyDataObject( elem );
data: function( elem, name, data, pvt /* Internal Use Only */ ) {
if ( !jQuery.acceptData( elem ) ) {
var internalKey = jQuery.expando, getByName = typeof name === &string&, thisCache,
// We have to handle DOM nodes and JS objects differently because IE6-7
// can't GC object references properly across the DOM-JS boundary
isNode = elem.nodeType,
// Only DOM nodes need the global jQ JS object data is
// attached directly to the object so GC can occur automatically
cache = isNode ? jQuery.cache : elem,
// Only defining an ID for JS objects if its cache already exists allows
// the code to shortcut on the same path as a DOM node with no cache
id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.
// Avoid doing any more work than we need to when trying to get data on an
// object that has no data at all
if ( (!id || (pvt && id && !cache[ id ][ internalKey ])) && getByName && data === undefined ) {
if ( !id ) {
// Only DOM nodes need a new unique ID for each element since their data
// ends up in the global cache
if ( isNode ) {
elem[ jQuery.expando ] = id = ++jQuery.
id = jQuery.
if ( !cache[ id ] ) {
cache[ id ] = {};
// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
// metadata on plain JS objects when the object is serialized using
// JSON.stringify
if ( !isNode ) {
cache[ id ].toJSON = jQuery.
// An object can be passed to jQuery.data instead of a key/ this gets
// shallow copied over onto the existing cache
if ( typeof name === &object& || typeof name === &function& ) {
if ( pvt ) {
cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
cache[ id ] = jQuery.extend(cache[ id ], name);
thisCache = cache[ id ];
// Internal jQuery data is stored in a separate object inside the object's data
// cache in order to avoid key collisions between internal data and user-defined
if ( pvt ) {
if ( !thisCache[ internalKey ] ) {
thisCache[ internalKey ] = {};
thisCache = thisCache[ internalKey ];
if ( data !== undefined ) {
thisCache[ jQuery.camelCase( name ) ] =
// TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
// not attempt to inspect the internal events object using jQuery.data, as this
// internal data object is undocumented and subject to change.
if ( name === &events& && !thisCache[name] ) {
return thisCache[ internalKey ] && thisCache[ internalKey ].
return getByName ?
// Check for both converted-to-camel and non-converted data property names
thisCache[ jQuery.camelCase( name ) ] || thisCache[ name ] :
removeData: function( elem, name, pvt /* Internal Use Only */ ) {
if ( !jQuery.acceptData( elem ) ) {
var internalKey = jQuery.expando, isNode = elem.nodeType,
// See jQuery.data for more information
cache = isNode ? jQuery.cache : elem,
// See jQuery.data for more information
id = isNode ? elem[ jQuery.expando ] : jQuery.
// If there is already no cache entry for this object, there is no
// purpose in continuing
if ( !cache[ id ] ) {
if ( name ) {
var thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
if ( thisCache ) {
delete thisCache[ name ];
// If there is no data left in the cache, we want to continue
// and let the cache object itself get destroyed
if ( !isEmptyDataObject(thisCache) ) {
// See jQuery.data for more information
if ( pvt ) {
delete cache[ id ][ internalKey ];
// Don't destroy the parent cache unless the internal data object
// had been the only thing left in it
if ( !isEmptyDataObject(cache[ id ]) ) {
var internalCache = cache[ id ][ internalKey ];
// Browsers that fail expando deletion also refuse to delete expandos on
// the window, but it will allow it on all other JS other browsers
// don't care
if ( jQuery.support.deleteExpando || cache != window ) {
delete cache[ id ];
cache[ id ] =
// We destroyed the entire user cache at once because it's faster than
// iterating through each key, but we need to continue to persist internal
// data if it existed
if ( internalCache ) {
cache[ id ] = {};
// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
// metadata on plain JS objects when the object is serialized using
// JSON.stringify
if ( !isNode ) {
cache[ id ].toJSON = jQuery.
cache[ id ][ internalKey ] = internalC
// Otherwise, we need to eliminate the expando on the node to avoid
// false lookups in the cache for entries that no longer exist
} else if ( isNode ) {
// IE does not allow us to delete expando properties from nodes,
// nor does it have a removeAttribute function on D
// we must handle all of these cases
if ( jQuery.support.deleteExpando ) {
delete elem[ jQuery.expando ];
} else if ( elem.removeAttribute ) {
elem.removeAttribute( jQuery.expando );
elem[ jQuery.expando ] =
// For internal use only.
_data: function( elem, name, data ) {
return jQuery.data( elem, name, data, true );
// A method for determining if a DOM node can handle the data expando
acceptData: function( elem ) {
if ( elem.nodeName ) {
var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
if ( match ) {
return !(match === true || elem.getAttribute(&classid&) !== match);
jQuery.fn.extend({
data: function( key, value ) {
var data =
if ( typeof key === &undefined& ) {
if ( this.length ) {
data = jQuery.data( this[0] );
if ( this[0].nodeType === 1 ) {
var attr = this[0].attributes,
for ( var i = 0, l = attr. i & i++ ) {
name = attr[i].
if ( name.indexOf( &data-& ) === 0 ) {
name = jQuery.camelCase( name.substring(5) );
dataAttr( this[0], name, data[ name ] );
} else if ( typeof key === &object& ) {
return this.each(function() {
jQuery.data( this, key );
var parts = key.split(&.&);
parts[1] = parts[1] ? &.& + parts[1] : &&;
if ( value === undefined ) {
data = this.triggerHandler(&getData& + parts[1] + &!&, [parts[0]]);
// Try to fetch any internally stored data first
if ( data === undefined && this.length ) {
data = jQuery.data( this[0], key );
data = dataAttr( this[0], key, data );
return data === undefined && parts[1] ?
this.data( parts[0] ) :
return this.each(function() {
var $this = jQuery( this ),
args = [ parts[0], value ];
$this.triggerHandler( &setData& + parts[1] + &!&, args );
jQuery.data( this, key, value );
$this.triggerHandler( &changeData& + parts[1] + &!&, args );
removeData: function( key ) {
return this.each(function() {
jQuery.removeData( this, key );
function dataAttr( elem, key, data ) {
// If nothing was found internally, try to fetch any
// data from the HTML5 data-* attribute
if ( data === undefined && elem.nodeType === 1 ) {
var name = &data-& + key.replace( rmultiDash, &$1-$2& ).toLowerCase();
data = elem.getAttribute( name );
if ( typeof data === &string& ) {
data = data === &true& ? true :
data === &false& ? false :
data === &null& ? null :
!jQuery.isNaN( data ) ? parseFloat( data ) :
rbrace.test( data ) ? jQuery.parseJSON( data ) :
} catch( e ) {}
// Make sure we set the data so it isn't changed later
jQuery.data( elem, key, data );
// TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
// property to be cons this property always exists in
// order to make sure JSON.stringify does not expose internal metadata
function isEmptyDataObject( obj ) {
for ( var name in obj ) {
if ( name !== &toJSON& ) {
function handleQueueMarkDefer( elem, type, src ) {
var deferDataKey = type + &defer&,
queueDataKey = type + &queue&,
markDataKey = type + &mark&,
defer = jQuery.data( elem, deferDataKey, undefined, true );
if ( defer &&
( src === &queue& || !jQuery.data( elem, queueDataKey, undefined, true ) ) &&
( src === &mark& || !jQuery.data( elem, markDataKey, undefined, true ) ) ) {
// Give room for hard-coded callbacks to fire first
// and eventually mark/queue something else on the element
setTimeout( function() {
if ( !jQuery.data( elem, queueDataKey, undefined, true ) &&