webshims-rails 1.12.3 → 1.12.5

data/vendor/assets/javascripts/webshims/shims/form-validation.js

@@ -110,11 +110,9 @@ webshims.register('form-validation', function($, webshims, window, document, und
 				){
 					return;
 			}
-			if(webshims.refreshCustomValidityRules){
-				if(webshims.refreshCustomValidityRules(elem) == 'async'){
-					$(elem).one('refreshvalidityui', switchValidityClass);
-					return;
-				}
+			if(webshims.refreshCustomValidityRules && webshims.refreshCustomValidityRules(elem) == 'async'){
+				$(elem).one('refreshvalidityui', switchValidityClass);
+				return;
 			}
 			
 			var validity = $.prop(elem, 'validity');
@@ -663,7 +661,7 @@ webshims.register('form-validation', function($, webshims, window, document, und
 			check();
 		},
 		hideError: function(elem, reset){
-			var invalid, errorBox;
+			var invalid, errorBox, afterHide;
 			var fieldWrapper = this.getFieldWrapper(elem);
 
 			if(fieldWrapper.hasClass(invalidWrapperClass)){
@@ -674,12 +672,17 @@ webshims.register('form-validation', function($, webshims, window, document, und
 					errorBox = this.get(elem, fieldWrapper);
 					fieldWrapper.removeClass(invalidWrapperClass);
 					errorBox.message = '';
-					errorBox[fx[iVal.fx].hide](function(){
+					afterHide = function(){
 						if(this.id == elem.getAttribute('aria-describedby')){
 							elem.removeAttribute('aria-describedby');
 						}
 						$(this).attr({hidden: 'hidden'});
-					});
+					};
+					if(iVal.fx != 'no'){
+						errorBox[fx[iVal.fx].hide](afterHide);
+					} else {
+						errorBox[fx[iVal.fx].hide]().each(afterHide);
+					}
 				}
 				
 			}
@@ -779,7 +782,7 @@ webshims.register('form-validation', function($, webshims, window, document, und
 				}
 			},
 			submit: function(e){
-				if(iVal.sel && iVal.submitCheck &&$(e.target).is(iVal.sel) && $.prop(e.target, 'noValidate') && !$(e.target).checkValidity()){
+				if(iVal.sel && iVal.submitCheck && $(e.target).is(iVal.sel) && $.prop(e.target, 'noValidate') && !$(e.target).checkValidity()){
 					e.stopImmediatePropagation();
 					return false;
 				}

data/vendor/assets/javascripts/webshims/shims/form-validators.js

@@ -93,6 +93,18 @@ webshims.register('form-validators', function($, webshims, window, document, und
 		return message;
 	};
 	var testValidityRules = webshims.refreshCustomValidityRules;
+
+	if(typeof document.activeElement != 'unknown'){
+		$('body').on('click', function(e){
+			if(e.target.type == 'submit'){
+				var activeElement = document.activeElement;
+
+				if(activeElement != e.target && $.data(activeElement, 'webshimsswitchvalidityclass')){
+					$(activeElement).trigger('refreshvalidityui');
+				}
+			}
+		});
+	}
 	
 	webshims.ready('forms form-validation', function(){
 		
@@ -264,12 +276,10 @@ webshims.register('form-validators', function($, webshims, window, document, und
 				$(data.masterElement.type === 'radio' && getGroupElements(data.masterElement) || data.masterElement).on('change', depFn);
 			} else {
 				$(data.masterElement).on('change', function(){
+					webshims.refreshCustomValidityRules(elem);
 					$(elem)
 						.getShadowElement()
 						.filter('.user-error, .user-success')
-						.each(function(){
-							webshims.refreshCustomValidityRules(elem);
-						})
 						.trigger('refreshvalidityui')
 					;
 				});
@@ -284,8 +294,14 @@ webshims.register('form-validators', function($, webshims, window, document, und
 		}
 		
 	}, 'The value of this field does not repeat the value of the other field');
-	
-	
+
+	addCustomValidityRule('valuevalidation', function(elem, val, data){
+		if(val && ('valuevalidation' in data)){
+			//Todo allow markup params
+			return $(elem).triggerHandler('valuevalidation', [{value: val, valueAsDate: $.prop(elem, 'valueAsDate'), isPartial: false}]) || '';
+		}
+	}, 'This value is not allowed here');
+
 	if(window.JSON){
 		addCustomValidityRule('ajaxvalidate', function(elem, val, data){
 			if(!val || !data.ajaxvalidate){return;}

data/vendor/assets/javascripts/webshims/shims/forms-picker.js

@@ -932,6 +932,7 @@ webshims.register('forms-picker', function($, webshims, window, document, undefi
 		var enabled = 0;
 		var str = '';
 		var rowNum = 0;
+		var triggerValueValidation = (data.orig && ('valuevalidation' in $.data(data.orig)));
 		
 		if(data.options.useDecadeBase == 'max' && max[0]){
 			xthCorrect = 11 - (max[0] % 12);
@@ -956,7 +957,7 @@ webshims.register('forms-picker', function($, webshims, window, document, undefi
 			for(i = 0; i < 12; i++){
 				val = start + i ;
 				classArray = [];
-				if( !picker.isInRange([val], max, min) ){
+				if( !picker.isInRange([val], max, min) || (triggerValueValidation && $(data.orig).triggerHandler('valuevalidation', [{value: val, valueAsDate: null, isPartial: [val]}]))){
 					disabled = ' disabled=""';
 				} else {
 					disabled = '';
@@ -1007,6 +1008,9 @@ webshims.register('forms-picker', function($, webshims, window, document, undefi
 		var enabled = 0;
 		var rowNum = 0;
 		var str = '';
+		var action = data.type == 'month' ? 'changeInput' : 'setDayList' ;
+		var triggerValueValidation = (data.orig && ('valuevalidation' in $.data(data.orig)));
+		var isPartial = action != 'changeInput';
 		
 		value = value[0] - Math.floor((size - 1) / 2);
 		for(j = 0; j < size; j++){
@@ -1040,7 +1044,7 @@ webshims.register('forms-picker', function($, webshims, window, document, undefi
 				val = curCfg.date.monthkeys[i+1];
 				name = getMonthNameHTML(i);
 				classArray = [];
-				if(!picker.isInRange([value, val], max, min) ){
+				if(!picker.isInRange([value, val], max, min) || (triggerValueValidation  && $(data.orig).triggerHandler('valuevalidation', [{value: value+'-'+val, valueAsDate: data.asDate(value+'-'+val), isPartial: isPartial && [value, val]}]))){
 					disabled = ' disabled=""';
 				} else {
 					disabled = '';
@@ -1061,7 +1065,7 @@ webshims.register('forms-picker', function($, webshims, window, document, undefi
 					lis.push('</tr><tr class="ws-row-'+ rowNum +'">');
 				}
 
-				lis.push('<td class="ws-item-'+ i +'" role="presentation"><button data-id="month-'+ i +'" type="button"'+ disabled + classStr +' data-action="'+ (data.type == 'month' ? 'changeInput' : 'setDayList' ) +'" value="'+value+'-'+val+'" tabindex="-1" role="gridcell" aria-label="'+ curCfg.date.monthNames[i] +'">'+name+'</button></td>');
+				lis.push('<td class="ws-item-'+ i +'" role="presentation"><button data-id="month-'+ i +'" type="button"'+ disabled + classStr +' data-action="'+ action +'" value="'+value+'-'+val+'" tabindex="-1" role="gridcell" aria-label="'+ curCfg.date.monthNames[i] +'">'+name+'</button></td>');
 				
 			}
 			
@@ -1081,9 +1085,9 @@ webshims.register('forms-picker', function($, webshims, window, document, undefi
 	
 	picker.getDayList = function(value, data){
 		
-		var j, i, k, day, nDay, name, val, disabled, lis,  prevDisabled, nextDisabled, yearNext, yearPrev, addTr, week, rowNum;
+		var j, i, k, day, nDay, disabled, prevDisabled, nextDisabled, yearNext, yearPrev, addTr, week, rowNum;
 		
-		var lastMonth, curMonth, otherMonth, dateArray, monthName, fullMonthName, monthDigit, buttonStr, date2, classArray;
+		var lastMonth, curMonth, otherMonth, dateArray, monthName, fullMonthName, buttonStr, date2, classArray;
 		
 		var o = data.options;
 		var size = o.size;
@@ -1091,10 +1095,11 @@ webshims.register('forms-picker', function($, webshims, window, document, undefi
 		var min = o.minS;
 		var currentValue = o.value.split('T')[0].split('-');
 		var dateCfg = curCfg.date;
-		var enabled = 0;
 		var str = [];
 		var date = new Date(value[0], value[1] - 1, 1);
 		var action = (data.type == 'datetime-local') ? 'setTimeList' : 'changeInput';
+		var triggerValueValidation = (data.orig && ('valuevalidation' in $.data(data.orig)));
+		var isPartial = action != 'changeInput';
 		
 		date.setMonth(date.getMonth()  - Math.floor((size - 1) / 2));
 		
@@ -1210,7 +1215,7 @@ webshims.register('forms-picker', function($, webshims, window, document, undefi
 					buttonStr += ' class="'+ classArray.join(' ') +'"';
 				}
 				
-				if(!picker.isInRange(dateArray, max, min)){
+				if(!picker.isInRange(dateArray, max, min) || (triggerValueValidation && $(data.orig).triggerHandler('valuevalidation', [{value: dateArray.join('-'), valueAsDate: date, isPartial: isPartial && dateArray}]))){
 					buttonStr += ' disabled=""';
 				}
 				
@@ -1252,7 +1257,7 @@ webshims.register('forms-picker', function($, webshims, window, document, undefi
 			max: $.prop(data.orig, 'max'),
 			step: $.prop(data.orig, 'step')
 		};
-		var o = data.options;
+		var triggerValueValidation = (data.orig && ('valuevalidation' in $.data(data.orig)));
 		var gridLabel = '';
 		
 		if(data.type == 'time'){
@@ -1285,7 +1290,7 @@ webshims.register('forms-picker', function($, webshims, window, document, undefi
 			}
 			str += '<td role="presentation"><button role="gridcell" data-action="changeInput" value="'+ hVal +'" type="button" tabindex="-1"';
 			
-			if(!data.isValid(hVal, attrs)){
+			if(!data.isValid(hVal, attrs) || (triggerValueValidation && $(data.orig).triggerHandler('valuevalidation', [{value: hVal, valueAsDate: data.asDate(hVal), partial: false}]))){
 				str += ' disabled=""';
 			}
 			if(value == iVal){
@@ -1523,15 +1528,13 @@ webshims.register('forms-picker', function($, webshims, window, document, undefi
 							text = (formcfg[''][[data.type]] || {}).currentText || (curCfg.date || {}).currentText || 'current';
 							webshims.warn("could not get currentText from form cfg for "+data.type);
 						}
+
 						if(today[data.type] && data.type != 'time'){
-							$.prop(this, 'disabled', !picker.isInRange(today[data.type].split('-'), o.maxS, o.minS));
+							$.prop(this, 'disabled', (!picker.isInRange(today[data.type].split('-'), o.maxS, o.minS) || !!$(data.orig).triggerHandler('valuevalidation', [{value: today[data.type], valueAsDate: new Date(), isPartial: false}])));
 						}
 					}
 					if(text){
 						$(this).text(text).attr({'aria-label': text});
-						if(webshims.assumeARIA){
-							$.attr(this, 'aria-label', text);
-						}
 					}
 					
 				});

data/vendor/assets/javascripts/webshims/shims/geolocation.js

@@ -128,8 +128,8 @@
 					if($.ajax){
 						createAjax();
 					} else {
-						webshims.ready('$ajax', createAjax);
-						webshims.loader.loadList(['$ajax']);
+						webshims.ready('jajax', createAjax);
+						webshims.loader.loadList(['jajax']);
 					}
 					clearTimeout(googleTimer);
 					if (!window.google || !window.google.loader) {
@@ -174,7 +174,7 @@
 	})();
 	
 	webshims.ready('WINDOWLOAD', function(){
-		webshims.loader.loadList(['$ajax']);
+		webshims.loader.loadList(['jajax']);
 	});
 	webshims.isReady('geolocation', true);
 })(webshims.$);

data/vendor/assets/javascripts/webshims/shims/jajax.js

@@ -0,0 +1,1262 @@
+(function(){
+	var jQuery = window.webshims && webshims.$ || window.jQuery;
+
+	var rnotwhite = (/\S+/g);
+	var nonce = jQuery.now();
+	var rquery = (/\?/);
+	var init = jQuery.fn.init;
+
+	jQuery.parseJSON = function( data ) {
+		return window.JSON.parse( data + "" );
+	};
+
+	// Cross-browser xml parsing
+	jQuery.parseXML = function( data ) {
+		var xml, tmp;
+		if ( !data || typeof data !== "string" ) {
+			return null;
+		}
+		try {
+			if ( window.DOMParser ) { // Standard
+				tmp = new DOMParser();
+				xml = tmp.parseFromString( data, "text/xml" );
+			} else { // IE
+				xml = new ActiveXObject( "Microsoft.XMLDOM" );
+				xml.async = "false";
+				xml.loadXML( data );
+			}
+		} catch( e ) {
+			xml = undefined;
+		}
+		if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
+			jQuery.error( "Invalid XML: " + data );
+		}
+		return xml;
+	};
+
+	(function(){
+		var
+		// Document location
+			ajaxLocParts,
+			ajaxLocation,
+
+			rhash = /#.*$/,
+			rts = /([?&])_=[^&]*/,
+			rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
+		// #7653, #8125, #8152: local protocol detection
+			rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
+			rnoContent = /^(?:GET|HEAD)$/,
+			rprotocol = /^\/\//,
+			rurl = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/,
+
+		/* 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("*");
+
+// #8138, IE may throw an exception when accessing
+// a field from window.location if document.domain has been set
+		try {
+			ajaxLocation = location.href;
+		} catch( e ) {
+			// Use the href attribute of an A element
+			// since IE will modify it given document.location
+			ajaxLocation = document.createElement( "a" );
+			ajaxLocation.href = "";
+			ajaxLocation = ajaxLocation.href;
+		}
+
+// Segment location into parts
+		ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
+
+// 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( rnotwhite ) || [];
+
+				if ( jQuery.isFunction( func ) ) {
+					// For each dataType in the dataTypeExpression
+					while ( (dataType = dataTypes[i++]) ) {
+						// Prepend if requested
+						if ( dataType.charAt( 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 deep, key,
+				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 firstDataType, ct, finalDataType, type,
+				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: ajaxLocation,
+				type: "GET",
+				isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
+				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: /xml/,
+					html: /html/,
+					json: /json/
+				},
+
+				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": jQuery.parseJSON,
+
+					// 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 // Cross-domain detection vars
+					parts,
+				// Loop variable
+					i,
+				// URL without anti-cache param
+					cacheURL,
+				// Response headers as string
+					responseHeadersString,
+				// timeout handle
+					timeoutTimer,
+
+				// To know if global events are to be dispatched
+					fireGlobals,
+
+					transport,
+				// Response headers
+					responseHeaders,
+				// 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 = {},
+				// The jqXHR state
+					state = 0,
+				// Default abort message
+					strAbort = "canceled",
+				// Fake xhr
+					jqXHR = {
+						readyState: 0,
+
+						// 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 ? null : match;
+						},
+
+						// Raw string
+						getAllResponseHeaders: function() {
+							return state === 2 ? responseHeadersString : null;
+						},
+
+						// Caches the header
+						setRequestHeader: function( name, value ) {
+							var lname = name.toLowerCase();
+							if ( !state ) {
+								name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
+								requestHeaders[ name ] = value;
+							}
+							return this;
+						},
+
+						// Overrides response content-type header
+						overrideMimeType: function( type ) {
+							if ( !state ) {
+								s.mimeType = type;
+							}
+							return this;
+						},
+
+						// Status-dependent callbacks
+						statusCode: function( map ) {
+							var code;
+							if ( map ) {
+								if ( state < 2 ) {
+									for ( code in map ) {
+										// Lazy-add the new callback in a way that preserves old ones
+										statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
+									}
+								} else {
+									// Execute the appropriate callbacks
+									jqXHR.always( map[ jqXHR.status ] );
+								}
+							}
+							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 ).complete = completeDeferred.add;
+				jqXHR.success = jqXHR.done;
+				jqXHR.error = jqXHR.fail;
+
+				// Remove hash character (#7531: and string promotion)
+				// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
+				// 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 || ajaxLocation ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
+
+				// Alias method option to type as per ticket #12004
+				s.type = options.method || options.type || s.method || s.type;
+
+				// Extract dataTypes list
+				s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().match( rnotwhite ) || [ "" ];
+
+				// A cross-domain request is in order when we have a protocol:host:port mismatch
+				if ( s.crossDomain == null ) {
+					parts = rurl.exec( s.url.toLowerCase() );
+					s.crossDomain = !!( parts &&
+						( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] ||
+							( parts[ 3 ] || ( parts[ 1 ] === "http:" ? "80" : "443" ) ) !==
+								( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? "80" : "443" ) ) )
+						);
+				}
+
+				// 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 ( state === 2 ) {
+					return jqXHR;
+				}
+
+				// We can fire global events as of now if asked to
+				fireGlobals = 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
+				cacheURL = s.url;
+
+				// More options handling for requests with no content
+				if ( !s.hasContent ) {
+
+					// If data is available, append data to url
+					if ( s.data ) {
+						cacheURL = ( s.url += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data );
+						// #9682: remove data so that it's not used in an eventual retry
+						delete s.data;
+					}
+
+					// Add anti-cache in url if needed
+					if ( s.cache === false ) {
+						s.url = rts.test( cacheURL ) ?
+
+							// If there is already a '_' parameter, set its value
+							cacheURL.replace( rts, "$1_=" + nonce++ ) :
+
+							// Otherwise add one to the end
+							cacheURL + ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + nonce++;
+					}
+				}
+
+				// 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 || state === 2 ) ) {
+					// Abort if not done already and return
+					return jqXHR.abort();
+				}
+
+				// aborting is no longer a cancellation
+				strAbort = "abort";
+
+				// Install callbacks on deferreds
+				for ( i in { success: 1, error: 1, complete: 1 } ) {
+					jqXHR[ i ]( s[ i ] );
+				}
+
+				// 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 ] );
+					}
+					// Timeout
+					if ( s.async && s.timeout > 0 ) {
+						timeoutTimer = setTimeout(function() {
+							jqXHR.abort("timeout");
+						}, s.timeout );
+					}
+
+					try {
+						state = 1;
+						transport.send( requestHeaders, done );
+					} catch ( e ) {
+						// Propagate exception as error if not done
+						if ( state < 2 ) {
+							done( -1, e );
+							// Simply rethrow otherwise
+						} else {
+							throw e;
+						}
+					}
+				}
+
+				// Callback for when everything is done
+				function done( status, nativeStatusText, responses, headers ) {
+					var isSuccess, success, error, response, modified,
+						statusText = nativeStatusText;
+
+					// Called once
+					if ( state === 2 ) {
+						return;
+					}
+
+					// State is "done" now
+					state = 2;
+
+					// Clear timeout if it exists
+					if ( timeoutTimer ) {
+						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 {
+						// We extract error from statusText
+						// then normalize statusText and status 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;
+				}
+
+				return jQuery.ajax({
+					url: url,
+					type: method,
+					dataType: type,
+					data: data,
+					success: callback
+				});
+			};
+		});
+
+// Attach a bunch of functions for handling common AJAX events
+		jQuery.each( [ "ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend" ], function( i, type ) {
+			jQuery.fn[ type ] = function( fn ) {
+				return this.on( type, fn );
+			};
+		});
+	})();
+
+
+	(function(){
+		var oldCallbacks = [],
+			rjsonp = /(=)\?(?=&|$)|\?\?/;
+
+// Default jsonp settings
+		jQuery.ajaxSetup({
+			jsonp: "callback",
+			jsonpCallback: function() {
+				var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
+				this[ callback ] = true;
+				return callback;
+			}
+		});
+
+// Detect, normalize options and install callbacks for jsonp requests
+		jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
+
+			var callbackName, overwritten, responseContainer,
+				jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
+					"url" :
+					typeof s.data === "string" && !( s.contentType || "" ).indexOf("application/x-www-form-urlencoded") && rjsonp.test( s.data ) && "data"
+					);
+
+			// Handle iff the expected data type is "jsonp" or we have a parameter to set
+			if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
+
+				// Get callback name, remembering preexisting value associated with it
+				callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
+					s.jsonpCallback() :
+					s.jsonpCallback;
+
+				// Insert callback into url or form data
+				if ( jsonProp ) {
+					s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
+				} else if ( s.jsonp !== false ) {
+					s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
+				}
+
+				// Use data converter to retrieve json after script execution
+				s.converters["script json"] = function() {
+					if ( !responseContainer ) {
+						jQuery.error( callbackName + " was not called" );
+					}
+					return responseContainer[ 0 ];
+				};
+
+				// force json dataType
+				s.dataTypes[ 0 ] = "json";
+
+				// Install callback
+				overwritten = window[ callbackName ];
+				window[ callbackName ] = function() {
+					responseContainer = arguments;
+				};
+
+				// Clean-up function (fires after converters)
+				jqXHR.always(function() {
+					// Restore preexisting value
+					window[ callbackName ] = overwritten;
+
+					// Save back as free
+					if ( s[ callbackName ] ) {
+						// make sure that re-using the options doesn't screw things around
+						s.jsonpCallback = originalSettings.jsonpCallback;
+
+						// save the callback name for future use
+						oldCallbacks.push( callbackName );
+					}
+
+					// Call if it was a function and we have a response
+					if ( responseContainer && jQuery.isFunction( overwritten ) ) {
+						overwritten( responseContainer[ 0 ] );
+					}
+
+					responseContainer = overwritten = undefined;
+				});
+
+				// Delegate to script
+				return "script";
+			}
+		});
+	})();
+
+	(function(){
+		// Keep a copy of the old load method
+		var _load = jQuery.fn.load;
+
+		/**
+		 * Load a url into a page
+		 */
+		jQuery.fn.load = function( url, params, callback ) {
+			if ( typeof url !== "string" && _load ) {
+				return _load.apply( this, arguments );
+			}
+
+			var selector, response, type,
+				self = this,
+				off = url.indexOf(" ");
+
+			if ( off >= 0 ) {
+				selector = url.slice( off, url.length );
+				url = url.slice( 0, off );
+			}
+
+			// If it's a function
+			if ( jQuery.isFunction( params ) ) {
+
+				// We assume that it's the callback
+				callback = params;
+				params = undefined;
+
+				// Otherwise, build a param string
+			} else if ( params && typeof params === "object" ) {
+				type = "POST";
+			}
+
+			// If we have elements to modify, make the request
+			if ( self.length > 0 ) {
+				jQuery.ajax({
+					url: url,
+
+					// if "type" variable is undefined, then "GET" method will be used
+					type: type,
+					dataType: "html",
+					data: params
+				}).done(function( responseText ) {
+
+					// Save response for use in complete callback
+					response = arguments;
+
+					self.html( selector ?
+
+						// If a selector was specified, locate the right elements in a dummy div
+						// Exclude scripts to avoid IE 'Permission Denied' errors
+						jQuery("<div>").append( jQuery.parseHTML( responseText ) ).find( selector ) :
+
+						// Otherwise use the full result
+						responseText );
+
+				}).complete( callback && function( jqXHR, status ) {
+						self.each( callback, response || [ jqXHR.responseText, status, jqXHR ] );
+					});
+			}
+
+			return this;
+		};
+
+	})();
+	(function(){
+// Install script dataType
+		jQuery.ajaxSetup({
+			accepts: {
+				script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
+			},
+			contents: {
+				script: /(?:java|ecma)script/
+			},
+			converters: {
+				"text script": function( text ) {
+					jQuery.globalEval( text );
+					return text;
+				}
+			}
+		});
+
+// Handle cache's special case and global
+		jQuery.ajaxPrefilter( "script", function( s ) {
+			if ( s.cache === undefined ) {
+				s.cache = false;
+			}
+			if ( s.crossDomain ) {
+				s.type = "GET";
+				s.global = false;
+			}
+		});
+
+// Bind script tag hack transport
+		jQuery.ajaxTransport( "script", function(s) {
+
+			// This transport only deals with cross domain requests
+			if ( s.crossDomain ) {
+
+				var script,
+					head = document.head || jQuery("head")[0] || document.documentElement;
+
+				return {
+
+					send: function( _, callback ) {
+
+						script = document.createElement("script");
+
+						script.async = true;
+
+						if ( s.scriptCharset ) {
+							script.charset = s.scriptCharset;
+						}
+
+						script.src = s.url;
+
+						// Attach handlers for all browsers
+						script.onload = script.onreadystatechange = function( _, isAbort ) {
+
+							if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
+
+								// Handle memory leak in IE
+								script.onload = script.onreadystatechange = null;
+
+								// Remove the script
+								if ( script.parentNode ) {
+									script.parentNode.removeChild( script );
+								}
+
+								// Dereference the script
+								script = null;
+
+								// Callback if not abort
+								if ( !isAbort ) {
+									callback( 200, "success" );
+								}
+							}
+						};
+
+						// Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending
+						// Use native DOM manipulation to avoid our domManip AJAX trickery
+						head.insertBefore( script, head.firstChild );
+					},
+
+					abort: function() {
+						if ( script ) {
+							script.onload( undefined, true );
+						}
+					}
+				};
+			}
+		});
+	})();
+	(function(){
+		var support = jQuery.support;
+// Create the request object
+// (This is still attached to ajaxSettings for backward compatibility)
+		jQuery.ajaxSettings.xhr = window.ActiveXObject !== undefined ?
+			// Support: IE6+
+			function() {
+
+				// XHR cannot access local files, always use ActiveX for that case
+				return !this.isLocal &&
+
+					// Support: IE7-8
+					// oldIE XHR does not support non-RFC2616 methods (#13240)
+					// See http://msdn.microsoft.com/en-us/library/ie/ms536648(v=vs.85).aspx
+					// and http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9
+					// Although this check for six methods instead of eight
+					// since IE also does not support "trace" and "connect"
+					/^(get|post|head|put|delete|options)$/i.test( this.type ) &&
+
+					createStandardXHR() || createActiveXHR();
+			} :
+			// For all other browsers, use the standard XMLHttpRequest object
+			createStandardXHR;
+
+		var xhrId = 0,
+			xhrCallbacks = {},
+			xhrSupported = jQuery.ajaxSettings.xhr();
+
+// Support: IE<10
+// Open requests must be manually aborted on unload (#5280)
+		if ( window.ActiveXObject ) {
+			jQuery( window ).on( "unload", function() {
+				for ( var key in xhrCallbacks ) {
+					xhrCallbacks[ key ]( undefined, true );
+				}
+			});
+		}
+
+// Determine support properties
+		support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
+		xhrSupported = support.ajax = !!xhrSupported;
+
+// Create transport if the browser can provide an xhr
+		if ( xhrSupported ) {
+
+			jQuery.ajaxTransport(function( options ) {
+				// Cross domain only allowed if supported through XMLHttpRequest
+				if ( !options.crossDomain || support.cors ) {
+
+					var callback;
+
+					return {
+						send: function( headers, complete ) {
+							var i,
+								xhr = options.xhr(),
+								id = ++xhrId;
+
+							// Open the socket
+							xhr.open( options.type, options.url, options.async, options.username, options.password );
+
+							// Apply custom fields if provided
+							if ( options.xhrFields ) {
+								for ( i in options.xhrFields ) {
+									xhr[ i ] = options.xhrFields[ i ];
+								}
+							}
+
+							// Override mime type if needed
+							if ( options.mimeType && xhr.overrideMimeType ) {
+								xhr.overrideMimeType( options.mimeType );
+							}
+
+							// X-Requested-With header
+							// For cross-domain requests, seeing as conditions for a preflight are
+							// akin to a jigsaw puzzle, we simply never set it to be sure.
+							// (it can always be set on a per-request basis or even using ajaxSetup)
+							// For same-domain requests, won't change header if already provided.
+							if ( !options.crossDomain && !headers["X-Requested-With"] ) {
+								headers["X-Requested-With"] = "XMLHttpRequest";
+							}
+
+							// Set headers
+							for ( i in headers ) {
+								// Support: IE<9
+								// IE's ActiveXObject throws a 'Type Mismatch' exception when setting
+								// request header to a null-value.
+								//
+								// To keep consistent with other XHR implementations, cast the value
+								// to string and ignore `undefined`.
+								if ( headers[ i ] !== undefined ) {
+									xhr.setRequestHeader( i, headers[ i ] + "" );
+								}
+							}
+
+							// Do send the request
+							// This may raise an exception which is actually
+							// handled in jQuery.ajax (so no try/catch here)
+							xhr.send( ( options.hasContent && options.data ) || null );
+
+							// Listener
+							callback = function( _, isAbort ) {
+								var status, statusText, responses;
+
+								// Was never called and is aborted or complete
+								if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
+									// Clean up
+									delete xhrCallbacks[ id ];
+									callback = undefined;
+									xhr.onreadystatechange = jQuery.noop;
+
+									// Abort manually if needed
+									if ( isAbort ) {
+										if ( xhr.readyState !== 4 ) {
+											xhr.abort();
+										}
+									} else {
+										responses = {};
+										status = xhr.status;
+
+										// Support: IE<10
+										// Accessing binary-data responseText throws an exception
+										// (#11426)
+										if ( typeof xhr.responseText === "string" ) {
+											responses.text = xhr.responseText;
+										}
+
+										// Firefox throws an exception when accessing
+										// statusText for faulty cross-domain requests
+										try {
+											statusText = xhr.statusText;
+										} catch( e ) {
+											// We normalize with Webkit giving an empty statusText
+											statusText = "";
+										}
+
+										// Filter status for non standard behaviors
+
+										// If the request is local and we have data: assume a success
+										// (success with no data won't get notified, that's the best we
+										// can do given current implementations)
+										if ( !status && options.isLocal && !options.crossDomain ) {
+											status = responses.text ? 200 : 404;
+											// IE - #1450: sometimes returns 1223 when it should be 204
+										} else if ( status === 1223 ) {
+											status = 204;
+										}
+									}
+								}
+
+								// Call complete if needed
+								if ( responses ) {
+									complete( status, statusText, responses, xhr.getAllResponseHeaders() );
+								}
+							};
+
+							if ( !options.async ) {
+								// if we're in sync mode we fire the callback
+								callback();
+							} else if ( xhr.readyState === 4 ) {
+								// (IE6 & IE7) if it's in cache and has been
+								// retrieved directly we need to fire the callback
+								setTimeout( callback );
+							} else {
+								// Add to the list of active xhr callbacks
+								xhr.onreadystatechange = xhrCallbacks[ id ] = callback;
+							}
+						},
+
+						abort: function() {
+							if ( callback ) {
+								callback( undefined, true );
+							}
+						}
+					};
+				}
+			});
+		}
+
+// Functions to create xhrs
+		function createStandardXHR() {
+			try {
+				return new window.XMLHttpRequest();
+			} catch( e ) {}
+		}
+
+		function createActiveXHR() {
+			try {
+				return new window.ActiveXObject( "Microsoft.XMLHTTP" );
+			} catch( e ) {}
+		}
+	})();
+	webshims.isReady('jajax', true);
+})();