xonecas.io
286
Sf

simple-flask-coffee-sass-boilerplate / files

simple-flask-coffee-sass-boilerplate / bower_components / jquery / src / ajax.js

21.2 KB
1define([
2	"./core",
3	"./var/rnotwhite",
4	"./ajax/var/nonce",
5	"./ajax/var/rquery",
6	"./core/init",
7	"./ajax/parseJSON",
8	"./ajax/parseXML",
9	"./deferred"
10], function( jQuery, rnotwhite, nonce, rquery ) {
11
12var
13	// Document location
14	ajaxLocParts,
15	ajaxLocation,
16
17	rhash = /#.*$/,
18	rts = /([?&])_=[^&]*/,
19	rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
20	// #7653, #8125, #8152: local protocol detection
21	rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
22	rnoContent = /^(?:GET|HEAD)$/,
23	rprotocol = /^\/\//,
24	rurl = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/,
25
26	/* Prefilters
27	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
28	 * 2) These are called:
29	 *    - BEFORE asking for a transport
30	 *    - AFTER param serialization (s.data is a string if s.processData is true)
31	 * 3) key is the dataType
32	 * 4) the catchall symbol "*" can be used
33	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
34	 */
35	prefilters = {},
36
37	/* Transports bindings
38	 * 1) key is the dataType
39	 * 2) the catchall symbol "*" can be used
40	 * 3) selection will start with transport dataType and THEN go to "*" if needed
41	 */
42	transports = {},
43
44	// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
45	allTypes = "*/".concat("*");
46
47// #8138, IE may throw an exception when accessing
48// a field from window.location if document.domain has been set
49try {
50	ajaxLocation = location.href;
51} catch( e ) {
52	// Use the href attribute of an A element
53	// since IE will modify it given document.location
54	ajaxLocation = document.createElement( "a" );
55	ajaxLocation.href = "";
56	ajaxLocation = ajaxLocation.href;
57}
58
59// Segment location into parts
60ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
61
62// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
63function addToPrefiltersOrTransports( structure ) {
64
65	// dataTypeExpression is optional and defaults to "*"
66	return function( dataTypeExpression, func ) {
67
68		if ( typeof dataTypeExpression !== "string" ) {
69			func = dataTypeExpression;
70			dataTypeExpression = "*";
71		}
72
73		var dataType,
74			i = 0,
75			dataTypes = dataTypeExpression.toLowerCase().match( rnotwhite ) || [];
76
77		if ( jQuery.isFunction( func ) ) {
78			// For each dataType in the dataTypeExpression
79			while ( (dataType = dataTypes[i++]) ) {
80				// Prepend if requested
81				if ( dataType[0] === "+" ) {
82					dataType = dataType.slice( 1 ) || "*";
83					(structure[ dataType ] = structure[ dataType ] || []).unshift( func );
84
85				// Otherwise append
86				} else {
87					(structure[ dataType ] = structure[ dataType ] || []).push( func );
88				}
89			}
90		}
91	};
92}
93
94// Base inspection function for prefilters and transports
95function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
96
97	var inspected = {},
98		seekingTransport = ( structure === transports );
99
100	function inspect( dataType ) {
101		var selected;
102		inspected[ dataType ] = true;
103		jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
104			var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
105			if ( typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
106				options.dataTypes.unshift( dataTypeOrTransport );
107				inspect( dataTypeOrTransport );
108				return false;
109			} else if ( seekingTransport ) {
110				return !( selected = dataTypeOrTransport );
111			}
112		});
113		return selected;
114	}
115
116	return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
117}
118
119// A special extend for ajax options
120// that takes "flat" options (not to be deep extended)
121// Fixes #9887
122function ajaxExtend( target, src ) {
123	var key, deep,
124		flatOptions = jQuery.ajaxSettings.flatOptions || {};
125
126	for ( key in src ) {
127		if ( src[ key ] !== undefined ) {
128			( flatOptions[ key ] ? target : ( deep || (deep = {}) ) )[ key ] = src[ key ];
129		}
130	}
131	if ( deep ) {
132		jQuery.extend( true, target, deep );
133	}
134
135	return target;
136}
137
138/* Handles responses to an ajax request:
139 * - finds the right dataType (mediates between content-type and expected dataType)
140 * - returns the corresponding response
141 */
142function ajaxHandleResponses( s, jqXHR, responses ) {
143
144	var ct, type, finalDataType, firstDataType,
145		contents = s.contents,
146		dataTypes = s.dataTypes;
147
148	// Remove auto dataType and get content-type in the process
149	while ( dataTypes[ 0 ] === "*" ) {
150		dataTypes.shift();
151		if ( ct === undefined ) {
152			ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
153		}
154	}
155
156	// Check if we're dealing with a known content-type
157	if ( ct ) {
158		for ( type in contents ) {
159			if ( contents[ type ] && contents[ type ].test( ct ) ) {
160				dataTypes.unshift( type );
161				break;
162			}
163		}
164	}
165
166	// Check to see if we have a response for the expected dataType
167	if ( dataTypes[ 0 ] in responses ) {
168		finalDataType = dataTypes[ 0 ];
169	} else {
170		// Try convertible dataTypes
171		for ( type in responses ) {
172			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
173				finalDataType = type;
174				break;
175			}
176			if ( !firstDataType ) {
177				firstDataType = type;
178			}
179		}
180		// Or just use first one
181		finalDataType = finalDataType || firstDataType;
182	}
183
184	// If we found a dataType
185	// We add the dataType to the list if needed
186	// and return the corresponding response
187	if ( finalDataType ) {
188		if ( finalDataType !== dataTypes[ 0 ] ) {
189			dataTypes.unshift( finalDataType );
190		}
191		return responses[ finalDataType ];
192	}
193}
194
195/* Chain conversions given the request and the original response
196 * Also sets the responseXXX fields on the jqXHR instance
197 */
198function ajaxConvert( s, response, jqXHR, isSuccess ) {
199	var conv2, current, conv, tmp, prev,
200		converters = {},
201		// Work with a copy of dataTypes in case we need to modify it for conversion
202		dataTypes = s.dataTypes.slice();
203
204	// Create converters map with lowercased keys
205	if ( dataTypes[ 1 ] ) {
206		for ( conv in s.converters ) {
207			converters[ conv.toLowerCase() ] = s.converters[ conv ];
208		}
209	}
210
211	current = dataTypes.shift();
212
213	// Convert to each sequential dataType
214	while ( current ) {
215
216		if ( s.responseFields[ current ] ) {
217			jqXHR[ s.responseFields[ current ] ] = response;
218		}
219
220		// Apply the dataFilter if provided
221		if ( !prev && isSuccess && s.dataFilter ) {
222			response = s.dataFilter( response, s.dataType );
223		}
224
225		prev = current;
226		current = dataTypes.shift();
227
228		if ( current ) {
229
230		// There's only work to do if current dataType is non-auto
231			if ( current === "*" ) {
232
233				current = prev;
234
235			// Convert response if prev dataType is non-auto and differs from current
236			} else if ( prev !== "*" && prev !== current ) {
237
238				// Seek a direct converter
239				conv = converters[ prev + " " + current ] || converters[ "* " + current ];
240
241				// If none found, seek a pair
242				if ( !conv ) {
243					for ( conv2 in converters ) {
244
245						// If conv2 outputs current
246						tmp = conv2.split( " " );
247						if ( tmp[ 1 ] === current ) {
248
249							// If prev can be converted to accepted input
250							conv = converters[ prev + " " + tmp[ 0 ] ] ||
251								converters[ "* " + tmp[ 0 ] ];
252							if ( conv ) {
253								// Condense equivalence converters
254								if ( conv === true ) {
255									conv = converters[ conv2 ];
256
257								// Otherwise, insert the intermediate dataType
258								} else if ( converters[ conv2 ] !== true ) {
259									current = tmp[ 0 ];
260									dataTypes.unshift( tmp[ 1 ] );
261								}
262								break;
263							}
264						}
265					}
266				}
267
268				// Apply converter (if not an equivalence)
269				if ( conv !== true ) {
270
271					// Unless errors are allowed to bubble, catch and return them
272					if ( conv && s[ "throws" ] ) {
273						response = conv( response );
274					} else {
275						try {
276							response = conv( response );
277						} catch ( e ) {
278							return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current };
279						}
280					}
281				}
282			}
283		}
284	}
285
286	return { state: "success", data: response };
287}
288
289jQuery.extend({
290
291	// Counter for holding the number of active queries
292	active: 0,
293
294	// Last-Modified header cache for next request
295	lastModified: {},
296	etag: {},
297
298	ajaxSettings: {
299		url: ajaxLocation,
300		type: "GET",
301		isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
302		global: true,
303		processData: true,
304		async: true,
305		contentType: "application/x-www-form-urlencoded; charset=UTF-8",
306		/*
307		timeout: 0,
308		data: null,
309		dataType: null,
310		username: null,
311		password: null,
312		cache: null,
313		throws: false,
314		traditional: false,
315		headers: {},
316		*/
317
318		accepts: {
319			"*": allTypes,
320			text: "text/plain",
321			html: "text/html",
322			xml: "application/xml, text/xml",
323			json: "application/json, text/javascript"
324		},
325
326		contents: {
327			xml: /xml/,
328			html: /html/,
329			json: /json/
330		},
331
332		responseFields: {
333			xml: "responseXML",
334			text: "responseText",
335			json: "responseJSON"
336		},
337
338		// Data converters
339		// Keys separate source (or catchall "*") and destination types with a single space
340		converters: {
341
342			// Convert anything to text
343			"* text": String,
344
345			// Text to html (true = no transformation)
346			"text html": true,
347
348			// Evaluate text as a json expression
349			"text json": jQuery.parseJSON,
350
351			// Parse text as xml
352			"text xml": jQuery.parseXML
353		},
354
355		// For options that shouldn't be deep extended:
356		// you can add your own custom options here if
357		// and when you create one that shouldn't be
358		// deep extended (see ajaxExtend)
359		flatOptions: {
360			url: true,
361			context: true
362		}
363	},
364
365	// Creates a full fledged settings object into target
366	// with both ajaxSettings and settings fields.
367	// If target is omitted, writes into ajaxSettings.
368	ajaxSetup: function( target, settings ) {
369		return settings ?
370
371			// Building a settings object
372			ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
373
374			// Extending ajaxSettings
375			ajaxExtend( jQuery.ajaxSettings, target );
376	},
377
378	ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
379	ajaxTransport: addToPrefiltersOrTransports( transports ),
380
381	// Main method
382	ajax: function( url, options ) {
383
384		// If url is an object, simulate pre-1.5 signature
385		if ( typeof url === "object" ) {
386			options = url;
387			url = undefined;
388		}
389
390		// Force options to be an object
391		options = options || {};
392
393		var transport,
394			// URL without anti-cache param
395			cacheURL,
396			// Response headers
397			responseHeadersString,
398			responseHeaders,
399			// timeout handle
400			timeoutTimer,
401			// Cross-domain detection vars
402			parts,
403			// To know if global events are to be dispatched
404			fireGlobals,
405			// Loop variable
406			i,
407			// Create the final options object
408			s = jQuery.ajaxSetup( {}, options ),
409			// Callbacks context
410			callbackContext = s.context || s,
411			// Context for global events is callbackContext if it is a DOM node or jQuery collection
412			globalEventContext = s.context && ( callbackContext.nodeType || callbackContext.jquery ) ?
413				jQuery( callbackContext ) :
414				jQuery.event,
415			// Deferreds
416			deferred = jQuery.Deferred(),
417			completeDeferred = jQuery.Callbacks("once memory"),
418			// Status-dependent callbacks
419			statusCode = s.statusCode || {},
420			// Headers (they are sent all at once)
421			requestHeaders = {},
422			requestHeadersNames = {},
423			// The jqXHR state
424			state = 0,
425			// Default abort message
426			strAbort = "canceled",
427			// Fake xhr
428			jqXHR = {
429				readyState: 0,
430
431				// Builds headers hashtable if needed
432				getResponseHeader: function( key ) {
433					var match;
434					if ( state === 2 ) {
435						if ( !responseHeaders ) {
436							responseHeaders = {};
437							while ( (match = rheaders.exec( responseHeadersString )) ) {
438								responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
439							}
440						}
441						match = responseHeaders[ key.toLowerCase() ];
442					}
443					return match == null ? null : match;
444				},
445
446				// Raw string
447				getAllResponseHeaders: function() {
448					return state === 2 ? responseHeadersString : null;
449				},
450
451				// Caches the header
452				setRequestHeader: function( name, value ) {
453					var lname = name.toLowerCase();
454					if ( !state ) {
455						name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
456						requestHeaders[ name ] = value;
457					}
458					return this;
459				},
460
461				// Overrides response content-type header
462				overrideMimeType: function( type ) {
463					if ( !state ) {
464						s.mimeType = type;
465					}
466					return this;
467				},
468
469				// Status-dependent callbacks
470				statusCode: function( map ) {
471					var code;
472					if ( map ) {
473						if ( state < 2 ) {
474							for ( code in map ) {
475								// Lazy-add the new callback in a way that preserves old ones
476								statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
477							}
478						} else {
479							// Execute the appropriate callbacks
480							jqXHR.always( map[ jqXHR.status ] );
481						}
482					}
483					return this;
484				},
485
486				// Cancel the request
487				abort: function( statusText ) {
488					var finalText = statusText || strAbort;
489					if ( transport ) {
490						transport.abort( finalText );
491					}
492					done( 0, finalText );
493					return this;
494				}
495			};
496
497		// Attach deferreds
498		deferred.promise( jqXHR ).complete = completeDeferred.add;
499		jqXHR.success = jqXHR.done;
500		jqXHR.error = jqXHR.fail;
501
502		// Remove hash character (#7531: and string promotion)
503		// Add protocol if not provided (prefilters might expect it)
504		// Handle falsy url in the settings object (#10093: consistency with old signature)
505		// We also use the url parameter if available
506		s.url = ( ( url || s.url || ajaxLocation ) + "" ).replace( rhash, "" )
507			.replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
508
509		// Alias method option to type as per ticket #12004
510		s.type = options.method || options.type || s.method || s.type;
511
512		// Extract dataTypes list
513		s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().match( rnotwhite ) || [ "" ];
514
515		// A cross-domain request is in order when we have a protocol:host:port mismatch
516		if ( s.crossDomain == null ) {
517			parts = rurl.exec( s.url.toLowerCase() );
518			s.crossDomain = !!( parts &&
519				( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] ||
520					( parts[ 3 ] || ( parts[ 1 ] === "http:" ? "80" : "443" ) ) !==
521						( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? "80" : "443" ) ) )
522			);
523		}
524
525		// Convert data if not already a string
526		if ( s.data && s.processData && typeof s.data !== "string" ) {
527			s.data = jQuery.param( s.data, s.traditional );
528		}
529
530		// Apply prefilters
531		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
532
533		// If request was aborted inside a prefilter, stop there
534		if ( state === 2 ) {
535			return jqXHR;
536		}
537
538		// We can fire global events as of now if asked to
539		fireGlobals = s.global;
540
541		// Watch for a new set of requests
542		if ( fireGlobals && jQuery.active++ === 0 ) {
543			jQuery.event.trigger("ajaxStart");
544		}
545
546		// Uppercase the type
547		s.type = s.type.toUpperCase();
548
549		// Determine if request has content
550		s.hasContent = !rnoContent.test( s.type );
551
552		// Save the URL in case we're toying with the If-Modified-Since
553		// and/or If-None-Match header later on
554		cacheURL = s.url;
555
556		// More options handling for requests with no content
557		if ( !s.hasContent ) {
558
559			// If data is available, append data to url
560			if ( s.data ) {
561				cacheURL = ( s.url += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data );
562				// #9682: remove data so that it's not used in an eventual retry
563				delete s.data;
564			}
565
566			// Add anti-cache in url if needed
567			if ( s.cache === false ) {
568				s.url = rts.test( cacheURL ) ?
569
570					// If there is already a '_' parameter, set its value
571					cacheURL.replace( rts, "$1_=" + nonce++ ) :
572
573					// Otherwise add one to the end
574					cacheURL + ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + nonce++;
575			}
576		}
577
578		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
579		if ( s.ifModified ) {
580			if ( jQuery.lastModified[ cacheURL ] ) {
581				jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
582			}
583			if ( jQuery.etag[ cacheURL ] ) {
584				jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
585			}
586		}
587
588		// Set the correct header, if data is being sent
589		if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
590			jqXHR.setRequestHeader( "Content-Type", s.contentType );
591		}
592
593		// Set the Accepts header for the server, depending on the dataType
594		jqXHR.setRequestHeader(
595			"Accept",
596			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
597				s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
598				s.accepts[ "*" ]
599		);
600
601		// Check for headers option
602		for ( i in s.headers ) {
603			jqXHR.setRequestHeader( i, s.headers[ i ] );
604		}
605
606		// Allow custom headers/mimetypes and early abort
607		if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
608			// Abort if not done already and return
609			return jqXHR.abort();
610		}
611
612		// aborting is no longer a cancellation
613		strAbort = "abort";
614
615		// Install callbacks on deferreds
616		for ( i in { success: 1, error: 1, complete: 1 } ) {
617			jqXHR[ i ]( s[ i ] );
618		}
619
620		// Get transport
621		transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
622
623		// If no transport, we auto-abort
624		if ( !transport ) {
625			done( -1, "No Transport" );
626		} else {
627			jqXHR.readyState = 1;
628
629			// Send global event
630			if ( fireGlobals ) {
631				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
632			}
633			// Timeout
634			if ( s.async && s.timeout > 0 ) {
635				timeoutTimer = setTimeout(function() {
636					jqXHR.abort("timeout");
637				}, s.timeout );
638			}
639
640			try {
641				state = 1;
642				transport.send( requestHeaders, done );
643			} catch ( e ) {
644				// Propagate exception as error if not done
645				if ( state < 2 ) {
646					done( -1, e );
647				// Simply rethrow otherwise
648				} else {
649					throw e;
650				}
651			}
652		}
653
654		// Callback for when everything is done
655		function done( status, nativeStatusText, responses, headers ) {
656			var isSuccess, success, error, response, modified,
657				statusText = nativeStatusText;
658
659			// Called once
660			if ( state === 2 ) {
661				return;
662			}
663
664			// State is "done" now
665			state = 2;
666
667			// Clear timeout if it exists
668			if ( timeoutTimer ) {
669				clearTimeout( timeoutTimer );
670			}
671
672			// Dereference transport for early garbage collection
673			// (no matter how long the jqXHR object will be used)
674			transport = undefined;
675
676			// Cache response headers
677			responseHeadersString = headers || "";
678
679			// Set readyState
680			jqXHR.readyState = status > 0 ? 4 : 0;
681
682			// Determine if successful
683			isSuccess = status >= 200 && status < 300 || status === 304;
684
685			// Get response data
686			if ( responses ) {
687				response = ajaxHandleResponses( s, jqXHR, responses );
688			}
689
690			// Convert no matter what (that way responseXXX fields are always set)
691			response = ajaxConvert( s, response, jqXHR, isSuccess );
692
693			// If successful, handle type chaining
694			if ( isSuccess ) {
695
696				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
697				if ( s.ifModified ) {
698					modified = jqXHR.getResponseHeader("Last-Modified");
699					if ( modified ) {
700						jQuery.lastModified[ cacheURL ] = modified;
701					}
702					modified = jqXHR.getResponseHeader("etag");
703					if ( modified ) {
704						jQuery.etag[ cacheURL ] = modified;
705					}
706				}
707
708				// if no content
709				if ( status === 204 || s.type === "HEAD" ) {
710					statusText = "nocontent";
711
712				// if not modified
713				} else if ( status === 304 ) {
714					statusText = "notmodified";
715
716				// If we have data, let's convert it
717				} else {
718					statusText = response.state;
719					success = response.data;
720					error = response.error;
721					isSuccess = !error;
722				}
723			} else {
724				// We extract error from statusText
725				// then normalize statusText and status for non-aborts
726				error = statusText;
727				if ( status || !statusText ) {
728					statusText = "error";
729					if ( status < 0 ) {
730						status = 0;
731					}
732				}
733			}
734
735			// Set data for the fake xhr object
736			jqXHR.status = status;
737			jqXHR.statusText = ( nativeStatusText || statusText ) + "";
738
739			// Success/Error
740			if ( isSuccess ) {
741				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
742			} else {
743				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
744			}
745
746			// Status-dependent callbacks
747			jqXHR.statusCode( statusCode );
748			statusCode = undefined;
749
750			if ( fireGlobals ) {
751				globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
752					[ jqXHR, s, isSuccess ? success : error ] );
753			}
754
755			// Complete
756			completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
757
758			if ( fireGlobals ) {
759				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
760				// Handle the global AJAX counter
761				if ( !( --jQuery.active ) ) {
762					jQuery.event.trigger("ajaxStop");
763				}
764			}
765		}
766
767		return jqXHR;
768	},
769
770	getJSON: function( url, data, callback ) {
771		return jQuery.get( url, data, callback, "json" );
772	},
773
774	getScript: function( url, callback ) {
775		return jQuery.get( url, undefined, callback, "script" );
776	}
777});
778
779jQuery.each( [ "get", "post" ], function( i, method ) {
780	jQuery[ method ] = function( url, data, callback, type ) {
781		// shift arguments if data argument was omitted
782		if ( jQuery.isFunction( data ) ) {
783			type = type || callback;
784			callback = data;
785			data = undefined;
786		}
787
788		return jQuery.ajax({
789			url: url,
790			type: method,
791			dataType: type,
792			data: data,
793			success: callback
794		});
795	};
796});
797
798// Attach a bunch of functions for handling common AJAX events
799jQuery.each( [ "ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend" ], function( i, type ) {
800	jQuery.fn[ type ] = function( fn ) {
801		return this.on( type, fn );
802	};
803});
804
805return jQuery;
806});