/drupal7/sites/all/modules/jquery_update/replace/jquery/1.8/jquery.js - Diff - Club Drupal - Forge Centrale Marseille

Révision 2c8c2b87

Ajouté par Assos Assos il y a presque 9 ans

ID 2c8c2b87c46d4f7ff3dcb391edd0a894cb086ab3
Parent 58344a8d
Enfant 1afa1695

Weekly update of contrib modules

     /*!
      * jQuery JavaScript Library v1.8.2
      * jQuery JavaScript Library v1.8.3
      * http://jquery.com/
+     *
      * Includes Sizzle.js
-...
      * Released under the MIT license
      * http://jquery.org/license
+     *
      * Date: Thu Sep 20 2012 21:13:05 GMT-0400 (Eastern Daylight Time)
      * Date: Tue Nov 13 2012 08:20:33 GMT-0500 (Eastern Standard Time)
      */
     (function( window, undefined ) {
     var
-...
     	selector: "",
     	// The current version of jQuery being used
     	jquery: "1.8.2",
     	jquery: "1.8.3",
     	// The default length of a jQuery object is 0
     	length: 0,
-...
     					(function add( args ) {
     						jQuery.each( args, function( _, arg ) {
     							var type = jQuery.type( arg );
     							if ( type === "function" && ( !options.unique || !self.has( arg ) ) ) {
     								list.push( arg );
     							if ( type === "function" ) {
     								if ( !options.unique || !self.has( arg ) ) {
     									list.push( arg );
+    								}
     							} else if ( arg && arg.length && type !== "string" ) {
     								// Inspect recursively
     								add( arg );
-...
     		clickFn,
     		div = document.createElement("div");
     	// Preliminary tests
     	// Setup
     	div.setAttribute( "className", "t" );
     	div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
     	// Support tests won't run in some limited or non-browser environments
     	all = div.getElementsByTagName("*");
     	a = div.getElementsByTagName("a")[ 0 ];
     	a.style.cssText = "top:1px;float:left;opacity:.5";
     	// Can't get basic test support
     	if ( !all || !all.length ) {
     	if ( !all || !a || !all.length ) {
     		return {};
+    	}
     	// First batch of supports tests
     	// First batch of tests
     	select = document.createElement("select");
     	opt = select.appendChild( document.createElement("option") );
     	input = div.getElementsByTagName("input")[ 0 ];
     	a.style.cssText = "top:1px;float:left;opacity:.5";
     	support = {
     		// IE strips leading whitespace when .innerHTML is used
     		leadingWhitespace: ( div.firstChild.nodeType === 3 ),
-...
     		// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
     		getSetAttribute: div.className !== "t",
     		// Tests for enctype support on a form(#6743)
     		// Tests for enctype support on a form (#6743)
     		enctype: !!document.createElement("form").enctype,
     		// Makes sure cloning an html5 element does not cause problems
-...
     		},
     		select: {
     			get: function( elem ) {
     				var value, i, max, option,
     					index = elem.selectedIndex,
     					values = [],
     				var value, option,
     					options = elem.options,
     					one = elem.type === "select-one";
     				// Nothing was selected
     				if ( index < 0 ) {
     					return null;
+    				}
     					index = elem.selectedIndex,
     					one = elem.type === "select-one" || index < 0,
     					values = one ? null : [],
     					max = one ? index + 1 : options.length,
     					i = index < 0 ?
     						max :
     						one ? index : 0;
     				// Loop through all the selected options
     				i = one ? index : 0;
     				max = one ? index + 1 : options.length;
     				for ( ; i < max; i++ ) {
     					option = options[ i ];
     					// Don't return options that are disabled or in a disabled optgroup
     					if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
     							(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
     					// oldIE doesn't update selected after form reset (#2551)
     					if ( ( option.selected || i === index ) &&
     							// Don't return options that are disabled or in a disabled optgroup
     							( jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null ) &&
     							( !option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {
     						// Get the specific value for the option
     						value = jQuery( option ).val();
-...
+    					}
+    				}
     				// Fixes Bug #2551 -- select.val() broken in IE after form.reset()
     				if ( one && !values.length && options.length ) {
     					return jQuery( options[ index ] ).val();
+    				}
     				return values;
     			},
-...
     		if ( elem.detachEvent ) {
     			// #8545, #7054, preventing memory leaks for custom events in IE6-8 –
     			// #8545, #7054, preventing memory leaks for custom events in IE6-8
     			// detachEvent needed property on element, by name of that event, to properly expose it to GC
     			if ( typeof elem[ name ] === "undefined" ) {
     				elem[ name ] = null;
-...
     			jQuery.event.add( this, "beforeactivate._change", function( e ) {
     				var elem = e.target;
     				if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "_change_attached" ) ) {
     					jQuery.event.add( elem, "change._change", function( event ) {
     						if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
     							jQuery.event.simulate( "change", this.parentNode, event, true );
     				if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "_change_attached" ) ) {
     					jQuery.event.add( elem, "change._change", function( event ) {
     						if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
     							jQuery.event.simulate( "change", this.parentNode, event, true );
+    						}
     					});
     					jQuery._data( elem, "_change_attached", true );
+    				}
     			});
     		},
     		handle: function( event ) {
     			var elem = event.target;
     			// Swallow native change events from checkbox/radio, we already triggered them above
     			if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
     				return event.handleObj.handler.apply( this, arguments );
+    			}
     		},
     		teardown: function() {
     			jQuery.event.remove( this, "._change" );
     			return !rformElems.test( this.nodeName );
+    		}
     	};
+    }
     // Create "bubbling" focus and blur events
     if ( !jQuery.support.focusinBubbles ) {
     	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
     		// Attach a single capturing handler while someone wants focusin/focusout
     		var attaches = 0,
     			handler = function( event ) {
     				jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
     			};
     		jQuery.event.special[ fix ] = {
     			setup: function() {
     				if ( attaches++ === 0 ) {
     					document.addEventListener( orig, handler, true );
+    				}
     			},
     			teardown: function() {
     				if ( --attaches === 0 ) {
     					document.removeEventListener( orig, handler, true );
+    				}
+    			}
     		};
     	});
+    }
     jQuery.fn.extend({
     	on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
     		var origFn, type;
     		// Types can be a map of types/handlers
     		if ( typeof types === "object" ) {
     			// ( types-Object, selector, data )
     			if ( typeof selector !== "string" ) { // && selector != null
     				// ( types-Object, data )
     				data = data || selector;
     				selector = undefined;
+    			}
     			for ( type in types ) {
     				this.on( type, selector, data, types[ type ], one );
+    			}
     			return this;
+    		}
     		if ( data == null && fn == null ) {
     			// ( types, fn )
     			fn = selector;
     			data = selector = undefined;
     		} else if ( fn == null ) {
     			if ( typeof selector === "string" ) {
     				// ( types, selector, fn )
     				fn = data;
     				data = undefined;
     			} else {
     				// ( types, data, fn )
     				fn = data;
     				data = selector;
     				selector = undefined;
+    			}
+    		}
     		if ( fn === false ) {
     			fn = returnFalse;
     		} else if ( !fn ) {
     			return this;
+    		}
     		if ( one === 1 ) {
     			origFn = fn;
     			fn = function( event ) {
     				// Can use an empty set, since event contains the info
     				jQuery().off( event );
     				return origFn.apply( this, arguments );
     			};
     			// Use same guid so caller can remove using origFn
     			fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
+    		}
     		return this.each( function() {
     			jQuery.event.add( this, types, fn, data, selector );
     		});
     	},
     	one: function( types, selector, data, fn ) {
     		return this.on( types, selector, data, fn, 1 );
     	},
     	off: function( types, selector, fn ) {
     		var handleObj, type;
     		if ( types && types.preventDefault && types.handleObj ) {
     			// ( event )  dispatched jQuery.Event
     			handleObj = types.handleObj;
     			jQuery( types.delegateTarget ).off(
     				handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
     				handleObj.selector,
     				handleObj.handler
     			);
     			return this;
+    		}
     		if ( typeof types === "object" ) {
     			// ( types-object [, selector] )
     			for ( type in types ) {
     				this.off( type, selector, types[ type ] );
+    			}
     			return this;
+    		}
     		if ( selector === false || typeof selector === "function" ) {
     			// ( types [, fn] )
     			fn = selector;
     			selector = undefined;
+    		}
     		if ( fn === false ) {
     			fn = returnFalse;
+    		}
     		return this.each(function() {
     			jQuery.event.remove( this, types, fn, selector );
     		});
     	},
     	bind: function( types, data, fn ) {
     		return this.on( types, null, data, fn );
     	},
     	unbind: function( types, fn ) {
     		return this.off( types, null, fn );
     	},
     	live: function( types, data, fn ) {
     		jQuery( this.context ).on( types, this.selector, data, fn );
     		return this;
     	},
     	die: function( types, fn ) {
     		jQuery( this.context ).off( types, this.selector || "**", fn );
     		return this;
     	},
     	delegate: function( selector, types, data, fn ) {
     		return this.on( types, selector, data, fn );
     	},
     	undelegate: function( selector, types, fn ) {
     		// ( namespace ) or ( selector, types [, fn] )
     		return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn );
     	},
     	trigger: function( type, data ) {
     		return this.each(function() {
     			jQuery.event.trigger( type, data, this );
     		});
     	},
     	triggerHandler: function( type, data ) {
     		if ( this[0] ) {
     			return jQuery.event.trigger( type, data, this[0], true );
+    		}
     	},
     	toggle: function( fn ) {
     		// Save reference to arguments for access in closure
     		var args = arguments,
     			guid = fn.guid || jQuery.guid++,
     			i = 0,
     			toggler = function( event ) {
     				// Figure out which function to execute
     				var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
     				jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );
     				// Make sure that clicks stop
     				event.preventDefault();
     				// and execute the function
     				return args[ lastToggle ].apply( this, arguments ) || false;
     			};
     		// link all the functions, so any of them can unbind this click handler
     		toggler.guid = guid;
     		while ( i < args.length ) {
     			args[ i++ ].guid = guid;
+    		}
     		return this.click( toggler );
     	},
     	hover: function( fnOver, fnOut ) {
     		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
+    	}
     });
     jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
     	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
     	"change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
     	// Handle event binding
     	jQuery.fn[ name ] = function( data, fn ) {
     		if ( fn == null ) {
     			fn = data;
     			data = null;
+    		}
     		return arguments.length > 0 ?
     			this.on( name, null, data, fn ) :
     			this.trigger( name );
     	};
     	if ( rkeyEvent.test( name ) ) {
     		jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks;
+    	}
     	if ( rmouseEvent.test( name ) ) {
     		jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks;
+    	}
     });
     /*!
      * Sizzle CSS Selector Engine
      * Copyright 2012 jQuery Foundation and other contributors
      * Released under the MIT license
      * http://sizzlejs.com/
      */
     (function( window, undefined ) {
     var cachedruns,
     	assertGetIdNotName,
     	Expr,
     	getText,
     	isXML,
     	contains,
     	compile,
     	sortOrder,
     	hasDuplicate,
     	outermostContext,
     	baseHasDuplicate = true,
     	strundefined = "undefined",
     	expando = ( "sizcache" + Math.random() ).replace( ".", "" ),
     	Token = String,
     	document = window.document,
     	docElem = document.documentElement,
     	dirruns = 0,
     	done = 0,
     	pop = [].pop,
     	push = [].push,
     	slice = [].slice,
     	// Use a stripped-down indexOf if a native one is unavailable
     	indexOf = [].indexOf || function( elem ) {
     		var i = 0,
     			len = this.length;
     		for ( ; i < len; i++ ) {
     			if ( this[i] === elem ) {
     				return i;
+    			}
+    		}
     		return -1;
     	},
     	// Augment a function for special use by Sizzle
     	markFunction = function( fn, value ) {
     		fn[ expando ] = value == null || value;
     		return fn;
     	},
     	createCache = function() {
     		var cache = {},
     			keys = [];
     		return markFunction(function( key, value ) {
     			// Only keep the most recent entries
     			if ( keys.push( key ) > Expr.cacheLength ) {
     				delete cache[ keys.shift() ];
+    			}
     			// Retrieve with (key + " ") to avoid collision with native Object.prototype properties (see Issue #157)
     			return (cache[ key + " " ] = value);
     		}, cache );
     	},
     	classCache = createCache(),
     	tokenCache = createCache(),
     	compilerCache = createCache(),
     	// Regex
     	// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
     	whitespace = "[\\x20\\t\\r\\n\\f]",
     	// http://www.w3.org/TR/css3-syntax/#characters
     	characterEncoding = "(?:\\\\.|[-\\w]|[^\\x00-\\xa0])+",
     	// Loosely modeled on CSS identifier characters
     	// An unquoted value should be a CSS identifier (http://www.w3.org/TR/css3-selectors/#attribute-selectors)
     	// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
     	identifier = characterEncoding.replace( "w", "w#" ),
     	// Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors
     	operators = "([*^$|!~]?=)",
     	attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace +
     		"*(?:" + operators + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]",
     	// Prefer arguments not in parens/brackets,
     	//   then attribute selectors and non-pseudos (denoted by :),
     	//   then anything else
     	// These preferences are here to reduce the number of selectors
     	//   needing tokenize in the PSEUDO preFilter
     	pseudos = ":(" + characterEncoding + ")(?:\\((?:(['\"])((?:\\\\.|[^\\\\])*?)\\2|([^()[\\]]*|(?:(?:" + attributes + ")|[^:]|\\\\.)*|.*))\\)|)",
     	// For matchExpr.POS and matchExpr.needsContext
     	pos = ":(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
     		"*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)",
     	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
     	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
     	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
     	rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ),
     	rpseudo = new RegExp( pseudos ),
     	// Easily-parseable/retrievable ID or TAG or CLASS selectors
     	rquickExpr = /^(?:#([\w\-]+)|(\w+)|\.([\w\-]+))$/,
     	rnot = /^:not/,
     	rsibling = /[\x20\t\r\n\f]*[+~]/,
     	rendsWithNot = /:not\($/,
     	rheader = /h\d/i,
     	rinputs = /input|select|textarea|button/i,
     	rbackslash = /\\(?!\\)/g,
     	matchExpr = {
     		"ID": new RegExp( "^#(" + characterEncoding + ")" ),
     		"CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
     		"NAME": new RegExp( "^\\[name=['\"]?(" + characterEncoding + ")['\"]?\\]" ),
     		"TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),
     		"ATTR": new RegExp( "^" + attributes ),
     		"PSEUDO": new RegExp( "^" + pseudos ),
     		"POS": new RegExp( pos, "i" ),
     		"CHILD": new RegExp( "^:(only|nth|first|last)-child(?:\\(" + whitespace +
     			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
     			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
     		// For use in libraries implementing .is()
     		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|" + pos, "i" )
     	},
     	// Support
     	// Used for testing something on an element
     	assert = function( fn ) {
     		var div = document.createElement("div");
     		try {
     			return fn( div );
     		} catch (e) {
     			return false;
     		} finally {
     			// release memory in IE
     			div = null;
+    		}
     	},
     	// Check if getElementsByTagName("*") returns only elements
     	assertTagNameNoComments = assert(function( div ) {
     		div.appendChild( document.createComment("") );
     		return !div.getElementsByTagName("*").length;
     	}),
     	// Check if getAttribute returns normalized href attributes
     	assertHrefNotNormalized = assert(function( div ) {
     		div.innerHTML = "<a href='#'></a>";
     		return div.firstChild && typeof div.firstChild.getAttribute !== strundefined &&
     			div.firstChild.getAttribute("href") === "#";
     	}),
     	// Check if attributes should be retrieved by attribute nodes
     	assertAttributes = assert(function( div ) {
     		div.innerHTML = "<select></select>";
     		var type = typeof div.lastChild.getAttribute("multiple");
     		// IE8 returns a string for some attributes even when not present
     		return type !== "boolean" && type !== "string";
     	}),
     	// Check if getElementsByClassName can be trusted
     	assertUsableClassName = assert(function( div ) {
     		// Opera can't find a second classname (in 9.6)
     		div.innerHTML = "<div class='hidden e'></div><div class='hidden'></div>";
     		if ( !div.getElementsByClassName || !div.getElementsByClassName("e").length ) {
     			return false;
+    		}
     		// Safari 3.2 caches class attributes and doesn't catch changes
     		div.lastChild.className = "e";
     		return div.getElementsByClassName("e").length === 2;
     	}),
     	// Check if getElementById returns elements by name
     	// Check if getElementsByName privileges form controls or returns elements by ID
     	assertUsableName = assert(function( div ) {
     		// Inject content
     		div.id = expando + 0;
     		div.innerHTML = "<a name='" + expando + "'></a><div name='" + expando + "'></div>";
     		docElem.insertBefore( div, docElem.firstChild );
     		// Test
     		var pass = document.getElementsByName &&
     			// buggy browsers will return fewer than the correct 2
     			document.getElementsByName( expando ).length === 2 +
     			// buggy browsers will return more than the correct 0
     			document.getElementsByName( expando + 0 ).length;
     		assertGetIdNotName = !document.getElementById( expando );
     		// Cleanup
     		docElem.removeChild( div );
     		return pass;
     	});
     // If slice is not available, provide a backup
     try {
     	slice.call( docElem.childNodes, 0 )[0].nodeType;
     } catch ( e ) {
     	slice = function( i ) {
     		var elem,
     			results = [];
     		for ( ; (elem = this[i]); i++ ) {
     			results.push( elem );
+    		}
     		return results;
     	};
+    }
     function Sizzle( selector, context, results, seed ) {
     	results = results || [];
     	context = context || document;
     	var match, elem, xml, m,
     		nodeType = context.nodeType;
     	if ( !selector || typeof selector !== "string" ) {
     		return results;
+    	}
     	if ( nodeType !== 1 && nodeType !== 9 ) {
     		return [];
+    	}
     	xml = isXML( context );
     	if ( !xml && !seed ) {
     		if ( (match = rquickExpr.exec( selector )) ) {
     			// Speed-up: Sizzle("#ID")
     			if ( (m = match[1]) ) {
     				if ( nodeType === 9 ) {
     					elem = context.getElementById( m );
     					// Check parentNode to catch when Blackberry 4.6 returns
     					// nodes that are no longer in the document #6963
     					if ( elem && elem.parentNode ) {
     						// Handle the case where IE, Opera, and Webkit return items
     						// by name instead of ID
     						if ( elem.id === m ) {
     							results.push( elem );
     							return results;
+    						}
     					} else {
     						return results;
+    					}
     				} else {
     					// Context is not a document
     					if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
     						contains( context, elem ) && elem.id === m ) {
     						results.push( elem );
     						return results;
+    					}
+    				}
     			// Speed-up: Sizzle("TAG")
     			} else if ( match[2] ) {
     				push.apply( results, slice.call(context.getElementsByTagName( selector ), 0) );
     				return results;
     			// Speed-up: Sizzle(".CLASS")
     			} else if ( (m = match[3]) && assertUsableClassName && context.getElementsByClassName ) {
     				push.apply( results, slice.call(context.getElementsByClassName( m ), 0) );
     				return results;
+    			}
+    		}
+    	}
     	// All others
     	return select( selector.replace( rtrim, "$1" ), context, results, seed, xml );
+    }
     Sizzle.matches = function( expr, elements ) {
     	return Sizzle( expr, null, null, elements );
     };
     Sizzle.matchesSelector = function( elem, expr ) {
     	return Sizzle( expr, null, null, [ elem ] ).length > 0;
     };
     // Returns a function to use in pseudos for input types
     function createInputPseudo( type ) {
     	return function( elem ) {
     		var name = elem.nodeName.toLowerCase();
     		return name === "input" && elem.type === type;
     	};
+    }
     // Returns a function to use in pseudos for buttons
     function createButtonPseudo( type ) {
     	return function( elem ) {
     		var name = elem.nodeName.toLowerCase();
     		return (name === "input" || name === "button") && elem.type === type;
     	};
+    }
     // Returns a function to use in pseudos for positionals
     function createPositionalPseudo( fn ) {
     	return markFunction(function( argument ) {
     		argument = +argument;
     		return markFunction(function( seed, matches ) {
     			var j,
     				matchIndexes = fn( [], seed.length, argument ),
     				i = matchIndexes.length;
     			// Match elements found at the specified indexes
     			while ( i-- ) {
     				if ( seed[ (j = matchIndexes[i]) ] ) {
     					seed[j] = !(matches[j] = seed[j]);
+    				}
+    			}
     		});
     	});
+    }
     /**
      * Utility function for retrieving the text value of an array of DOM nodes
      * @param {Array|Element} elem
      */
     getText = Sizzle.getText = function( elem ) {
     	var node,
     		ret = "",
     		i = 0,
     		nodeType = elem.nodeType;
     	if ( nodeType ) {
     		if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
     			// Use textContent for elements
     			// innerText usage removed for consistency of new lines (see #11153)
     			if ( typeof elem.textContent === "string" ) {
     				return elem.textContent;
     			} else {
     				// Traverse its children
     				for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
     					ret += getText( elem );
+    				}
+    			}
     		} else if ( nodeType === 3 || nodeType === 4 ) {
     			return elem.nodeValue;
+    		}
     		// Do not include comment or processing instruction nodes
     	} else {
     		// If no nodeType, this is expected to be an array
     		for ( ; (node = elem[i]); i++ ) {
     			// Do not traverse comment nodes
     			ret += getText( node );
+    		}
+    	}
     	return ret;
     };
     isXML = Sizzle.isXML = function( elem ) {
     	// documentElement is verified for cases where it doesn't yet exist
     	// (such as loading iframes in IE - #4833)
     	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
     	return documentElement ? documentElement.nodeName !== "HTML" : false;
     };
     // Element contains another
     contains = Sizzle.contains = docElem.contains ?
     	function( a, b ) {
     		var adown = a.nodeType === 9 ? a.documentElement : a,
     			bup = b && b.parentNode;
     		return a === bup || !!( bup && bup.nodeType === 1 && adown.contains && adown.contains(bup) );
     	} :
     	docElem.compareDocumentPosition ?
     	function( a, b ) {
     		return b && !!( a.compareDocumentPosition( b ) & 16 );
     	} :
     	function( a, b ) {
     		while ( (b = b.parentNode) ) {
     			if ( b === a ) {
     				return true;
+    			}
+    		}
     		return false;
     	};
     Sizzle.attr = function( elem, name ) {
     	var val,
     		xml = isXML( elem );
     	if ( !xml ) {
     		name = name.toLowerCase();
+    	}
     	if ( (val = Expr.attrHandle[ name ]) ) {
     		return val( elem );
+    	}
     	if ( xml || assertAttributes ) {
     		return elem.getAttribute( name );
+    	}
     	val = elem.getAttributeNode( name );
     	return val ?
     		typeof elem[ name ] === "boolean" ?
     			elem[ name ] ? name : null :
     			val.specified ? val.value : null :
     		null;
     };
     Expr = Sizzle.selectors = {
     	// Can be adjusted by the user
     	cacheLength: 50,
     	createPseudo: markFunction,
     	match: matchExpr,
     	// IE6/7 return a modified href
     	attrHandle: assertHrefNotNormalized ?
     		{} :
+    		{
     			"href": function( elem ) {
     				return elem.getAttribute( "href", 2 );
     			},
     			"type": function( elem ) {
     				return elem.getAttribute("type");
+    			}
     		},
     	find: {
     		"ID": assertGetIdNotName ?
     			function( id, context, xml ) {
     				if ( typeof context.getElementById !== strundefined && !xml ) {
     					var m = context.getElementById( id );
     					// Check parentNode to catch when Blackberry 4.6 returns
     					// nodes that are no longer in the document #6963
     					return m && m.parentNode ? [m] : [];
+    				}
     			} :
     			function( id, context, xml ) {
     				if ( typeof context.getElementById !== strundefined && !xml ) {
     					var m = context.getElementById( id );
     					return m ?
     						m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ?
     							[m] :
     							undefined :
     						[];
+    				}
     			},
     		"TAG": assertTagNameNoComments ?
     			function( tag, context ) {
     				if ( typeof context.getElementsByTagName !== strundefined ) {
     					return context.getElementsByTagName( tag );
+    				}
     			} :
     			function( tag, context ) {
     				var results = context.getElementsByTagName( tag );
     				// Filter out possible comments
     				if ( tag === "*" ) {
     					var elem,
     						tmp = [],
     						i = 0;
     					for ( ; (elem = results[i]); i++ ) {
     						if ( elem.nodeType === 1 ) {
     							tmp.push( elem );
+    						}
+    					}
     					return tmp;
+    				}
     				return results;
     			},
     		"NAME": assertUsableName && function( tag, context ) {
     			if ( typeof context.getElementsByName !== strundefined ) {
     				return context.getElementsByName( name );
+    			}
     		},
     		"CLASS": assertUsableClassName && function( className, context, xml ) {
     			if ( typeof context.getElementsByClassName !== strundefined && !xml ) {
     				return context.getElementsByClassName( className );
+    			}
+    		}
     	},
     	relative: {
     		">": { dir: "parentNode", first: true },
     		" ": { dir: "parentNode" },
     		"+": { dir: "previousSibling", first: true },
     		"~": { dir: "previousSibling" }
     	},
     	preFilter: {
     		"ATTR": function( match ) {
     			match[1] = match[1].replace( rbackslash, "" );
     			// Move the given value to match[3] whether quoted or unquoted
     			match[3] = ( match[4] || match[5] || "" ).replace( rbackslash, "" );
     			if ( match[2] === "~=" ) {
     				match[3] = " " + match[3] + " ";
+    			}
     			return match.slice( 0, 4 );
     		},
     		"CHILD": function( match ) {
     			/* matches from matchExpr["CHILD"]
 type (only|nth|...)
 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
 xn-component of xn+y argument ([+-]?\d*n|)
 sign of xn-component
 x of xn-component
 sign of y-component
 y of y-component
     			*/
     			match[1] = match[1].toLowerCase();
     			if ( match[1] === "nth" ) {
     				// nth-child requires argument
     				if ( !match[2] ) {
     					Sizzle.error( match[0] );
+    				}
     				// numeric x and y parameters for Expr.filter.CHILD
     				// remember that false/true cast respectively to 0/1
     				match[3] = +( match[3] ? match[4] + (match[5] || 1) : 2 * ( match[2] === "even" || match[2] === "odd" ) );
     				match[4] = +( ( match[6] + match[7] ) || match[2] === "odd" );
     			// other types prohibit arguments
     			} else if ( match[2] ) {
     				Sizzle.error( match[0] );
+    			}
     			return match;
     		},
     		"PSEUDO": function( match ) {
     			var unquoted, excess;
     			if ( matchExpr["CHILD"].test( match[0] ) ) {
     				return null;
+    			}
     			if ( match[3] ) {
     				match[2] = match[3];
     			} else if ( (unquoted = match[4]) ) {
     				// Only check arguments that contain a pseudo
     				if ( rpseudo.test(unquoted) &&
     					// Get excess from tokenize (recursively)
     					(excess = tokenize( unquoted, true )) &&
     					// advance to the next closing parenthesis
     					(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
     					// excess is a negative index
     					unquoted = unquoted.slice( 0, excess );
     					match[0] = match[0].slice( 0, excess );
+    				}
     				match[2] = unquoted;
+    			}
     			// Return only captures needed by the pseudo filter method (type and argument)
     			return match.slice( 0, 3 );
+    		}
     	},
     	filter: {
     		"ID": assertGetIdNotName ?
     			function( id ) {
     				id = id.replace( rbackslash, "" );
     				return function( elem ) {
     					return elem.getAttribute("id") === id;
     				};
     			} :
     			function( id ) {
     				id = id.replace( rbackslash, "" );
     				return function( elem ) {
     					var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
     					return node && node.value === id;
     				};
     			},
     		"TAG": function( nodeName ) {
     			if ( nodeName === "*" ) {
     				return function() { return true; };
+    			}
     			nodeName = nodeName.replace( rbackslash, "" ).toLowerCase();
     			return function( elem ) {
     				return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
     			};
     		},
     		"CLASS": function( className ) {
     			var pattern = classCache[ expando ][ className + " " ];
     			return pattern ||
     				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
     				classCache( className, function( elem ) {
     					return pattern.test( elem.className || (typeof elem.getAttribute !== strundefined && elem.getAttribute("class")) || "" );
     				});
     		},
     		"ATTR": function( name, operator, check ) {
     			return function( elem, context ) {
     				var result = Sizzle.attr( elem, name );
     				if ( result == null ) {
     					return operator === "!=";
+    				}
     				if ( !operator ) {
     					return true;
+    				}
     				result += "";
     				return operator === "=" ? result === check :
     					operator === "!=" ? result !== check :
     					operator === "^=" ? check && result.indexOf( check ) === 0 :
     					operator === "*=" ? check && result.indexOf( check ) > -1 :
     					operator === "$=" ? check && result.substr( result.length - check.length ) === check :
     					operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
     					operator === "|=" ? result === check || result.substr( 0, check.length + 1 ) === check + "-" :
     					false;
     			};
     		},
     		"CHILD": function( type, argument, first, last ) {
     			if ( type === "nth" ) {
     				return function( elem ) {
     					var node, diff,
     						parent = elem.parentNode;
     					if ( first === 1 && last === 0 ) {
     						return true;
+    					}
     					if ( parent ) {
     						diff = 0;
     						for ( node = parent.firstChild; node; node = node.nextSibling ) {
     							if ( node.nodeType === 1 ) {
     								diff++;
     								if ( elem === node ) {
     									break;
+    								}
+    							}
+    						}
+    					}
     					// Incorporate the offset (or cast to NaN), then check against cycle size
     					diff -= last;
     					return diff === first || ( diff % first === 0 && diff / first >= 0 );
     				};
+    			}
     			return function( elem ) {
     				var node = elem;
     				switch ( type ) {
     					case "only":
     					case "first":
     						while ( (node = node.previousSibling) ) {
     							if ( node.nodeType === 1 ) {
     								return false;
+    							}
+    						}
     						if ( type === "first" ) {
     							return true;
+    						}
     						node = elem;
     						/* falls through */
     					case "last":
     						while ( (node = node.nextSibling) ) {
     							if ( node.nodeType === 1 ) {
     								return false;
+    							}
+    						}
     						return true;
+    				}
     			};
     		},
     		"PSEUDO": function( pseudo, argument ) {
     			// pseudo-class names are case-insensitive
     			// http://www.w3.org/TR/selectors/#pseudo-classes
     			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
     			// Remember that setFilters inherits from pseudos
     			var args,
     				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
     					Sizzle.error( "unsupported pseudo: " + pseudo );
     			// The user may use createPseudo to indicate that
     			// arguments are needed to create the filter function
     			// just as Sizzle does
     			if ( fn[ expando ] ) {
     				return fn( argument );
+    			}
     			// But maintain support for old signatures
     			if ( fn.length > 1 ) {
     				args = [ pseudo, pseudo, "", argument ];
     				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
     					markFunction(function( seed, matches ) {
     						var idx,
     							matched = fn( seed, argument ),
     							i = matched.length;
     						while ( i-- ) {
     							idx = indexOf.call( seed, matched[i] );
     							seed[ idx ] = !( matches[ idx ] = matched[i] );
+    						}
     					}) :
     					function( elem ) {
     						return fn( elem, 0, args );
     					};
+    			}
     			return fn;
+    		}
     	},
     	pseudos: {
     		"not": markFunction(function( selector ) {
     			// Trim the selector passed to compile
     			// to avoid treating leading and trailing
     			// spaces as combinators
     			var input = [],
     				results = [],
     				matcher = compile( selector.replace( rtrim, "$1" ) );
     			return matcher[ expando ] ?
     				markFunction(function( seed, matches, context, xml ) {
     					var elem,
     						unmatched = matcher( seed, null, xml, [] ),
     						i = seed.length;
     					// Match elements unmatched by `matcher`
     					while ( i-- ) {
     						if ( (elem = unmatched[i]) ) {
     							seed[i] = !(matches[i] = elem);
+    						}
+    					}
     				}) :
     				function( elem, context, xml ) {
     					input[0] = elem;
     					matcher( input, null, xml, results );
     					return !results.pop();
     				};
     		}),
     		"has": markFunction(function( selector ) {
     			return function( elem ) {
     				return Sizzle( selector, elem ).length > 0;
     			};
     		}),
     		"contains": markFunction(function( text ) {
     			return function( elem ) {
     				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
     			};
     		}),
     		"enabled": function( elem ) {
     			return elem.disabled === false;
     		},
     		"disabled": function( elem ) {
     			return elem.disabled === true;
     		},
     		"checked": function( elem ) {
     			// In CSS3, :checked should return both checked and selected elements
     			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
     			var nodeName = elem.nodeName.toLowerCase();
     			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
     		},
     		"selected": function( elem ) {
     			// Accessing this property makes selected-by-default
     			// options in Safari work properly
     			if ( elem.parentNode ) {
     				elem.parentNode.selectedIndex;
+    			}
     			return elem.selected === true;
     		},
     		"parent": function( elem ) {
     			return !Expr.pseudos["empty"]( elem );
     		},
     		"empty": function( elem ) {
     			// http://www.w3.org/TR/selectors/#empty-pseudo
     			// :empty is only affected by element nodes and content nodes(including text(3), cdata(4)),
     			//   not comment, processing instructions, or others
     			// Thanks to Diego Perini for the nodeName shortcut
     			//   Greater than "@" means alpha characters (specifically not starting with "#" or "?")
     			var nodeType;
     			elem = elem.firstChild;
     			while ( elem ) {
     				if ( elem.nodeName > "@" || (nodeType = elem.nodeType) === 3 || nodeType === 4 ) {
     					return false;
+    				}
     				elem = elem.nextSibling;
+    			}
     			return true;
     		},
     		"header": function( elem ) {
     			return rheader.test( elem.nodeName );
     		},
     		"text": function( elem ) {
     			var type, attr;
     			// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
     			// use getAttribute instead to test this case
     			return elem.nodeName.toLowerCase() === "input" &&
     				(type = elem.type) === "text" &&
     				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === type );
     		},
     		// Input types
     		"radio": createInputPseudo("radio"),
     		"checkbox": createInputPseudo("checkbox"),
     		"file": createInputPseudo("file"),
     		"password": createInputPseudo("password"),
     		"image": createInputPseudo("image"),
     		"submit": createButtonPseudo("submit"),
     		"reset": createButtonPseudo("reset"),
     		"button": function( elem ) {
     			var name = elem.nodeName.toLowerCase();
     			return name === "input" && elem.type === "button" || name === "button";
     		},
     		"input": function( elem ) {
     			return rinputs.test( elem.nodeName );
     		},
     		"focus": function( elem ) {
     			var doc = elem.ownerDocument;
     			return elem === doc.activeElement && (!doc.hasFocus || doc.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
     		},
     		"active": function( elem ) {
     			return elem === elem.ownerDocument.activeElement;
     		},
     		// Positional types
     		"first": createPositionalPseudo(function() {
     			return [ 0 ];
     		}),
     		"last": createPositionalPseudo(function( matchIndexes, length ) {
     			return [ length - 1 ];
     		}),
     		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
     			return [ argument < 0 ? argument + length : argument ];
     		}),
     		"even": createPositionalPseudo(function( matchIndexes, length ) {
     			for ( var i = 0; i < length; i += 2 ) {
     				matchIndexes.push( i );
+    			}
     			return matchIndexes;
     		}),
     		"odd": createPositionalPseudo(function( matchIndexes, length ) {
     			for ( var i = 1; i < length; i += 2 ) {
     				matchIndexes.push( i );
+    			}
     			return matchIndexes;
     		}),
     		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
     			for ( var i = argument < 0 ? argument + length : argument; --i >= 0; ) {
     				matchIndexes.push( i );
+    			}
     			return matchIndexes;
     		}),
     		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
     			for ( var i = argument < 0 ? argument + length : argument; ++i < length; ) {
     				matchIndexes.push( i );
+    			}
     			return matchIndexes;
     		})
+    	}
     };
     function siblingCheck( a, b, ret ) {
     	if ( a === b ) {
     		return ret;
+    	}
     	var cur = a.nextSibling;
     	while ( cur ) {
     		if ( cur === b ) {
     			return -1;
+    		}
     		cur = cur.nextSibling;
+    	}
     	return 1;
+    }
     sortOrder = docElem.compareDocumentPosition ?
     	function( a, b ) {
     		if ( a === b ) {
     			hasDuplicate = true;
     			return 0;
+    		}
     		return ( !a.compareDocumentPosition || !b.compareDocumentPosition ?
     			a.compareDocumentPosition :
     			a.compareDocumentPosition(b) & 4
     		) ? -1 : 1;
     	} :
     	function( a, b ) {
     		// The nodes are identical, we can exit early
     		if ( a === b ) {
     			hasDuplicate = true;
     			return 0;
     		// Fallback to using sourceIndex (in IE) if it's available on both nodes
     		} else if ( a.sourceIndex && b.sourceIndex ) {
     			return a.sourceIndex - b.sourceIndex;
+    		}
     		var al, bl,
     			ap = [],
     			bp = [],
     			aup = a.parentNode,
     			bup = b.parentNode,
     			cur = aup;
     		// If the nodes are siblings (or identical) we can do a quick check
     		if ( aup === bup ) {
     			return siblingCheck( a, b );
     		// If no parents were found then the nodes are disconnected
     		} else if ( !aup ) {
     			return -1;
     		} else if ( !bup ) {
     			return 1;
+    		}
     		// Otherwise they're somewhere else in the tree so we need
     		// to build up a full list of the parentNodes for comparison
     		while ( cur ) {
     			ap.unshift( cur );
     			cur = cur.parentNode;
+    		}
     		cur = bup;
     		while ( cur ) {
     			bp.unshift( cur );
     			cur = cur.parentNode;
+    		}
     		al = ap.length;
     		bl = bp.length;
     		// Start walking down the tree looking for a discrepancy
     		for ( var i = 0; i < al && i < bl; i++ ) {
     			if ( ap[i] !== bp[i] ) {
     				return siblingCheck( ap[i], bp[i] );
+    			}
+    		}
     		// We ended someplace up the tree so do a sibling check
     		return i === al ?
     			siblingCheck( a, bp[i], -1 ) :
     			siblingCheck( ap[i], b, 1 );
     	};
     // Always assume the presence of duplicates if sort doesn't
     // pass them to our comparison function (as in Google Chrome).
     [0, 0].sort( sortOrder );
     baseHasDuplicate = !hasDuplicate;
     // Document sorting and removing duplicates
     Sizzle.uniqueSort = function( results ) {
     	var elem,
     		duplicates = [],
     		i = 1,
     		j = 0;
     	hasDuplicate = baseHasDuplicate;
     	results.sort( sortOrder );
     	if ( hasDuplicate ) {
     		for ( ; (elem = results[i]); i++ ) {
     			if ( elem === results[ i - 1 ] ) {
     				j = duplicates.push( i );
+    			}
+    		}
     		while ( j-- ) {
     			results.splice( duplicates[ j ], 1 );
+    		}
+    	}
     	return results;
     };
     Sizzle.error = function( msg ) {
     	throw new Error( "Syntax error, unrecognized expression: " + msg );
     };
     function tokenize( selector, parseOnly ) {
     	var matched, match, tokens, type,
     		soFar, groups, preFilters,
     		cached = tokenCache[ expando ][ selector + " " ];
     	if ( cached ) {
     		return parseOnly ? 0 : cached.slice( 0 );
+    	}
     	soFar = selector;
     	groups = [];
     	preFilters = Expr.preFilter;
     	while ( soFar ) {
     		// Comma and first run
     		if ( !matched || (match = rcomma.exec( soFar )) ) {
     			if ( match ) {
     				// Don't consume trailing commas as valid
     				soFar = soFar.slice( match[0].length ) || soFar;
+    			}
     			groups.push( tokens = [] );
+    		}
     		matched = false;
     		// Combinators
     		if ( (match = rcombinators.exec( soFar )) ) {
     			tokens.push( matched = new Token( match.shift() ) );
     			soFar = soFar.slice( matched.length );
     			// Cast descendant combinators to space
     			matched.type = match[0].replace( rtrim, " " );
+    		}
     		// Filters
     		for ( type in Expr.filter ) {
     			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
     				(match = preFilters[ type ]( match ))) ) {
     				tokens.push( matched = new Token( match.shift() ) );
     				soFar = soFar.slice( matched.length );
     				matched.type = type;
     				matched.matches = match;
+    			}
+    		}
     		if ( !matched ) {
     			break;
+    		}
+    	}
     	// Return the length of the invalid excess
     	// if we're just parsing
     	// Otherwise, throw an error or return tokens
     	return parseOnly ?
     		soFar.length :
     		soFar ?
     			Sizzle.error( selector ) :
     			// Cache the tokens
     			tokenCache( selector, groups ).slice( 0 );
+    }
     function addCombinator( matcher, combinator, base ) {
     	var dir = combinator.dir,
     		checkNonElements = base && combinator.dir === "parentNode",
     		doneName = done++;
     	return combinator.first ?
     		// Check against closest ancestor/preceding element
     		function( elem, context, xml ) {
     			while ( (elem = elem[ dir ]) ) {
     				if ( checkNonElements || elem.nodeType === 1  ) {
     					return matcher( elem, context, xml );
+    				}
+    			}
     		} :
     		// Check against all ancestor/preceding elements
     		function( elem, context, xml ) {
     			// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
     			if ( !xml ) {
     				var cache,
     					dirkey = dirruns + " " + doneName + " ",
     					cachedkey = dirkey + cachedruns;
     				while ( (elem = elem[ dir ]) ) {
     					if ( checkNonElements || elem.nodeType === 1 ) {
     						if ( (cache = elem[ expando ]) === cachedkey ) {
     							return elem.sizset;
     						} else if ( typeof cache === "string" && cache.indexOf(dirkey) === 0 ) {
     							if ( elem.sizset ) {
     								return elem;

... Ce différentiel a été tronqué car il excède la taille maximale pouvant être affichée.

Formats disponibles : Unified diff