UNPKG

jquery/src/ajax.js

Version:
22.8 kBJavaScriptView Raw
1define( [
"./core",
"./var/document",
"./var/isFunction",
"./var/rnothtmlwhite",
"./ajax/var/location",
"./ajax/var/nonce",
"./ajax/var/rquery",
9
"./core/init",
"./core/parseXML",
"./event/trigger",
"./deferred",
"./serialize" // jQuery.param
15], function( jQuery, document, isFunction, rnothtmlwhite, location, nonce, rquery ) {
16
17"use strict";
18
19var
r20 = /%20/g,
rhash = /#.*$/,
rantiCache = /([?&])_=[^&]*/,
rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
24
// #7653, #8125, #8152: local protocol detection
rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
rnoContent = /^(?:GET|HEAD)$/,
rprotocol = /^\/\//,
29
/* Prefilters
* 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
* 2) These are called:
*    - BEFORE asking for a transport
*    - AFTER param serialization (s.data is a string if s.processData is true)
* 3) key is the dataType
* 4) the catchall symbol "*" can be used
* 5) execution will start with transport dataType and THEN continue down to "*" if needed
*/
prefilters = {},
40
/* Transports bindings
* 1) key is the dataType
* 2) the catchall symbol "*" can be used
* 3) selection will start with transport dataType and THEN go to "*" if needed
*/
transports = {},
47
// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
allTypes = "*/".concat( "*" ),
50
// Anchor tag for parsing the document origin
originAnchor = document.createElement( "a" );
originAnchor.href = location.href;
54
55// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
56function addToPrefiltersOrTransports( structure ) {
57
// dataTypeExpression is optional and defaults to "*"
return function( dataTypeExpression, func ) {
60
if ( typeof dataTypeExpression !== "string" ) {
	func = dataTypeExpression;
	dataTypeExpression = "*";
}
65
var dataType,
	i = 0,
	dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
69
if ( isFunction( func ) ) {
71
	// For each dataType in the dataTypeExpression
	while ( ( dataType = dataTypes[ i++ ] ) ) {
74
		// Prepend if requested
		if ( dataType[ 0 ] === "+" ) {
			dataType = dataType.slice( 1 ) || "*";
			( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
79
		// Otherwise append
		} else {
			( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
		}
	}
}
};
87}
88
89// Base inspection function for prefilters and transports
90function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
91
var inspected = {},
seekingTransport = ( structure === transports );
94
function inspect( dataType ) {
var selected;
inspected[ dataType ] = true;
jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
	var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
	if ( typeof dataTypeOrTransport === "string" &&
		!seekingTransport && !inspected[ dataTypeOrTransport ] ) {
102
		options.dataTypes.unshift( dataTypeOrTransport );
		inspect( dataTypeOrTransport );
		return false;
	} else if ( seekingTransport ) {
		return !( selected = dataTypeOrTransport );
	}
} );
return selected;
}
112
return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
114}
115
116// A special extend for ajax options
117// that takes "flat" options (not to be deep extended)
118// Fixes #9887
119function ajaxExtend( target, src ) {
var key, deep,
flatOptions = jQuery.ajaxSettings.flatOptions || {};
122
for ( key in src ) {
if ( src[ key ] !== undefined ) {
	( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
}
}
if ( deep ) {
jQuery.extend( true, target, deep );
}
131
return target;
133}
134
135/* Handles responses to an ajax request:
* - finds the right dataType (mediates between content-type and expected dataType)
* - returns the corresponding response
*/
139function ajaxHandleResponses( s, jqXHR, responses ) {
140
var ct, type, finalDataType, firstDataType,
contents = s.contents,
dataTypes = s.dataTypes;
144
// Remove auto dataType and get content-type in the process
while ( dataTypes[ 0 ] === "*" ) {
dataTypes.shift();
if ( ct === undefined ) {
	ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
}
}
152
// Check if we're dealing with a known content-type
if ( ct ) {
for ( type in contents ) {
	if ( contents[ type ] && contents[ type ].test( ct ) ) {
		dataTypes.unshift( type );
		break;
	}
}
}
162
// Check to see if we have a response for the expected dataType
if ( dataTypes[ 0 ] in responses ) {
finalDataType = dataTypes[ 0 ];
} else {
167
// Try convertible dataTypes
for ( type in responses ) {
	if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
		finalDataType = type;
		break;
	}
	if ( !firstDataType ) {
		firstDataType = type;
	}
}
178
// Or just use first one
finalDataType = finalDataType || firstDataType;
}
182
// If we found a dataType
// We add the dataType to the list if needed
// and return the corresponding response
if ( finalDataType ) {
if ( finalDataType !== dataTypes[ 0 ] ) {
	dataTypes.unshift( finalDataType );
}
return responses[ finalDataType ];
}
192}
193
194/* Chain conversions given the request and the original response
* Also sets the responseXXX fields on the jqXHR instance
*/
197function ajaxConvert( s, response, jqXHR, isSuccess ) {
var conv2, current, conv, tmp, prev,
converters = {},
200
// Work with a copy of dataTypes in case we need to modify it for conversion
dataTypes = s.dataTypes.slice();
203
// Create converters map with lowercased keys
if ( dataTypes[ 1 ] ) {
for ( conv in s.converters ) {
	converters[ conv.toLowerCase() ] = s.converters[ conv ];
}
}
210
current = dataTypes.shift();
212
// Convert to each sequential dataType
while ( current ) {
215
if ( s.responseFields[ current ] ) {
	jqXHR[ s.responseFields[ current ] ] = response;
}
219
// Apply the dataFilter if provided
if ( !prev && isSuccess && s.dataFilter ) {
	response = s.dataFilter( response, s.dataType );
}
224
prev = current;
current = dataTypes.shift();
227
if ( current ) {
229
	// There's only work to do if current dataType is non-auto
	if ( current === "*" ) {
232
		current = prev;
234
	// Convert response if prev dataType is non-auto and differs from current
	} else if ( prev !== "*" && prev !== current ) {
237
		// Seek a direct converter
		conv = converters[ prev + " " + current ] || converters[ "* " + current ];
240
		// If none found, seek a pair
		if ( !conv ) {
			for ( conv2 in converters ) {
244
				// If conv2 outputs current
				tmp = conv2.split( " " );
				if ( tmp[ 1 ] === current ) {
248
					// If prev can be converted to accepted input
					conv = converters[ prev + " " + tmp[ 0 ] ] ||
						converters[ "* " + tmp[ 0 ] ];
					if ( conv ) {
253
						// Condense equivalence converters
						if ( conv === true ) {
							conv = converters[ conv2 ];
257
						// Otherwise, insert the intermediate dataType
						} else if ( converters[ conv2 ] !== true ) {
							current = tmp[ 0 ];
							dataTypes.unshift( tmp[ 1 ] );
						}
						break;
					}
				}
			}
		}
268
		// Apply converter (if not an equivalence)
		if ( conv !== true ) {
271
			// Unless errors are allowed to bubble, catch and return them
			if ( conv && s.throws ) {
				response = conv( response );
			} else {
				try {
					response = conv( response );
				} catch ( e ) {
					return {
						state: "parsererror",
						error: conv ? e : "No conversion from " + prev + " to " + current
					};
				}
			}
		}
	}
}
}
289
return { state: "success", data: response };
291}
292
293jQuery.extend( {
294
// Counter for holding the number of active queries
active: 0,
297
// Last-Modified header cache for next request
lastModified: {},
etag: {},
301
ajaxSettings: {
url: location.href,
type: "GET",
isLocal: rlocalProtocol.test( location.protocol ),
global: true,
processData: true,
async: true,
contentType: "application/x-www-form-urlencoded; charset=UTF-8",
310
/*
timeout: 0,
data: null,
dataType: null,
username: null,
password: null,
cache: null,
throws: false,
traditional: false,
headers: {},
*/
322
accepts: {
	"*": allTypes,
	text: "text/plain",
	html: "text/html",
	xml: "application/xml, text/xml",
	json: "application/json, text/javascript"
},
330
contents: {
	xml: /\bxml\b/,
	html: /\bhtml/,
	json: /\bjson\b/
},
336
responseFields: {
	xml: "responseXML",
	text: "responseText",
	json: "responseJSON"
},
342
// Data converters
// Keys separate source (or catchall "*") and destination types with a single space
converters: {
346
	// Convert anything to text
	"* text": String,
349
	// Text to html (true = no transformation)
	"text html": true,
352
	// Evaluate text as a json expression
	"text json": JSON.parse,
355
	// Parse text as xml
	"text xml": jQuery.parseXML
},
359
// For options that shouldn't be deep extended:
// you can add your own custom options here if
// and when you create one that shouldn't be
// deep extended (see ajaxExtend)
flatOptions: {
	url: true,
	context: true
}
},
369
// Creates a full fledged settings object into target
// with both ajaxSettings and settings fields.
// If target is omitted, writes into ajaxSettings.
ajaxSetup: function( target, settings ) {
return settings ?
375
	// Building a settings object
	ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
378
	// Extending ajaxSettings
	ajaxExtend( jQuery.ajaxSettings, target );
},
382
ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
ajaxTransport: addToPrefiltersOrTransports( transports ),
385
// Main method
ajax: function( url, options ) {
388
// If url is an object, simulate pre-1.5 signature
if ( typeof url === "object" ) {
	options = url;
	url = undefined;
}
394
// Force options to be an object
options = options || {};
397
var transport,
399
	// URL without anti-cache param
	cacheURL,
402
	// Response headers
	responseHeadersString,
	responseHeaders,
406
	// timeout handle
	timeoutTimer,
409
	// Url cleanup var
	urlAnchor,
412
	// Request state (becomes false upon send and true upon completion)
	completed,
415
	// To know if global events are to be dispatched
	fireGlobals,
418
	// Loop variable
	i,
421
	// uncached part of the url
	uncached,
424
	// Create the final options object
	s = jQuery.ajaxSetup( {}, options ),
427
	// Callbacks context
	callbackContext = s.context || s,
430
	// Context for global events is callbackContext if it is a DOM node or jQuery collection
	globalEventContext = s.context &&
		( callbackContext.nodeType || callbackContext.jquery ) ?
			jQuery( callbackContext ) :
			jQuery.event,
436
	// Deferreds
	deferred = jQuery.Deferred(),
	completeDeferred = jQuery.Callbacks( "once memory" ),
440
	// Status-dependent callbacks
	statusCode = s.statusCode || {},
443
	// Headers (they are sent all at once)
	requestHeaders = {},
	requestHeadersNames = {},
447
	// Default abort message
	strAbort = "canceled",
450
	// Fake xhr
	jqXHR = {
		readyState: 0,
454
		// Builds headers hashtable if needed
		getResponseHeader: function( key ) {
			var match;
			if ( completed ) {
				if ( !responseHeaders ) {
					responseHeaders = {};
					while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
						responseHeaders[ match[ 1 ].toLowerCase() + " " ] =
							( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] )
								.concat( match[ 2 ] );
					}
				}
				match = responseHeaders[ key.toLowerCase() + " " ];
			}
			return match == null ? null : match.join( ", " );
		},
471
		// Raw string
		getAllResponseHeaders: function() {
			return completed ? responseHeadersString : null;
		},
476
		// Caches the header
		setRequestHeader: function( name, value ) {
			if ( completed == null ) {
				name = requestHeadersNames[ name.toLowerCase() ] =
					requestHeadersNames[ name.toLowerCase() ] || name;
				requestHeaders[ name ] = value;
			}
			return this;
		},
486
		// Overrides response content-type header
		overrideMimeType: function( type ) {
			if ( completed == null ) {
				s.mimeType = type;
			}
			return this;
		},
494
		// Status-dependent callbacks
		statusCode: function( map ) {
			var code;
			if ( map ) {
				if ( completed ) {
500
					// Execute the appropriate callbacks
					jqXHR.always( map[ jqXHR.status ] );
				} else {
504
					// Lazy-add the new callbacks in a way that preserves old ones
					for ( code in map ) {
						statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
					}
				}
			}
			return this;
		},
513
		// Cancel the request
		abort: function( statusText ) {
			var finalText = statusText || strAbort;
			if ( transport ) {
				transport.abort( finalText );
			}
			done( 0, finalText );
			return this;
		}
	};
524
// Attach deferreds
deferred.promise( jqXHR );
527
// Add protocol if not provided (prefilters might expect it)
// Handle falsy url in the settings object (#10093: consistency with old signature)
// We also use the url parameter if available
s.url = ( ( url || s.url || location.href ) + "" )
	.replace( rprotocol, location.protocol + "//" );
533
// Alias method option to type as per ticket #12004
s.type = options.method || options.type || s.method || s.type;
536
// Extract dataTypes list
s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
539
// A cross-domain request is in order when the origin doesn't match the current origin.
if ( s.crossDomain == null ) {
	urlAnchor = document.createElement( "a" );
543
	// Support: IE <=8 - 11, Edge 12 - 15
	// IE throws exception on accessing the href property if url is malformed,
	// e.g. http://example.com:80x/
	try {
		urlAnchor.href = s.url;
549
		// Support: IE <=8 - 11 only
		// Anchor's host property isn't correctly set when s.url is relative
		urlAnchor.href = urlAnchor.href;
		s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
			urlAnchor.protocol + "//" + urlAnchor.host;
	} catch ( e ) {
556
		// If there is an error parsing the URL, assume it is crossDomain,
		// it can be rejected by the transport if it is invalid
		s.crossDomain = true;
	}
}
562
// Convert data if not already a string
if ( s.data && s.processData && typeof s.data !== "string" ) {
	s.data = jQuery.param( s.data, s.traditional );
}
567
// Apply prefilters
inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
570
// If request was aborted inside a prefilter, stop there
if ( completed ) {
	return jqXHR;
}
575
// We can fire global events as of now if asked to
// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
fireGlobals = jQuery.event && s.global;
579
// Watch for a new set of requests
if ( fireGlobals && jQuery.active++ === 0 ) {
	jQuery.event.trigger( "ajaxStart" );
}
584
// Uppercase the type
s.type = s.type.toUpperCase();
587
// Determine if request has content
s.hasContent = !rnoContent.test( s.type );
590
// Save the URL in case we're toying with the If-Modified-Since
// and/or If-None-Match header later on
// Remove hash to simplify url manipulation
cacheURL = s.url.replace( rhash, "" );
595
// More options handling for requests with no content
if ( !s.hasContent ) {
598
	// Remember the hash so we can put it back
	uncached = s.url.slice( cacheURL.length );
601
	// If data is available and should be processed, append data to url
	if ( s.data && ( s.processData || typeof s.data === "string" ) ) {
		cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
605
		// #9682: remove data so that it's not used in an eventual retry
		delete s.data;
	}
609
	// Add or update anti-cache param if needed
	if ( s.cache === false ) {
		cacheURL = cacheURL.replace( rantiCache, "$1" );
		uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) +
			uncached;
	}
616
	// Put hash and anti-cache on the URL that will be requested (gh-1732)
	s.url = cacheURL + uncached;
619
// Change '%20' to '+' if this is encoded form body content (gh-2658)
} else if ( s.data && s.processData &&
	( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
	s.data = s.data.replace( r20, "+" );
}
625
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
if ( s.ifModified ) {
	if ( jQuery.lastModified[ cacheURL ] ) {
		jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
	}
	if ( jQuery.etag[ cacheURL ] ) {
		jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
	}
}
635
// Set the correct header, if data is being sent
if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
	jqXHR.setRequestHeader( "Content-Type", s.contentType );
}
640
// Set the Accepts header for the server, depending on the dataType
jqXHR.setRequestHeader(
	"Accept",
	s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
		s.accepts[ s.dataTypes[ 0 ] ] +
			( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
		s.accepts[ "*" ]
);
649
// Check for headers option
for ( i in s.headers ) {
	jqXHR.setRequestHeader( i, s.headers[ i ] );
}
654
// Allow custom headers/mimetypes and early abort
if ( s.beforeSend &&
	( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
658
	// Abort if not done already and return
	return jqXHR.abort();
}
662
// Aborting is no longer a cancellation
strAbort = "abort";
665
// Install callbacks on deferreds
completeDeferred.add( s.complete );
jqXHR.done( s.success );
jqXHR.fail( s.error );
670
// Get transport
transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
673
// If no transport, we auto-abort
if ( !transport ) {
	done( -1, "No Transport" );
} else {
	jqXHR.readyState = 1;
679
	// Send global event
	if ( fireGlobals ) {
		globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
	}
684
	// If request was aborted inside ajaxSend, stop there
	if ( completed ) {
		return jqXHR;
	}
689
	// Timeout
	if ( s.async && s.timeout > 0 ) {
		timeoutTimer = window.setTimeout( function() {
			jqXHR.abort( "timeout" );
		}, s.timeout );
	}
696
	try {
		completed = false;
		transport.send( requestHeaders, done );
	} catch ( e ) {
701
		// Rethrow post-completion exceptions
		if ( completed ) {
			throw e;
		}
706
		// Propagate others as results
		done( -1, e );
	}
}
711
// Callback for when everything is done
function done( status, nativeStatusText, responses, headers ) {
	var isSuccess, success, error, response, modified,
		statusText = nativeStatusText;
716
	// Ignore repeat invocations
	if ( completed ) {
		return;
	}
721
	completed = true;
723
	// Clear timeout if it exists
	if ( timeoutTimer ) {
		window.clearTimeout( timeoutTimer );
	}
728
	// Dereference transport for early garbage collection
	// (no matter how long the jqXHR object will be used)
	transport = undefined;
732
	// Cache response headers
	responseHeadersString = headers || "";
735
	// Set readyState
	jqXHR.readyState = status > 0 ? 4 : 0;
738
	// Determine if successful
	isSuccess = status >= 200 && status < 300 || status === 304;
741
	// Get response data
	if ( responses ) {
		response = ajaxHandleResponses( s, jqXHR, responses );
	}
746
	// Use a noop converter for missing script
	if ( !isSuccess && jQuery.inArray( "script", s.dataTypes ) > -1 ) {
		s.converters[ "text script" ] = function() {};
	}
751
	// Convert no matter what (that way responseXXX fields are always set)
	response = ajaxConvert( s, response, jqXHR, isSuccess );
754
	// If successful, handle type chaining
	if ( isSuccess ) {
757
		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
		if ( s.ifModified ) {
			modified = jqXHR.getResponseHeader( "Last-Modified" );
			if ( modified ) {
				jQuery.lastModified[ cacheURL ] = modified;
			}
			modified = jqXHR.getResponseHeader( "etag" );
			if ( modified ) {
				jQuery.etag[ cacheURL ] = modified;
			}
		}
769
		// if no content
		if ( status === 204 || s.type === "HEAD" ) {
			statusText = "nocontent";
773
		// if not modified
		} else if ( status === 304 ) {
			statusText = "notmodified";
777
		// If we have data, let's convert it
		} else {
			statusText = response.state;
			success = response.data;
			error = response.error;
			isSuccess = !error;
		}
	} else {
786
		// Extract error from statusText and normalize for non-aborts
		error = statusText;
		if ( status || !statusText ) {
			statusText = "error";
			if ( status < 0 ) {
				status = 0;
			}
		}
	}
796
	// Set data for the fake xhr object
	jqXHR.status = status;
	jqXHR.statusText = ( nativeStatusText || statusText ) + "";
800
	// Success/Error
	if ( isSuccess ) {
		deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
	} else {
		deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
	}
807
	// Status-dependent callbacks
	jqXHR.statusCode( statusCode );
	statusCode = undefined;
811
	if ( fireGlobals ) {
		globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
			[ jqXHR, s, isSuccess ? success : error ] );
	}
816
	// Complete
	completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
819
	if ( fireGlobals ) {
		globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
822
		// Handle the global AJAX counter
		if ( !( --jQuery.active ) ) {
			jQuery.event.trigger( "ajaxStop" );
		}
	}
}
829
return jqXHR;
},
832
getJSON: function( url, data, callback ) {
return jQuery.get( url, data, callback, "json" );
},
836
getScript: function( url, callback ) {
return jQuery.get( url, undefined, callback, "script" );
}
840} );
841
842jQuery.each( [ "get", "post" ], function( _i, method ) {
jQuery[ method ] = function( url, data, callback, type ) {
844
// Shift arguments if data argument was omitted
if ( isFunction( data ) ) {
	type = type || callback;
	callback = data;
	data = undefined;
}
851
// The url can be an options object (which then must have .url)
return jQuery.ajax( jQuery.extend( {
	url: url,
	type: method,
	dataType: type,
	data: data,
	success: callback
}, jQuery.isPlainObject( url ) && url ) );
};
861} );
862
863jQuery.ajaxPrefilter( function( s ) {
var i;
for ( i in s.headers ) {
if ( i.toLowerCase() === "content-type" ) {
	s.contentType = s.headers[ i ] || "";
}
}
870} );
871
872return jQuery;
873} );
1	`define( [`
2	`"./core",`
3	`"./var/document",`
4	`"./var/isFunction",`
5	`"./var/rnothtmlwhite",`
6	`"./ajax/var/location",`
7	`"./ajax/var/nonce",`
8	`"./ajax/var/rquery",`
9
10	`"./core/init",`
11	`"./core/parseXML",`
12	`"./event/trigger",`
13	`"./deferred",`
14	`"./serialize" // jQuery.param`
15	`], function( jQuery, document, isFunction, rnothtmlwhite, location, nonce, rquery ) {`
16
17	`"use strict";`
18
19	`var`
20	`r20 = /%20/g,`
21	`rhash = /#.*$/,`
22	`rantiCache = /([?&])_=[^&]*/,`
23	`rheaders = /^(.?):[ \t]([^\r\n]*)$/mg,`
24
25	`// #7653, #8125, #8152: local protocol detection`
26	`rlocalProtocol = /^(?:about\|app\|app-storage\|.+-extension\|file\|res\|widget):$/,`
27	`rnoContent = /^(?:GET\|HEAD)$/,`
28	`rprotocol = /^\/\//,`
29
30	`/* Prefilters`
31	`* 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)`
32	`* 2) These are called:`
33	`* - BEFORE asking for a transport`
34	`* - AFTER param serialization (s.data is a string if s.processData is true)`
35	`* 3) key is the dataType`
36	`* 4) the catchall symbol "*" can be used`
37	`* 5) execution will start with transport dataType and THEN continue down to "*" if needed`
38	`*/`
39	`prefilters = {},`
40