define( [

"./core",
"./var/document",
"./var/rnothtmlwhite",
"./ajax/var/location",
"./ajax/var/nonce",
"./ajax/var/rquery",

"./core/init",
"./ajax/parseXML",
"./event/trigger",
"./deferred",
"./serialize" // jQuery.param

], function( jQuery, document, rnothtmlwhite, location, nonce, rquery ) {

“use strict”;

var

r20 = /%20/g,
rhash = /#.*$/,
rantiCache = /([?&])_=[^&]*/,
rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,

// #7653, #8125, #8152: local protocol detection
rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
rnoContent = /^(?:GET|HEAD)$/,
rprotocol = /^\/\//,

/* 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 = {},

/* 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 = {},

// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
allTypes = "*/".concat( "*" ),

// Anchor tag for parsing the document origin
originAnchor = document.createElement( "a" );
originAnchor.href = location.href;

// Base “constructor” for jQuery.ajaxPrefilter and jQuery.ajaxTransport function addToPrefiltersOrTransports( structure ) {

// dataTypeExpression is optional and defaults to "*"
return function( dataTypeExpression, func ) {

        if ( typeof dataTypeExpression !== "string" ) {
                func = dataTypeExpression;
                dataTypeExpression = "*";
        }

        var dataType,
                i = 0,
                dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];

        if ( jQuery.isFunction( func ) ) {

                // For each dataType in the dataTypeExpression
                while ( ( dataType = dataTypes[ i++ ] ) ) {

                        // Prepend if requested
                        if ( dataType[ 0 ] === "+" ) {
                                dataType = dataType.slice( 1 ) || "*";
                                ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );

                        // Otherwise append
                        } else {
                                ( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
                        }
                }
        }
};

}

// Base inspection function for prefilters and transports function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {

var inspected = {},
        seekingTransport = ( structure === transports );

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 ] ) {

                        options.dataTypes.unshift( dataTypeOrTransport );
                        inspect( dataTypeOrTransport );
                        return false;
                } else if ( seekingTransport ) {
                        return !( selected = dataTypeOrTransport );
                }
        } );
        return selected;
}

return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );

}

// A special extend for ajax options // that takes “flat” options (not to be deep extended) // Fixes #9887 function ajaxExtend( target, src ) {

var key, deep,
        flatOptions = jQuery.ajaxSettings.flatOptions || {};

for ( key in src ) {
        if ( src[ key ] !== undefined ) {
                ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
        }
}
if ( deep ) {
        jQuery.extend( true, target, deep );
}

return target;

}

/* Handles responses to an ajax request:

* - finds the right dataType (mediates between content-type and expected dataType)
* - returns the corresponding response
*/

function ajaxHandleResponses( s, jqXHR, responses ) {

var ct, type, finalDataType, firstDataType,
        contents = s.contents,
        dataTypes = s.dataTypes;

// 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" );
        }
}

// 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;
                }
        }
}

// Check to see if we have a response for the expected dataType
if ( dataTypes[ 0 ] in responses ) {
        finalDataType = dataTypes[ 0 ];
} else {

        // Try convertible dataTypes
        for ( type in responses ) {
                if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
                        finalDataType = type;
                        break;
                }
                if ( !firstDataType ) {
                        firstDataType = type;
                }
        }

        // Or just use first one
        finalDataType = finalDataType || firstDataType;
}

// 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 ];
}

}

/* Chain conversions given the request and the original response

* Also sets the responseXXX fields on the jqXHR instance
*/

function ajaxConvert( s, response, jqXHR, isSuccess ) {

var conv2, current, conv, tmp, prev,
        converters = {},

        // Work with a copy of dataTypes in case we need to modify it for conversion
        dataTypes = s.dataTypes.slice();

// Create converters map with lowercased keys
if ( dataTypes[ 1 ] ) {
        for ( conv in s.converters ) {
                converters[ conv.toLowerCase() ] = s.converters[ conv ];
        }
}

current = dataTypes.shift();

// Convert to each sequential dataType
while ( current ) {

        if ( s.responseFields[ current ] ) {
                jqXHR[ s.responseFields[ current ] ] = response;
        }

        // Apply the dataFilter if provided
        if ( !prev && isSuccess && s.dataFilter ) {
                response = s.dataFilter( response, s.dataType );
        }

        prev = current;
        current = dataTypes.shift();

        if ( current ) {

                // There's only work to do if current dataType is non-auto
                if ( current === "*" ) {

                        current = prev;

                // Convert response if prev dataType is non-auto and differs from current
                } else if ( prev !== "*" && prev !== current ) {

                        // Seek a direct converter
                        conv = converters[ prev + " " + current ] || converters[ "* " + current ];

                        // If none found, seek a pair
                        if ( !conv ) {
                                for ( conv2 in converters ) {

                                        // If conv2 outputs current
                                        tmp = conv2.split( " " );
                                        if ( tmp[ 1 ] === current ) {

                                                // If prev can be converted to accepted input
                                                conv = converters[ prev + " " + tmp[ 0 ] ] ||
                                                        converters[ "* " + tmp[ 0 ] ];
                                                if ( conv ) {

                                                        // Condense equivalence converters
                                                        if ( conv === true ) {
                                                                conv = converters[ conv2 ];

                                                        // Otherwise, insert the intermediate dataType
                                                        } else if ( converters[ conv2 ] !== true ) {
                                                                current = tmp[ 0 ];
                                                                dataTypes.unshift( tmp[ 1 ] );
                                                        }
                                                        break;
                                                }
                                        }
                                }
                        }

                        // Apply converter (if not an equivalence)
                        if ( conv !== true ) {

                                // 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
                                                };
                                        }
                                }
                        }
                }
        }
}

return { state: "success", data: response };

}

jQuery.extend( {

// Counter for holding the number of active queries
active: 0,

// Last-Modified header cache for next request
lastModified: {},
etag: {},

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",

        /*
        timeout: 0,
        data: null,
        dataType: null,
        username: null,
        password: null,
        cache: null,
        throws: false,
        traditional: false,
        headers: {},
        */

        accepts: {
                "*": allTypes,
                text: "text/plain",
                html: "text/html",
                xml: "application/xml, text/xml",
                json: "application/json, text/javascript"
        },

        contents: {
                xml: /\bxml\b/,
                html: /\bhtml/,
                json: /\bjson\b/
        },

        responseFields: {
                xml: "responseXML",
                text: "responseText",
                json: "responseJSON"
        },

        // Data converters
        // Keys separate source (or catchall "*") and destination types with a single space
        converters: {

                // Convert anything to text
                "* text": String,

                // Text to html (true = no transformation)
                "text html": true,

                // Evaluate text as a json expression
                "text json": JSON.parse,

                // Parse text as xml
                "text xml": jQuery.parseXML
        },

        // 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
        }
},

// 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 ?

                // Building a settings object
                ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :

                // Extending ajaxSettings
                ajaxExtend( jQuery.ajaxSettings, target );
},

ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
ajaxTransport: addToPrefiltersOrTransports( transports ),

// Main method
ajax: function( url, options ) {

        // If url is an object, simulate pre-1.5 signature
        if ( typeof url === "object" ) {
                options = url;
                url = undefined;
        }

        // Force options to be an object
        options = options || {};

        var transport,

                // URL without anti-cache param
                cacheURL,

                // Response headers
                responseHeadersString,
                responseHeaders,

                // timeout handle
                timeoutTimer,

                // Url cleanup var
                urlAnchor,

                // Request state (becomes false upon send and true upon completion)
                completed,

                // To know if global events are to be dispatched
                fireGlobals,

                // Loop variable
                i,

                // uncached part of the url
                uncached,

                // Create the final options object
                s = jQuery.ajaxSetup( {}, options ),

                // Callbacks context
                callbackContext = s.context || s,

                // 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,

                // Deferreds
                deferred = jQuery.Deferred(),
                completeDeferred = jQuery.Callbacks( "once memory" ),

                // Status-dependent callbacks
                statusCode = s.statusCode || {},

                // Headers (they are sent all at once)
                requestHeaders = {},
                requestHeadersNames = {},

                // Default abort message
                strAbort = "canceled",

                // Fake xhr
                jqXHR = {
                        readyState: 0,

                        // Builds headers hashtable if needed
                        getResponseHeader: function( key ) {
                                var match;
                                if ( completed ) {
                                        if ( !responseHeaders ) {
                                                responseHeaders = {};
                                                while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
                                                        responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
                                                }
                                        }
                                        match = responseHeaders[ key.toLowerCase() ];
                                }
                                return match == null ? null : match;
                        },

                        // Raw string
                        getAllResponseHeaders: function() {
                                return completed ? responseHeadersString : null;
                        },

                        // Caches the header
                        setRequestHeader: function( name, value ) {
                                if ( completed == null ) {
                                        name = requestHeadersNames[ name.toLowerCase() ] =
                                                requestHeadersNames[ name.toLowerCase() ] || name;
                                        requestHeaders[ name ] = value;
                                }
                                return this;
                        },

                        // Overrides response content-type header
                        overrideMimeType: function( type ) {
                                if ( completed == null ) {
                                        s.mimeType = type;
                                }
                                return this;
                        },

                        // Status-dependent callbacks
                        statusCode: function( map ) {
                                var code;
                                if ( map ) {
                                        if ( completed ) {

                                                // Execute the appropriate callbacks
                                                jqXHR.always( map[ jqXHR.status ] );
                                        } else {

                                                // Lazy-add the new callbacks in a way that preserves old ones
                                                for ( code in map ) {
                                                        statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
                                                }
                                        }
                                }
                                return this;
                        },

                        // Cancel the request
                        abort: function( statusText ) {
                                var finalText = statusText || strAbort;
                                if ( transport ) {
                                        transport.abort( finalText );
                                }
                                done( 0, finalText );
                                return this;
                        }
                };

        // Attach deferreds
        deferred.promise( jqXHR );

        // 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 + "//" );

        // Alias method option to type as per ticket #12004
        s.type = options.method || options.type || s.method || s.type;

        // Extract dataTypes list
        s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];

        // A cross-domain request is in order when the origin doesn't match the current origin.
        if ( s.crossDomain == null ) {
                urlAnchor = document.createElement( "a" );

                // Support: IE <=8 - 11, Edge 12 - 13
                // IE throws exception on accessing the href property if url is malformed,
                // e.g. http://example.com:80x/
                try {
                        urlAnchor.href = s.url;

                        // 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 ) {

                        // 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;
                }
        }

        // Convert data if not already a string
        if ( s.data && s.processData && typeof s.data !== "string" ) {
                s.data = jQuery.param( s.data, s.traditional );
        }

        // Apply prefilters
        inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );

        // If request was aborted inside a prefilter, stop there
        if ( completed ) {
                return jqXHR;
        }

        // 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;

        // Watch for a new set of requests
        if ( fireGlobals && jQuery.active++ === 0 ) {
                jQuery.event.trigger( "ajaxStart" );
        }

        // Uppercase the type
        s.type = s.type.toUpperCase();

        // Determine if request has content
        s.hasContent = !rnoContent.test( s.type );

        // 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, "" );

        // More options handling for requests with no content
        if ( !s.hasContent ) {

                // Remember the hash so we can put it back
                uncached = s.url.slice( cacheURL.length );

                // If data is available, append data to url
                if ( s.data ) {
                        cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;

                        // #9682: remove data so that it's not used in an eventual retry
                        delete s.data;
                }

                // Add or update anti-cache param if needed
                if ( s.cache === false ) {
                        cacheURL = cacheURL.replace( rantiCache, "$1" );
                        uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached;
                }

                // Put hash and anti-cache on the URL that will be requested (gh-1732)
                s.url = cacheURL + uncached;

        // 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, "+" );
        }

        // 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 ] );
                }
        }

        // 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 );
        }

        // 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[ "*" ]
        );

        // Check for headers option
        for ( i in s.headers ) {
                jqXHR.setRequestHeader( i, s.headers[ i ] );
        }

        // Allow custom headers/mimetypes and early abort
        if ( s.beforeSend &&
                ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {

                // Abort if not done already and return
                return jqXHR.abort();
        }

        // Aborting is no longer a cancellation
        strAbort = "abort";

        // Install callbacks on deferreds
        completeDeferred.add( s.complete );
        jqXHR.done( s.success );
        jqXHR.fail( s.error );

        // Get transport
        transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );

        // If no transport, we auto-abort
        if ( !transport ) {
                done( -1, "No Transport" );
        } else {
                jqXHR.readyState = 1;

                // Send global event
                if ( fireGlobals ) {
                        globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
                }

                // If request was aborted inside ajaxSend, stop there
                if ( completed ) {
                        return jqXHR;
                }

                // Timeout
                if ( s.async && s.timeout > 0 ) {
                        timeoutTimer = window.setTimeout( function() {
                                jqXHR.abort( "timeout" );
                        }, s.timeout );
                }

                try {
                        completed = false;
                        transport.send( requestHeaders, done );
                } catch ( e ) {

                        // Rethrow post-completion exceptions
                        if ( completed ) {
                                throw e;
                        }

                        // Propagate others as results
                        done( -1, e );
                }
        }

        // Callback for when everything is done
        function done( status, nativeStatusText, responses, headers ) {
                var isSuccess, success, error, response, modified,
                        statusText = nativeStatusText;

                // Ignore repeat invocations
                if ( completed ) {
                        return;
                }

                completed = true;

                // Clear timeout if it exists
                if ( timeoutTimer ) {
                        window.clearTimeout( timeoutTimer );
                }

                // Dereference transport for early garbage collection
                // (no matter how long the jqXHR object will be used)
                transport = undefined;

                // Cache response headers
                responseHeadersString = headers || "";

                // Set readyState
                jqXHR.readyState = status > 0 ? 4 : 0;

                // Determine if successful
                isSuccess = status >= 200 && status < 300 || status === 304;

                // Get response data
                if ( responses ) {
                        response = ajaxHandleResponses( s, jqXHR, responses );
                }

                // Convert no matter what (that way responseXXX fields are always set)
                response = ajaxConvert( s, response, jqXHR, isSuccess );

                // If successful, handle type chaining
                if ( isSuccess ) {

                        // 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;
                                }
                        }

                        // if no content
                        if ( status === 204 || s.type === "HEAD" ) {
                                statusText = "nocontent";

                        // if not modified
                        } else if ( status === 304 ) {
                                statusText = "notmodified";

                        // If we have data, let's convert it
                        } else {
                                statusText = response.state;
                                success = response.data;
                                error = response.error;
                                isSuccess = !error;
                        }
                } else {

                        // Extract error from statusText and normalize for non-aborts
                        error = statusText;
                        if ( status || !statusText ) {
                                statusText = "error";
                                if ( status < 0 ) {
                                        status = 0;
                                }
                        }
                }

                // Set data for the fake xhr object
                jqXHR.status = status;
                jqXHR.statusText = ( nativeStatusText || statusText ) + "";

                // Success/Error
                if ( isSuccess ) {
                        deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
                } else {
                        deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
                }

                // Status-dependent callbacks
                jqXHR.statusCode( statusCode );
                statusCode = undefined;

                if ( fireGlobals ) {
                        globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
                                [ jqXHR, s, isSuccess ? success : error ] );
                }

                // Complete
                completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );

                if ( fireGlobals ) {
                        globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );

                        // Handle the global AJAX counter
                        if ( !( --jQuery.active ) ) {
                                jQuery.event.trigger( "ajaxStop" );
                        }
                }
        }

        return jqXHR;
},

getJSON: function( url, data, callback ) {
        return jQuery.get( url, data, callback, "json" );
},

getScript: function( url, callback ) {
        return jQuery.get( url, undefined, callback, "script" );
}

} );

jQuery.each( [ “get”, “post” ], function( i, method ) {

jQuery[ method ] = function( url, data, callback, type ) {

        // Shift arguments if data argument was omitted
        if ( jQuery.isFunction( data ) ) {
                type = type || callback;
                callback = data;
                data = undefined;
        }

        // 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 ) );
};

} );

return jQuery; } );