trimLeft = /^\s+/,
trimRight = /\s+$/,
- // Check for non-word characters
- rnonword = /\W/,
-
// Check for digits
rdigit = /\d/,
} else {
ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
- selector = (ret.cacheable ? jQuery(ret.fragment).clone()[0] : ret.fragment).childNodes;
+ selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
}
return jQuery.merge( this, selector );
-
+
// HANDLE: $("#id")
} else {
elem = document.getElementById( match[2] );
return jQuery.each( this, callback, args );
},
- ready: function() {
+ ready: function( fn ) {
// Attach the listeners
jQuery.bindReady();
- // Change ready & apply
- return ( jQuery.fn.ready = readyList.done ).apply( this , arguments );
+ // Add the callback
+ readyList.done( fn );
+
+ return this;
},
eq: function( i ) {
jQuery.fn.init.prototype = jQuery.fn;
jQuery.extend = jQuery.fn.extend = function() {
- var options, name, src, copy, copyIsArray, clone,
+ var options, name, src, copy, copyIsArray, clone,
target = arguments[0] || {},
i = 1,
length = arguments.length,
}
// If there are functions bound, to execute
- readyList.resolveWith( document , [ jQuery ] );
+ readyList.resolveWith( document, [ jQuery ] );
// Trigger any bound ready events
if ( jQuery.fn.trigger ) {
if ( data && rnotwhite.test(data) ) {
// Inspired by code by Andrea Giammarchi
// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
- var head = document.getElementsByTagName("head")[0] || document.documentElement,
- script = document.createElement("script");
-
- script.type = "text/javascript";
+ var head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement,
+ script = document.createElement( "script" );
if ( jQuery.support.scriptEval() ) {
script.appendChild( document.createTextNode( data ) );
// Create a simple deferred (one callbacks list)
_Deferred: function() {
-
var // callbacks list
callbacks = [],
// stored [ context , args ]
deferred = {
// done( f1, f2, ...)
- done: function () {
-
- if ( ! cancelled ) {
-
+ done: function() {
+ if ( !cancelled ) {
var args = arguments,
i,
length,
elem,
type,
_fired;
-
if ( fired ) {
_fired = fired;
fired = 0;
}
-
- for ( i = 0, length = args.length ; i < length ; i++ ) {
+ for ( i = 0, length = args.length; i < length; i++ ) {
elem = args[ i ];
type = jQuery.type( elem );
if ( type === "array" ) {
- deferred.done.apply( deferred , elem );
+ deferred.done.apply( deferred, elem );
} else if ( type === "function" ) {
callbacks.push( elem );
}
}
-
if ( _fired ) {
- deferred.resolveWith( _fired[ 0 ] , _fired[ 1 ] );
+ deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
}
}
-
return this;
},
// resolve with given context and args
- resolveWith: function( context , args ) {
- if ( ! cancelled && ! fired && ! firing ) {
-
+ resolveWith: function( context, args ) {
+ if ( !cancelled && !fired && !firing ) {
+ // make sure args are available (#8421)
+ args = args || [];
firing = 1;
-
try {
while( callbacks[ 0 ] ) {
- callbacks.shift().apply( context , args );
+ callbacks.shift().apply( context, args );
}
}
finally {
- fired = [ context , args ];
+ fired = [ context, args ];
firing = 0;
}
}
// resolve with this as context and given arguments
resolve: function() {
- deferred.resolveWith( jQuery.isFunction( this.promise ) ? this.promise() : this , arguments );
+ deferred.resolveWith( jQuery.isFunction( this.promise ) ? this.promise() : this, arguments );
return this;
},
},
// Full fledged deferred (two callbacks list)
- // Typical success/error system
Deferred: function( func ) {
-
var deferred = jQuery._Deferred(),
failDeferred = jQuery._Deferred(),
promise;
-
// Add errorDeferred methods, then and promise
- jQuery.extend( deferred , {
-
- then: function( doneCallbacks , failCallbacks ) {
+ jQuery.extend( deferred, {
+ then: function( doneCallbacks, failCallbacks ) {
deferred.done( doneCallbacks ).fail( failCallbacks );
return this;
},
isRejected: failDeferred.isResolved,
// Get a promise for this deferred
// If obj is provided, the promise aspect is added to the object
- // (i is used internally)
- promise: function( obj , i ) {
+ promise: function( obj ) {
if ( obj == null ) {
if ( promise ) {
return promise;
}
promise = obj = {};
}
- i = promiseMethods.length;
+ var i = promiseMethods.length;
while( i-- ) {
- obj[ promiseMethods[ i ] ] = deferred[ promiseMethods[ i ] ];
+ obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
}
return obj;
}
-
} );
-
// Make sure only one callback list will be used
- deferred.then( failDeferred.cancel , deferred.cancel );
-
+ deferred.done( failDeferred.cancel ).fail( deferred.cancel );
// Unexpose cancel
delete deferred.cancel;
-
// Call given func if any
if ( func ) {
- func.call( deferred , deferred );
+ func.call( deferred, deferred );
}
-
return deferred;
},
// Deferred helper
when: function( object ) {
- var args = arguments,
- length = args.length,
- deferred = length <= 1 && object && jQuery.isFunction( object.promise ) ?
+ var lastIndex = arguments.length,
+ deferred = lastIndex <= 1 && object && jQuery.isFunction( object.promise ) ?
object :
jQuery.Deferred(),
- promise = deferred.promise(),
- resolveArray;
-
- if ( length > 1 ) {
- resolveArray = new Array( length );
- jQuery.each( args, function( index, element, args ) {
- jQuery.when( element ).done( function( value ) {
- args = arguments;
- resolveArray[ index ] = args.length > 1 ? slice.call( args , 0 ) : value;
- if( ! --length ) {
- deferred.resolveWith( promise, resolveArray );
- }
- }).fail( function() {
- deferred.rejectWith( promise, arguments );
- });
- return !deferred.isRejected();
- });
+ promise = deferred.promise();
+
+ if ( lastIndex > 1 ) {
+ var array = slice.call( arguments, 0 ),
+ count = lastIndex,
+ iCallback = function( index ) {
+ return function( value ) {
+ array[ index ] = arguments.length > 1 ? slice.call( arguments, 0 ) : value;
+ if ( !( --count ) ) {
+ deferred.resolveWith( promise, array );
+ }
+ };
+ };
+ while( ( lastIndex-- ) ) {
+ object = array[ lastIndex ];
+ if ( object && jQuery.isFunction( object.promise ) ) {
+ object.promise().then( iCallback(lastIndex), deferred.reject );
+ } else {
+ --count;
+ }
+ }
+ if ( !count ) {
+ deferred.resolveWith( promise, array );
+ }
} else if ( deferred !== object ) {
deferred.resolve( object );
}
return { browser: match[1] || "", version: match[2] || "0" };
},
- subclass: function(){
+ sub: function() {
function jQuerySubclass( selector, context ) {
return new jQuerySubclass.fn.init( selector, context );
}
+ jQuery.extend( true, jQuerySubclass, this );
jQuerySubclass.superclass = this;
jQuerySubclass.fn = jQuerySubclass.prototype = this();
jQuerySubclass.fn.constructor = jQuerySubclass;
jQuerySubclass.subclass = this.subclass;
jQuerySubclass.fn.init = function init( selector, context ) {
- if (context && context instanceof jQuery && !(context instanceof jQuerySubclass)){
+ if ( context && context instanceof jQuery && !(context instanceof jQuerySubclass) ) {
context = jQuerySubclass(context);
}
+
return jQuery.fn.init.call( this, selector, context, rootjQuerySubclass );
};
jQuerySubclass.fn.init.prototype = jQuerySubclass.fn;
}
// Expose jQuery to the global object
-return (window.jQuery = window.$ = jQuery);
+return jQuery;
})();