+ // Force options to be an object
+ options = options || {};
+
+ var // Create the final options object
+ s = jQuery.extend( true , {} , jQuery.ajaxSettings , options ),
+ // jQuery lists
+ jQuery_lastModified = jQuery.lastModified,
+ jQuery_etag = jQuery.etag,
+ // Callbacks contexts
+ // We force the original context if it exists
+ // or take it from jQuery.ajaxSettings otherwise
+ // (plain objects used as context get extended)
+ callbackContext =
+ ( s.context = ( "context" in options ? options : jQuery.ajaxSettings ).context ) || s,
+ globalEventContext = callbackContext === s ? jQuery.event : jQuery( callbackContext ),
+ // Deferreds
+ deferred = jQuery.Deferred(),
+ completeDeferred = jQuery._Deferred(),
+ // Status-dependent callbacks
+ statusCode = s.statusCode || {},
+ // Headers (they are sent all at once)
+ requestHeaders = {},
+ // Response headers
+ responseHeadersString,
+ responseHeaders,
+ // transport
+ transport,
+ // timeout handle
+ timeoutTimer,
+ // Cross-domain detection vars
+ loc = document.location,
+ protocol = loc.protocol || "http:",
+ parts,
+ // The jXHR state
+ state = 0,
+ // Loop variable
+ i,
+ // Fake xhr
+ jXHR = {
+
+ readyState: 0,
+
+ // Caches the header
+ setRequestHeader: function(name,value) {
+ if ( state === 0 ) {
+ requestHeaders[ name.toLowerCase() ] = value;
+ }
+ return this;
+ },
+
+ // Raw string
+ getAllResponseHeaders: function() {
+ return state === 2 ? responseHeadersString : null;
+ },
+
+ // Builds headers hashtable if needed
+ getResponseHeader: function( key ) {
+
+ var match;
+
+ if ( state === 2 ) {
+
+ if ( !responseHeaders ) {
+
+ responseHeaders = {};
+
+ while( ( match = rheaders.exec( responseHeadersString ) ) ) {
+ responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
+ }
+ }
+ match = responseHeaders[ key.toLowerCase() ];
+
+ }
+
+ return match || null;
+ },
+
+ // Cancel the request
+ abort: function( statusText ) {
+ if ( transport ) {
+ transport.abort( statusText || "abort" );
+ }
+ done( 0 , statusText );
+ return this;
+ }
+ };
+
+ // Callback for when everything is done
+ // It is defined here because jslint complains if it is declared
+ // at the end of the function (which would be more logical and readable)
+ function done( status , statusText , responses , headers) {
+
+ // Called once
+ if ( state === 2 ) {
+ return;
+ }
+
+ // State is "done" now
+ state = 2;
+
+ // Dereference transport for early garbage collection
+ // (no matter how long the jXHR object will be used)
+ transport = undefined;
+
+ // Set readyState
+ jXHR.readyState = status ? 4 : 0;
+
+ // Cache response headers
+ responseHeadersString = headers || "";
+
+ // Clear timeout if it exists
+ if ( timeoutTimer ) {
+ clearTimeout(timeoutTimer);
+ }
+
+ var // Reference dataTypes and responseFields
+ dataTypes = s.dataTypes,
+ responseFields = s.responseFields,
+ responseField,
+
+ // Flag to mark as success
+ isSuccess,
+ // Stored success
+ success,
+ // Stored error
+ error,
+
+ // To keep track of statusCode based callbacks
+ oldStatusCode,
+
+ // Actual response
+ response;
+
+ // If we got responses:
+ // - find the right one
+ // - update dataTypes accordingly
+ // - set responseXXX accordingly too
+ if ( responses ) {
+
+ var contents = s.contents,
+ transportDataType = dataTypes[0],
+ ct,
+ type,
+ finalDataType;
+
+ // Auto (xml, json, script or text determined given headers)
+ if ( transportDataType === "*" && ( ct = jXHR.getResponseHeader( "content-type" ) ) ) {
+
+ for ( type in contents ) {
+ if ( contents[ type ] && contents[ type ].test( ct ) ) {
+ transportDataType = dataTypes[0] = type;
+ break;
+ }
+ }
+
+ type = undefined;
+ }
+
+ // Get final dataType
+ for( type in responses ) {
+ if ( ! finalDataType && type === transportDataType ) {
+ finalDataType = type;
+ }
+ responseField = responseFields[ type ];
+ if ( responseField && ! ( responseField in jXHR ) ) {
+ jXHR[ responseField ] = responses[ type ];
+ }
+ }
+
+ // If no response with the expected dataType was provided
+ // Take the last response as a default if it exists
+ if ( ! finalDataType && type ) {
+ finalDataType = type;
+ if ( transportDataType === "*" ) {
+ dataTypes.shift();
+ }
+ dataTypes.unshift( finalDataType );
+ }
+
+ // Get final response
+ response = responses[ finalDataType ];
+ }
+
+ // If successful, handle type chaining
+ if ( status >= 200 && status < 300 || status === 304 ) {
+
+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+ if ( s.ifModified ) {
+
+ var lastModified = jXHR.getResponseHeader("Last-Modified"),
+ etag = jXHR.getResponseHeader("Etag");
+
+ if (lastModified) {
+ jQuery_lastModified[ s.url ] = lastModified;
+ }
+ if (etag) {
+ jQuery_etag[ s.url ] = etag;
+ }
+ }
+
+ // If not modified
+ if ( status === 304 ) {
+
+ statusText = "notmodified";
+ isSuccess = 1;
+
+ // If we have data
+ } else {
+
+ statusText = "success";
+
+ // Chain data conversions and determine the final value
+ // (if an exception is thrown in the process, it'll be notified as an error)
+ try {
+
+ var i,
+ // Current dataType
+ current,
+ // Previous dataType
+ prev,
+ // Conversion expression
+ conversion,
+ // Conversion function
+ conv,
+ // Conversion functions (when text is used in-between)
+ conv1,
+ conv2,
+ // Local references to converters
+ converters = s.converters;
+
+ // For each dataType in the chain
+ for( i = 0 ; i < dataTypes.length ; i++ ) {
+
+ current = dataTypes[ i ];
+
+ // If a responseXXX field for this dataType exists
+ // and if it hasn't been set yet
+ responseField = responseFields[ current ];
+ if ( responseField && ! ( responseField in jXHR ) ) {
+ jXHR[ responseField ] = response;
+ }
+
+ // If this is not the first element
+ if ( i ) {
+
+ // Get the dataType to convert from
+ prev = dataTypes[ i - 1 ];
+
+ // If no catch-all and dataTypes are actually different
+ if ( prev !== "*" && current !== "*" && prev !== current ) {
+
+ // Get the converter
+ conversion = prev + " " + current;
+ conv = converters[ conversion ] || converters[ "* " + current ];
+
+ conv1 = conv2 = 0;
+
+ // If there is no direct converter and none of the dataTypes is text
+ if ( ! conv && prev !== "text" && current !== "text" ) {
+ // Try with text in-between
+ conv1 = converters[ prev + " text" ] || converters[ "* text" ];
+ conv2 = converters[ "text " + current ];
+ // Revert back to a single converter
+ // if one of the converter is an equivalence
+ if ( conv1 === true ) {
+ conv = conv2;
+ } else if ( conv2 === true ) {
+ conv = conv1;
+ }
+ }
+ // If we found no converter, dispatch an error
+ if ( ! ( conv || conv1 && conv2 ) ) {
+ throw conversion;
+ }
+ // If found converter is not an equivalence
+ if ( conv !== true ) {
+ // Convert with 1 or 2 converters accordingly
+ response = conv ? conv( response ) : conv2( conv1( response ) );
+ }
+ }
+ // If it is the first element of the chain
+ // and we have a dataFilter
+ } else if ( s.dataFilter ) {
+ // Apply the dataFilter
+ response = s.dataFilter( response , current );
+ // Get dataTypes again in case the filter changed them
+ dataTypes = s.dataTypes;
+ }
+ }
+ // End of loop
+
+ // We have a real success
+ success = response;
+ isSuccess = 1;
+
+ // If an exception was thrown
+ } catch(e) {
+
+ // We have a parsererror
+ statusText = "parsererror";
+ error = "" + e;
+
+ }
+ }
+
+ // if not success, mark it as an error
+ } else {
+ error = statusText = statusText || "error";
+ }
+
+ // Set data for the fake xhr object
+ jXHR.status = status;
+ jXHR.statusText = statusText;
+
+ // Success/Error
+ if ( isSuccess ) {
+ deferred.resolveWith( callbackContext , [ success , statusText , jXHR ] );
+ } else {
+ deferred.rejectWith( callbackContext , [ jXHR , statusText , error ] );
+ }
+
+ // Status-dependent callbacks
+ oldStatusCode = statusCode;
+ statusCode = undefined;
+ jXHR.statusCode( oldStatusCode );
+
+ if ( s.global ) {
+ globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ) ,
+ [ jXHR , s , isSuccess ? success : error ] );
+ }
+
+ // Complete
+ completeDeferred.resolveWith( callbackContext, [ jXHR , statusText ] );
+
+ if ( s.global ) {
+ globalEventContext.trigger( "ajaxComplete" , [ jXHR , s] );
+ // Handle the global AJAX counter
+ if ( ! --jQuery.active ) {
+ jQuery.event.trigger( "ajaxStop" );
+ }
+ }
+ }