Gecko [ paroquia-rio-de-mouro.pt ]

Name	Size	Permission	Date
ajax	[ DIR ]	drwxr-xr-x	2018-04-19 18:15
attributes	[ DIR ]	drwxr-xr-x	2018-04-19 18:15
core	[ DIR ]	drwxr-xr-x	2018-04-19 18:15
css	[ DIR ]	drwxr-xr-x	2018-04-19 18:15
data	[ DIR ]	drwxr-xr-x	2018-04-19 18:15
effects	[ DIR ]	drwxr-xr-x	2018-04-19 18:15
event	[ DIR ]	drwxr-xr-x	2018-04-19 18:15
exports	[ DIR ]	drwxr-xr-x	2018-04-19 18:15
manipulation	[ DIR ]	drwxr-xr-x	2018-04-19 18:15
queue	[ DIR ]	drwxr-xr-x	2018-04-19 18:15
sizzle	[ DIR ]	drwxr-xr-x	2018-04-19 18:15
traversing	[ DIR ]	drwxr-xr-x	2018-04-19 18:15
var	[ DIR ]	drwxr-xr-x	2018-04-19 18:15
ajax.js	20.67 KB	-rw-r--r--	2018-04-19 18:15
attributes.js	200 B	-rw-r--r--	2018-04-19 18:15
callbacks.js	5.38 KB	-rw-r--r--	2018-04-19 18:15
core.js	11.51 KB	-rw-r--r--	2018-04-19 18:15
css.js	12.06 KB	-rw-r--r--	2018-04-19 18:15
data.js	4.83 KB	-rw-r--r--	2018-04-19 18:15
deferred.js	4.31 KB	-rw-r--r--	2018-04-19 18:15
deprecated.js	223 B	-rw-r--r--	2018-04-19 18:15
dimensions.js	1.73 KB	-rw-r--r--	2018-04-19 18:15
effects.js	16.52 KB	-rw-r--r--	2018-04-19 18:15
event.js	23.9 KB	-rw-r--r--	2018-04-19 18:15
intro.js	1.36 KB	-rw-r--r--	2018-04-19 18:15
jquery.js	574 B	-rw-r--r--	2018-04-19 18:15
manipulation.js	14.69 KB	-rw-r--r--	2018-04-19 18:15
offset.js	5.46 KB	-rw-r--r--	2018-04-19 18:15
outro.js	5 B	-rw-r--r--	2018-04-19 18:15
queue.js	2.99 KB	-rw-r--r--	2018-04-19 18:15
selector-native.js	4.33 KB	-rw-r--r--	2018-04-19 18:15
selector-sizzle.js	294 B	-rw-r--r--	2018-04-19 18:15
selector.js	33 B	-rw-r--r--	2018-04-19 18:15
serialize.js	3.14 KB	-rw-r--r--	2018-04-19 18:15
traversing.js	4.43 KB	-rw-r--r--	2018-04-19 18:15
wrap.js	1.46 KB	-rw-r--r--	2018-04-19 18:15

Rename

define([
	"./core",
	"./var/slice",
	"./callbacks"
], function( jQuery, slice ) {

jQuery.extend({

Deferred: function( func ) {
		var tuples = [
				// action, add listener, listener list, final state
				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
				[ "notify", "progress", jQuery.Callbacks("memory") ]
			],
			state = "pending",
			promise = {
				state: function() {
					return state;
				},
				always: function() {
					deferred.done( arguments ).fail( arguments );
					return this;
				},
				then: function( /* fnDone, fnFail, fnProgress */ ) {
					var fns = arguments;
					return jQuery.Deferred(function( newDefer ) {
						jQuery.each( tuples, function( i, tuple ) {
							var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
							// deferred[ done | fail | progress ] for forwarding actions to newDefer
							deferred[ tuple[1] ](function() {
								var returned = fn && fn.apply( this, arguments );
								if ( returned && jQuery.isFunction( returned.promise ) ) {
									returned.promise()
										.done( newDefer.resolve )
										.fail( newDefer.reject )
										.progress( newDefer.notify );
								} else {
									newDefer[ tuple[ 0 ] + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
								}
							});
						});
						fns = null;
					}).promise();
				},
				// Get a promise for this deferred
				// If obj is provided, the promise aspect is added to the object
				promise: function( obj ) {
					return obj != null ? jQuery.extend( obj, promise ) : promise;
				}
			},
			deferred = {};

// Keep pipe for back-compat
		promise.pipe = promise.then;

// Add list-specific methods
		jQuery.each( tuples, function( i, tuple ) {
			var list = tuple[ 2 ],
				stateString = tuple[ 3 ];

// promise[ done | fail | progress ] = list.add
			promise[ tuple[1] ] = list.add;

// Handle state
			if ( stateString ) {
				list.add(function() {
					// state = [ resolved | rejected ]
					state = stateString;

// [ reject_list | resolve_list ].disable; progress_list.lock
				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
			}

// deferred[ resolve | reject | notify ]
			deferred[ tuple[0] ] = function() {
				deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
				return this;
			};
			deferred[ tuple[0] + "With" ] = list.fireWith;
		});

// Make the deferred a promise
		promise.promise( deferred );

// Call given func if any
		if ( func ) {
			func.call( deferred, deferred );
		}

// All done!
		return deferred;
	},

// Deferred helper
	when: function( subordinate /* , ..., subordinateN */ ) {
		var i = 0,
			resolveValues = slice.call( arguments ),
			length = resolveValues.length,

// the count of uncompleted subordinates
			remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,

// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
			deferred = remaining === 1 ? subordinate : jQuery.Deferred(),

// Update function for both resolve and progress values
			updateFunc = function( i, contexts, values ) {
				return function( value ) {
					contexts[ i ] = this;
					values[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
					if ( values === progressValues ) {
						deferred.notifyWith( contexts, values );
					} else if ( !( --remaining ) ) {
						deferred.resolveWith( contexts, values );
					}
				};
			},

progressValues, progressContexts, resolveContexts;

// Add listeners to Deferred subordinates; treat others as resolved
		if ( length > 1 ) {
			progressValues = new Array( length );
			progressContexts = new Array( length );
			resolveContexts = new Array( length );
			for ( ; i < length; i++ ) {
				if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
					resolveValues[ i ].promise()
						.done( updateFunc( i, resolveContexts, resolveValues ) )
						.fail( deferred.reject )
						.progress( updateFunc( i, progressContexts, progressValues ) );
				} else {
					--remaining;
				}
			}
		}

// If we're not waiting on anything, resolve the master
		if ( !remaining ) {
			deferred.resolveWith( resolveContexts, resolveValues );
		}

return deferred.promise();
	}
});

return jQuery;
});