9B534B8686E580E0E01768F00155B461

at path：ROOT / sistema / vendors / jquery / src / deferred.js

run：R W Run

ajax

DIR

2026-04-09 04:12:40

R W Run

attributes

DIR

2026-04-09 04:12:40

R W Run

core

DIR

2026-04-09 04:12:40

R W Run

css

DIR

2026-04-09 04:12:40

R W Run

data

DIR

2026-04-09 04:12:40

R W Run

effects

DIR

2026-04-09 04:12:40

R W Run

event

DIR

2026-04-13 08:51:37

R W Run

exports

DIR

2026-04-09 04:12:40

R W Run

manipulation

DIR

2026-04-09 04:12:40

R W Run

queue

DIR

2026-04-09 04:12:40

R W Run

traversing

DIR

2026-04-13 08:51:37

R W Run

var

DIR

2026-04-09 04:12:40

R W Run

.jshintrc

475 By

2018-11-08 02:46:18

R W Run

ajax.js

21.32 KB

2018-11-08 02:46:18

R W Run

attributes.js

202 By

2018-11-08 02:46:18

R W Run

callbacks.js

5.33 KB

2018-11-08 02:46:18

R W Run

core.js

11.44 KB

2018-11-08 02:46:18

R W Run

css.js

12.86 KB

2018-11-08 02:46:18

R W Run

data.js

5 KB

2018-11-08 02:46:18

R W Run

deferred.js

4.38 KB

2018-11-08 02:46:18

R W Run

deprecated.js

636 By

2018-11-08 02:46:18

R W Run

dimensions.js

1.74 KB

2018-11-08 02:46:18

R W Run

effects.js

15.52 KB

2018-11-08 02:46:18

R W Run

event.js

18.77 KB

2018-11-08 02:46:18

R W Run

intro.js

1.34 KB

2018-11-08 02:46:18

R W Run

jquery.js

606 By

2018-11-08 02:46:18

R W Run

manipulation.js

12.07 KB

2018-11-08 02:46:18

R W Run

offset.js

5.87 KB

2018-11-08 02:46:18

R W Run

outro.js

20 By

2018-11-08 02:46:18

R W Run

queue.js

3 KB

2018-11-08 02:46:18

R W Run

selector-native.js

5.52 KB

2018-11-08 02:46:18

R W Run

selector-sizzle.js

342 By

2018-11-08 02:46:18

R W Run

selector.js

50 By

2018-11-08 02:46:18

R W Run

serialize.js

3.2 KB

2018-11-08 02:46:18

R W Run

traversing.js

3.98 KB

2018-11-08 02:46:18

R W Run

wrap.js

1.48 KB

2018-11-08 02:46:18

R W Run

error_log

📄deferred.js

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()
										.progress( newDefer.notify )
										.done( newDefer.resolve )
										.fail( newDefer.reject );
								} 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()
						.progress( updateFunc( i, progressContexts, progressValues ) )
						.done( updateFunc( i, resolveContexts, resolveValues ) )
						.fail( deferred.reject );
				} else {
					--remaining;
				}
			}
		}

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

return deferred.promise();
	}
} );

return jQuery;
} );