https://adrien-fabre.com/Simulation%20impot/jquery.js

1/*!
2 * jQuery JavaScript Library v1.11.0
3 * http://jquery.com/
4 *
5 * Includes Sizzle.js
6 * http://sizzlejs.com/
7 *
8 * Copyright 2005, 2014 jQuery Foundation, Inc. and other contributors
9 * Released under the MIT license
10 * http://jquery.org/license
11 *
12 * Date: 2014-01-23T21:02Z
13 */
14
15(function( global, factory ) {
16
17	if ( typeof module === "object" && typeof module.exports === "object" ) {
18		// For CommonJS and CommonJS-like environments where a proper window is present,
19		// execute the factory and get jQuery
20		// For environments that do not inherently posses a window with a document
21		// (such as Node.js), expose a jQuery-making factory as module.exports
22		// This accentuates the need for the creation of a real window
23		// e.g. var jQuery = require("jquery")(window);
24		// See ticket #14549 for more info
25		module.exports = global.document ?
26			factory( global, true ) :
27			function( w ) {
28				if ( !w.document ) {
29					throw new Error( "jQuery requires a window with a document" );
30				}
31				return factory( w );
32			};
33	} else {
34		factory( global );
35	}
36
37// Pass this if window is not defined yet
38}(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
39
40// Can't do this because several apps including ASP.NET trace
41// the stack via arguments.caller.callee and Firefox dies if
42// you try to trace through "use strict" call chains. (#13335)
43// Support: Firefox 18+
44//
45
46var deletedIds = [];
47
48var slice = deletedIds.slice;
49
50var concat = deletedIds.concat;
51
52var push = deletedIds.push;
53
54var indexOf = deletedIds.indexOf;
55
56var class2type = {};
57
58var toString = class2type.toString;
59
60var hasOwn = class2type.hasOwnProperty;
61
62var trim = "".trim;
63
64var support = {};
65
66
67
68var
69	version = "1.11.0",
70
71	// Define a local copy of jQuery
72	jQuery = function( selector, context ) {
73		// The jQuery object is actually just the init constructor 'enhanced'
74		// Need init if jQuery is called (just allow error to be thrown if not included)
75		return new jQuery.fn.init( selector, context );
76	},
77
78	// Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
79	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
80
81	// Matches dashed string for camelizing
82	rmsPrefix = /^-ms-/,
83	rdashAlpha = /-([\da-z])/gi,
84
85	// Used by jQuery.camelCase as callback to replace()
86	fcamelCase = function( all, letter ) {
87		return letter.toUpperCase();
88	};
89
90jQuery.fn = jQuery.prototype = {
91	// The current version of jQuery being used
92	jquery: version,
93
94	constructor: jQuery,
95
96	// Start with an empty selector
97	selector: "",
98
99	// The default length of a jQuery object is 0
100	length: 0,
101
102	toArray: function() {
103		return slice.call( this );
104	},
105
106	// Get the Nth element in the matched element set OR
107	// Get the whole matched element set as a clean array
108	get: function( num ) {
109		return num != null ?
110
111			// Return a 'clean' array
112			( num < 0 ? this[ num + this.length ] : this[ num ] ) :
113
114			// Return just the object
115			slice.call( this );
116	},
117
118	// Take an array of elements and push it onto the stack
119	// (returning the new matched element set)
120	pushStack: function( elems ) {
121
122		// Build a new jQuery matched element set
123		var ret = jQuery.merge( this.constructor(), elems );
124
125		// Add the old object onto the stack (as a reference)
126		ret.prevObject = this;
127		ret.context = this.context;
128
129		// Return the newly-formed element set
130		return ret;
131	},
132
133	// Execute a callback for every element in the matched set.
134	// (You can seed the arguments with an array of args, but this is
135	// only used internally.)
136	each: function( callback, args ) {
137		return jQuery.each( this, callback, args );
138	},
139
140	map: function( callback ) {
141		return this.pushStack( jQuery.map(this, function( elem, i ) {
142			return callback.call( elem, i, elem );
143		}));
144	},
145
146	slice: function() {
147		return this.pushStack( slice.apply( this, arguments ) );
148	},
149
150	first: function() {
151		return this.eq( 0 );
152	},
153
154	last: function() {
155		return this.eq( -1 );
156	},
157
158	eq: function( i ) {
159		var len = this.length,
160			j = +i + ( i < 0 ? len : 0 );
161		return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
162	},
163
164	end: function() {
165		return this.prevObject || this.constructor(null);
166	},
167
168	// For internal use only.
169	// Behaves like an Array's method, not like a jQuery method.
170	push: push,
171	sort: deletedIds.sort,
172	splice: deletedIds.splice
173};
174
175jQuery.extend = jQuery.fn.extend = function() {
176	var src, copyIsArray, copy, name, options, clone,
177		target = arguments[0] || {},
178		i = 1,
179		length = arguments.length,
180		deep = false;

859				newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context;
860				newSelector = groups.join(",");
861			}
862
863			if ( newSelector ) {
864				try {
865					push.apply( results,
866						newContext.querySelectorAll( newSelector )
867					);
868					return results;
869				} catch(qsaError) {
870				} finally {
871					if ( !old ) {
872						context.removeAttribute("id");
873					}
874				}
875			}
876		}
877	}
878
879	// All others
880	return select( selector.replace( rtrim, "$1" ), context, results, seed );
881}
882
883/**
884 * Create key-value caches of limited size
885 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
886 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
887 *	deleting the oldest entry
888 */
889function createCache() {
890	var keys = [];
891
892	function cache( key, value ) {
893		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
894		if ( keys.push( key + " " ) > Expr.cacheLength ) {
895			// Only keep the most recent entries
896			delete cache[ keys.shift() ];
897		}
898		return (cache[ key + " " ] = value);
899	}
900	return cache;
901}
902
903/**
904 * Mark a function for special use by Sizzle
905 * @param {Function} fn The function to mark
906 */
907function markFunction( fn ) {
908	fn[ expando ] = true;
909	return fn;
910}
911
912/**
913 * Support testing using an element
914 * @param {Function} fn Passed the created div and expects a boolean result
915 */
916function assert( fn ) {
917	var div = document.createElement("div");
918
919	try {
920		return !!fn( div );
921	} catch (e) {
922		return false;
923	} finally {
924		// Remove from its parent by default
925		if ( div.parentNode ) {
926			div.parentNode.removeChild( div );
927		}
928		// release memory in IE
929		div = null;
930	}
931}
932
933/**
934 * Adds the same handler for all of the specified attrs
935 * @param {String} attrs Pipe-separated list of attributes
936 * @param {Function} handler The method that will be applied
937 */
938function addHandle( attrs, handler ) {
939	var arr = attrs.split("|"),
940		i = attrs.length;
941
942	while ( i-- ) {
943		Expr.attrHandle[ arr[i] ] = handler;
944	}
945}
946
947/**
948 * Checks document order of two siblings
949 * @param {Element} a
950 * @param {Element} b
951 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
952 */
953function siblingCheck( a, b ) {
954	var cur = b && a,
955		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
956			( ~b.sourceIndex || MAX_NEGATIVE ) -
957			( ~a.sourceIndex || MAX_NEGATIVE );
958
959	// Use IE sourceIndex if available on both nodes
960	if ( diff ) {
961		return diff;
962	}
963
964	// Check if b follows a
965	if ( cur ) {
966		while ( (cur = cur.nextSibling) ) {
967			if ( cur === b ) {
968				return -1;
969			}
970		}
971	}
972
973	return a ? 1 : -1;
974}
975
976/**
977 * Returns a function to use in pseudos for input types
978 * @param {String} type
979 */
980function createInputPseudo( type ) {
981	return function( elem ) {
982		var name = elem.nodeName.toLowerCase();
983		return name === "input" && elem.type === type;
984	};
985}
986
987/**
988 * Returns a function to use in pseudos for buttons
989 * @param {String} type
990 */
991function createButtonPseudo( type ) {
992	return function( elem ) {
993		var name = elem.nodeName.toLowerCase();
994		return (name === "input" || name === "button") && elem.type === type;
995	};
996}
997
998/**
999 * Returns a function to use in pseudos for positionals
1000 * @param {Function} fn
1001 */
1002function createPositionalPseudo( fn ) {
1003	return markFunction(function( argument ) {
1004		argument = +argument;
1005		return markFunction(function( seed, matches ) {
1006			var j,
1007				matchIndexes = fn( [], seed.length, argument ),
1008				i = matchIndexes.length;
1009
1010			// Match elements found at the specified indexes
1011			while ( i-- ) {
1012				if ( seed[ (j = matchIndexes[i]) ] ) {
1013					seed[j] = !(matches[j] = seed[j]);
1014				}
1015			}
1016		});
1017	});
1018}
1019
1020/**
1021 * Checks a node for validity as a Sizzle context
1022 * @param {Element|Object=} context
1023 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1024 */
1025function testContext( context ) {
1026	return context && typeof context.getElementsByTagName !== strundefined && context;
1027}
1028
1029// Expose support vars for convenience
1030support = Sizzle.support = {};
1031
1032/**
1033 * Detects XML nodes
1034 * @param {Element|Object} elem An element or a document
1035 * @returns {Boolean} True iff elem is a non-HTML XML node
1036 */
1037isXML = Sizzle.isXML = function( elem ) {
1038	// documentElement is verified for cases where it doesn't yet exist
1039	// (such as loading iframes in IE - #4833)
1040	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1041	return documentElement ? documentElement.nodeName !== "HTML" : false;

1140		// Support: IE6/7
1141		// getElementById is not reliable as a find shortcut
1142		delete Expr.find["ID"];
1143
1144		Expr.filter["ID"] =  function( id ) {
1145			var attrId = id.replace( runescape, funescape );
1146			return function( elem ) {
1147				var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
1148				return node && node.value === attrId;
1149			};
1150		};
1151	}
1152
1153	// Tag
1154	Expr.find["TAG"] = support.getElementsByTagName ?
1155		function( tag, context ) {
1156			if ( typeof context.getElementsByTagName !== strundefined ) {
1157				return context.getElementsByTagName( tag );
1158			}
1159		} :
1160		function( tag, context ) {
1161			var elem,
1162				tmp = [],
1163				i = 0,
1164				results = context.getElementsByTagName( tag );
1165
1166			// Filter out possible comments
1167			if ( tag === "*" ) {
1168				while ( (elem = results[i++]) ) {
1169					if ( elem.nodeType === 1 ) {
1170						tmp.push( elem );
1171					}
1172				}
1173
1174				return tmp;
1175			}
1176			return results;
1177		};
1178
1179	// Class
1180	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1181		if ( typeof context.getElementsByClassName !== strundefined && documentIsHTML ) {
1182			return context.getElementsByClassName( className );
1183		}
1184	};
1185
1186	/* QSA/matchesSelector
1187	---------------------------------------------------------------------- */
1188
1189	// QSA and matchesSelector support
1190
1191	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1192	rbuggyMatches = [];
1193
1194	// qSa(:focus) reports false when true (Chrome 21)
1195	// We allow this because of a bug in IE8/9 that throws an error
1196	// whenever `document.activeElement` is accessed on an iframe
1197	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1198	// See http://bugs.jquery.com/ticket/13378
1199	rbuggyQSA = [];
1200
1201	if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {
1202		// Build QSA regex
1203		// Regex strategy adopted from Diego Perini
1204		assert(function( div ) {
1205			// Select is set to empty string on purpose
1206			// This is to test IE's treatment of not explicitly
1207			// setting a boolean content attribute,
1208			// since its presence should be enough
1209			// http://bugs.jquery.com/ticket/12359
1210			div.innerHTML = "<select t=''><option selected=''></option></select>";
1211
1212			// Support: IE8, Opera 10-12
1213			// Nothing should be selected when empty strings follow ^= or $= or *=
1214			if ( div.querySelectorAll("[t^='']").length ) {
1215				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1216			}
1217
1218			// Support: IE8
1219			// Boolean attributes and "value" are not treated correctly
1220			if ( !div.querySelectorAll("[selected]").length ) {
1221				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1222			}
1223
1224			// Webkit/Opera - :checked should return selected option elements
1225			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1226			// IE8 throws error here and will not see later tests
1227			if ( !div.querySelectorAll(":checked").length ) {
1228				rbuggyQSA.push(":checked");
1229			}
1230		});
1231
1232		assert(function( div ) {
1233			// Support: Windows 8 Native Apps
1234			// The type and name attributes are restricted during .innerHTML assignment
1235			var input = doc.createElement("input");
1236			input.setAttribute( "type", "hidden" );
1237			div.appendChild( input ).setAttribute( "name", "D" );
1238
1239			// Support: IE8
1240			// Enforce case-sensitivity of name attribute
1241			if ( div.querySelectorAll("[name=d]").length ) {
1242				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1243			}
1244
1245			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1246			// IE8 throws error here and will not see later tests
1247			if ( !div.querySelectorAll(":enabled").length ) {
1248				rbuggyQSA.push( ":enabled", ":disabled" );
1249			}
1250
1251			// Opera 10-11 does not throw on post-comma invalid pseudos
1252			div.querySelectorAll("*,:x");
1253			rbuggyQSA.push(",.*:");
1254		});
1255	}
1256
1257	if ( (support.matchesSelector = rnative.test( (matches = docElem.webkitMatchesSelector ||
1258		docElem.mozMatchesSelector ||
1259		docElem.oMatchesSelector ||
1260		docElem.msMatchesSelector) )) ) {
1261
1262		assert(function( div ) {
1263			// Check to see if it's possible to do matchesSelector
1264			// on a disconnected node (IE 9)
1265			support.disconnectedMatch = matches.call( div, "div" );
1266
1267			// This should fail with an exception
1268			// Gecko does not error, returns false instead
1269			matches.call( div, "[s!='']:x" );
1270			rbuggyMatches.push( "!=", pseudos );
1271		});
1272	}
1273
1274	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1275	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1276
1277	/* Contains
1278	---------------------------------------------------------------------- */
1279	hasCompare = rnative.test( docElem.compareDocumentPosition );
1280
1281	// Element contains another
1282	// Purposefully does not implement inclusive descendent
1283	// As in, an element does not contain itself
1284	contains = hasCompare || rnative.test( docElem.contains ) ?
1285		function( a, b ) {
1286			var adown = a.nodeType === 9 ? a.documentElement : a,
1287				bup = b && b.parentNode;
1288			return a === bup || !!( bup && bup.nodeType === 1 && (
1289				adown.contains ?
1290					adown.contains( bup ) :
1291					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1292			));
1293		} :
1294		function( a, b ) {
1295			if ( b ) {
1296				while ( (b = b.parentNode) ) {
1297					if ( b === a ) {
1298						return true;
1299					}
1300				}
1301			}
1302			return false;
1303		};
1304
1305	/* Sorting
1306	---------------------------------------------------------------------- */
1307
1308	// Document order sorting
1309	sortOrder = hasCompare ?
1310	function( a, b ) {
1311
1312		// Flag for duplicate removal
1313		if ( a === b ) {
1314			hasDuplicate = true;
1315			return 0;
1316		}
1317
1318		// Sort on method existence if only one input has compareDocumentPosition
1319		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1320		if ( compare ) {
1321			return compare;
1322		}
1323
1324		// Calculate position if both inputs belong to the same document
1325		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
1326			a.compareDocumentPosition( b ) :
1327
1328			// Otherwise we know they are disconnected
1329			1;
1330
1331		// Disconnected nodes
1332		if ( compare & 1 ||
1333			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1334
1335			// Choose the first element that is related to our preferred document
1336			if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
1337				return -1;
1338			}
1339			if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
1340				return 1;
1341			}
1342
1343			// Maintain original order
1344			return sortInput ?
1345				( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1346				0;
1347		}
1348
1349		return compare & 4 ? -1 : 1;
1350	} :
1351	function( a, b ) {
1352		// Exit early if the nodes are identical
1353		if ( a === b ) {
1354			hasDuplicate = true;
1355			return 0;
1356		}
1357
1358		var cur,
1359			i = 0,
1360			aup = a.parentNode,
1361			bup = b.parentNode,
1362			ap = [ a ],
1363			bp = [ b ];
1364
1365		// Parentless nodes are either documents or disconnected
1366		if ( !aup || !bup ) {
1367			return a === doc ? -1 :
1368				b === doc ? 1 :
1369				aup ? -1 :
1370				bup ? 1 :
1371				sortInput ?
1372				( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1373				0;
1374
1375		// If the nodes are siblings, we can do a quick check
1376		} else if ( aup === bup ) {
1377			return siblingCheck( a, b );
1378		}
1379
1380		// Otherwise we need full lists of their ancestors for comparison
1381		cur = a;
1382		while ( (cur = cur.parentNode) ) {
1383			ap.unshift( cur );
1384		}
1385		cur = b;
1386		while ( (cur = cur.parentNode) ) {
1387			bp.unshift( cur );
1388		}
1389
1390		// Walk down the tree looking for a discrepancy
1391		while ( ap[i] === bp[i] ) {
1392			i++;
1393		}
1394
1395		return i ?
1396			// Do a sibling check if the nodes have a common ancestor
1397			siblingCheck( ap[i], bp[i] ) :
1398
1399			// Otherwise nodes in our document sort first
1400			ap[i] === preferredDoc ? -1 :
1401			bp[i] === preferredDoc ? 1 :
1402			0;
1403	};
1404
1405	return doc;
1406};
1407
1408Sizzle.matches = function( expr, elements ) {
1409	return Sizzle( expr, null, null, elements );
1410};
1411
1412Sizzle.matchesSelector = function( elem, expr ) {
1413	// Set document vars if needed
1414	if ( ( elem.ownerDocument || elem ) !== document ) {
1415		setDocument( elem );
1416	}
1417
1418	// Make sure that attribute selectors are quoted
1419	expr = expr.replace( rattributeQuotes, "='$1']" );
1420
1421	if ( support.matchesSelector && documentIsHTML &&
1422		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1423		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1424
1425		try {
1426			var ret = matches.call( elem, expr );
1427
1428			// IE 9's matchesSelector returns false on disconnected nodes
1429			if ( ret || support.disconnectedMatch ||
1430					// As well, disconnected nodes are said to be in a document
1431					// fragment in IE 9
1432					elem.document && elem.document.nodeType !== 11 ) {
1433				return ret;
1434			}
1435		} catch(e) {}
1436	}
1437
1438	return Sizzle( expr, document, null, [elem] ).length > 0;
1439};
1440
1441Sizzle.contains = function( context, elem ) {
1442	// Set document vars if needed
1443	if ( ( context.ownerDocument || context ) !== document ) {
1444		setDocument( context );
1445	}
1446	return contains( context, elem );
1447};
1448
1449Sizzle.attr = function( elem, name ) {
1450	// Set document vars if needed
1451	if ( ( elem.ownerDocument || elem ) !== document ) {
1452		setDocument( elem );
1453	}
1454
1455	var fn = Expr.attrHandle[ name.toLowerCase() ],
1456		// Don't get fooled by Object.prototype properties (jQuery #13807)
1457		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1458			fn( elem, name, !documentIsHTML ) :
1459			undefined;
1460
1461	return val !== undefined ?
1462		val :
1463		support.attributes || !documentIsHTML ?
1464			elem.getAttribute( name ) :
1465			(val = elem.getAttributeNode(name)) && val.specified ?
1466				val.value :
1467				null;
1468};
1469
1470Sizzle.error = function( msg ) {
1471	throw new Error( "Syntax error, unrecognized expression: " + msg );
1472};
1473
1474/**
1475 * Document sorting and removing duplicates
1476 * @param {ArrayLike} results
1477 */
1478Sizzle.uniqueSort = function( results ) {
1479	var elem,
1480		duplicates = [],
1481		j = 0,
1482		i = 0;
1483
1484	// Unless we *know* we can detect duplicates, assume their presence
1485	hasDuplicate = !support.detectDuplicates;
1486	sortInput = !support.sortStable && results.slice( 0 );
1487	results.sort( sortOrder );
1488
1489	if ( hasDuplicate ) {
1490		while ( (elem = results[i++]) ) {
1491			if ( elem === results[ i ] ) {
1492				j = duplicates.push( i );
1493			}
1494		}
1495		while ( j-- ) {
1496			results.splice( duplicates[ j ], 1 );
1497		}
1498	}
1499
1500	// Clear input after sorting to release objects
1501	// See https://github.com/jquery/sizzle/pull/225
1502	sortInput = null;
1503
1504	return results;
1505};
1506
1507/**
1508 * Utility function for retrieving the text value of an array of DOM nodes
1509 * @param {Array|Element} elem
1510 */
1511getText = Sizzle.getText = function( elem ) {
1512	var node,
1513		ret = "",
1514		i = 0,
1515		nodeType = elem.nodeType;
1516
1517	if ( !nodeType ) {
1518		// If no nodeType, this is expected to be an array
1519		while ( (node = elem[i++]) ) {
1520			// Do not traverse comment nodes
1521			ret += getText( node );
1522		}
1523	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1524		// Use textContent for elements
1525		// innerText usage removed for consistency of new lines (jQuery #11153)
1526		if ( typeof elem.textContent === "string" ) {
1527			return elem.textContent;
1528		} else {
1529			// Traverse its children
1530			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1531				ret += getText( elem );
1532			}
1533		}
1534	} else if ( nodeType === 3 || nodeType === 4 ) {
1535		return elem.nodeValue;
1536	}
1537	// Do not include comment or processing instruction nodes
1538
1539	return ret;
1540};
1541
1542Expr = Sizzle.selectors = {
1543
1544	// Can be adjusted by the user
1545	cacheLength: 50,
1546
1547	createPseudo: markFunction,
1548
1549	match: matchExpr,
1550
1551	attrHandle: {},
1552
1553	find: {},
1554
1555	relative: {
1556		">": { dir: "parentNode", first: true },
1557		" ": { dir: "parentNode" },
1558		"+": { dir: "previousSibling", first: true },
1559		"~": { dir: "previousSibling" }
1560	},
1561
1562	preFilter: {
1563		"ATTR": function( match ) {
1564			match[1] = match[1].replace( runescape, funescape );
1565
1566			// Move the given value to match[3] whether quoted or unquoted
1567			match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape );
1568
1569			if ( match[2] === "~=" ) {
1570				match[3] = " " + match[3] + " ";
1571			}
1572
1573			return match.slice( 0, 4 );
1574		},
1575
1576		"CHILD": function( match ) {
1577			/* matches from matchExpr["CHILD"]
1578				1 type (only|nth|...)
1579				2 what (child|of-type)
1580				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1581				4 xn-component of xn+y argument ([+-]?\d*n|)
1582				5 sign of xn-component
1583				6 x of xn-component
1584				7 sign of y-component
1585				8 y of y-component
1586			*/
1587			match[1] = match[1].toLowerCase();
1588
1589			if ( match[1].slice( 0, 3 ) === "nth" ) {
1590				// nth-* requires argument
1591				if ( !match[3] ) {
1592					Sizzle.error( match[0] );
1593				}
1594
1595				// numeric x and y parameters for Expr.filter.CHILD
1596				// remember that false/true cast respectively to 0/1
1597				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1598				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1599
1600			// other types prohibit arguments
1601			} else if ( match[3] ) {
1602				Sizzle.error( match[0] );
1603			}
1604
1605			return match;
1606		},
1607
1608		"PSEUDO": function( match ) {
1609			var excess,
1610				unquoted = !match[5] && match[2];
1611
1612			if ( matchExpr["CHILD"].test( match[0] ) ) {
1613				return null;
1614			}
1615
1616			// Accept quoted arguments as-is
1617			if ( match[3] && match[4] !== undefined ) {
1618				match[2] = match[4];
1619
1620			// Strip excess characters from unquoted arguments
1621			} else if ( unquoted && rpseudo.test( unquoted ) &&
1622				// Get excess from tokenize (recursively)
1623				(excess = tokenize( unquoted, true )) &&
1624				// advance to the next closing parenthesis
1625				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
1626
1627				// excess is a negative index
1628				match[0] = match[0].slice( 0, excess );
1629				match[2] = unquoted.slice( 0, excess );
1630			}
1631
1632			// Return only captures needed by the pseudo filter method (type and argument)
1633			return match.slice( 0, 3 );
1634		}
1635	},
1636
1637	filter: {
1638
1639		"TAG": function( nodeNameSelector ) {
1640			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1641			return nodeNameSelector === "*" ?
1642				function() { return true; } :
1643				function( elem ) {
1644					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1645				};
1646		},
1647
1648		"CLASS": function( className ) {
1649			var pattern = classCache[ className + " " ];
1650
1651			return pattern ||
1652				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
1653				classCache( className, function( elem ) {
1654					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute("class") || "" );
1655				});
1656		},
1657
1658		"ATTR": function( name, operator, check ) {
1659			return function( elem ) {
1660				var result = Sizzle.attr( elem, name );
1661
1662				if ( result == null ) {
1663					return operator === "!=";
1664				}
1665				if ( !operator ) {
1666					return true;
1667				}
1668
1669				result += "";
1670
1671				return operator === "=" ? result === check :
1672					operator === "!=" ? result !== check :
1673					operator === "^=" ? check && result.indexOf( check ) === 0 :
1674					operator === "*=" ? check && result.indexOf( check ) > -1 :
1675					operator === "$=" ? check && result.slice( -check.length ) === check :
1676					operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
1677					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1678					false;
1679			};
1680		},
1681
1682		"CHILD": function( type, what, argument, first, last ) {
1683			var simple = type.slice( 0, 3 ) !== "nth",
1684				forward = type.slice( -4 ) !== "last",
1685				ofType = what === "of-type";
1686
1687			return first === 1 && last === 0 ?
1688
1689				// Shortcut for :nth-*(n)
1690				function( elem ) {
1691					return !!elem.parentNode;
1692				} :
1693
1694				function( elem, context, xml ) {
1695					var cache, outerCache, node, diff, nodeIndex, start,
1696						dir = simple !== forward ? "nextSibling" : "previousSibling",
1697						parent = elem.parentNode,
1698						name = ofType && elem.nodeName.toLowerCase(),
1699						useCache = !xml && !ofType;
1700
1701					if ( parent ) {
1702
1703						// :(first|last|only)-(child|of-type)
1704						if ( simple ) {
1705							while ( dir ) {
1706								node = elem;
1707								while ( (node = node[ dir ]) ) {
1708									if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
1709										return false;
1710									}
1711								}
1712								// Reverse direction for :only-* (if we haven't yet done so)
1713								start = dir = type === "only" && !start && "nextSibling";
1714							}
1715							return true;
1716						}
1717
1718						start = [ forward ? parent.firstChild : parent.lastChild ];
1719
1720						// non-xml :nth-child(...) stores cache data on `parent`
1721						if ( forward && useCache ) {
1722							// Seek `elem` from a previously-cached index
1723							outerCache = parent[ expando ] || (parent[ expando ] = {});
1724							cache = outerCache[ type ] || [];
1725							nodeIndex = cache[0] === dirruns && cache[1];
1726							diff = cache[0] === dirruns && cache[2];
1727							node = nodeIndex && parent.childNodes[ nodeIndex ];
1728
1729							while ( (node = ++nodeIndex && node && node[ dir ] ||
1730
1731								// Fallback to seeking `elem` from the start
1732								(diff = nodeIndex = 0) || start.pop()) ) {
1733
1734								// When found, cache indexes on `parent` and break
1735								if ( node.nodeType === 1 && ++diff && node === elem ) {
1736									outerCache[ type ] = [ dirruns, nodeIndex, diff ];
1737									break;
1738								}
1739							}
1740
1741						// Use previously-cached element index if available
1742						} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
1743							diff = cache[1];
1744
1745						// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
1746						} else {
1747							// Use the same loop as above to seek `elem` from the start
1748							while ( (node = ++nodeIndex && node && node[ dir ] ||
1749								(diff = nodeIndex = 0) || start.pop()) ) {
1750
1751								if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
1752									// Cache the index of each encountered element
1753									if ( useCache ) {
1754										(node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
1755									}
1756
1757									if ( node === elem ) {
1758										break;
1759									}
1760								}
1761							}
1762						}
1763
1764						// Incorporate the offset, then check against cycle size
1765						diff -= last;
1766						return diff === first || ( diff % first === 0 && diff / first >= 0 );
1767					}
1768				};
1769		},
1770
1771		"PSEUDO": function( pseudo, argument ) {
1772			// pseudo-class names are case-insensitive
1773			// http://www.w3.org/TR/selectors/#pseudo-classes
1774			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1775			// Remember that setFilters inherits from pseudos
1776			var args,
1777				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
1778					Sizzle.error( "unsupported pseudo: " + pseudo );
1779
1780			// The user may use createPseudo to indicate that
1781			// arguments are needed to create the filter function
1782			// just as Sizzle does
1783			if ( fn[ expando ] ) {
1784				return fn( argument );
1785			}
1786
1787			// But maintain support for old signatures
1788			if ( fn.length > 1 ) {
1789				args = [ pseudo, pseudo, "", argument ];
1790				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
1791					markFunction(function( seed, matches ) {
1792						var idx,
1793							matched = fn( seed, argument ),
1794							i = matched.length;
1795						while ( i-- ) {
1796							idx = indexOf.call( seed, matched[i] );
1797							seed[ idx ] = !( matches[ idx ] = matched[i] );
1798						}
1799					}) :
1800					function( elem ) {
1801						return fn( elem, 0, args );
1802					};
1803			}
1804
1805			return fn;
1806		}
1807	},
1808
1809	pseudos: {
1810		// Potentially complex pseudos
1811		"not": markFunction(function( selector ) {
1812			// Trim the selector passed to compile
1813			// to avoid treating leading and trailing
1814			// spaces as combinators
1815			var input = [],
1816				results = [],
1817				matcher = compile( selector.replace( rtrim, "$1" ) );
1818
1819			return matcher[ expando ] ?
1820				markFunction(function( seed, matches, context, xml ) {
1821					var elem,
1822						unmatched = matcher( seed, null, xml, [] ),
1823						i = seed.length;
1824
1825					// Match elements unmatched by `matcher`
1826					while ( i-- ) {
1827						if ( (elem = unmatched[i]) ) {
1828							seed[i] = !(matches[i] = elem);
1829						}
1830					}
1831				}) :
1832				function( elem, context, xml ) {
1833					input[0] = elem;
1834					matcher( input, null, xml, results );
1835					return !results.pop();
1836				};
1837		}),
1838
1839		"has": markFunction(function( selector ) {
1840			return function( elem ) {
1841				return Sizzle( selector, elem ).length > 0;
1842			};
1843		}),
1844
1845		"contains": markFunction(function( text ) {
1846			return function( elem ) {
1847				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
1848			};
1849		}),
1850
1851		// "Whether an element is represented by a :lang() selector
1852		// is based solely on the element's language value
1853		// being equal to the identifier C,
1854		// or beginning with the identifier C immediately followed by "-".
1855		// The matching of C against the element's language value is performed case-insensitively.
1856		// The identifier C does not have to be a valid language name."
1857		// http://www.w3.org/TR/selectors/#lang-pseudo
1858		"lang": markFunction( function( lang ) {
1859			// lang value must be a valid identifier
1860			if ( !ridentifier.test(lang || "") ) {
1861				Sizzle.error( "unsupported lang: " + lang );
1862			}
1863			lang = lang.replace( runescape, funescape ).toLowerCase();
1864			return function( elem ) {
1865				var elemLang;
1866				do {
1867					if ( (elemLang = documentIsHTML ?
1868						elem.lang :
1869						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
1870
1871						elemLang = elemLang.toLowerCase();
1872						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
1873					}
1874				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
1875				return false;
1876			};
1877		}),
1878
1879		// Miscellaneous
1880		"target": function( elem ) {
1881			var hash = window.location && window.location.hash;
1882			return hash && hash.slice( 1 ) === elem.id;
1883		},
1884
1885		"root": function( elem ) {
1886			return elem === docElem;
1887		},
1888
1889		"focus": function( elem ) {
1890			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
1891		},
1892
1893		// Boolean properties
1894		"enabled": function( elem ) {
1895			return elem.disabled === false;
1896		},
1897
1898		"disabled": function( elem ) {
1899			return elem.disabled === true;
1900		},
1901
1902		"checked": function( elem ) {
1903			// In CSS3, :checked should return both checked and selected elements
1904			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1905			var nodeName = elem.nodeName.toLowerCase();
1906			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
1907		},
1908
1909		"selected": function( elem ) {
1910			// Accessing this property makes selected-by-default
1911			// options in Safari work properly
1912			if ( elem.parentNode ) {
1913				elem.parentNode.selectedIndex;
1914			}
1915
1916			return elem.selected === true;
1917		},
1918
1919		// Contents
1920		"empty": function( elem ) {
1921			// http://www.w3.org/TR/selectors/#empty-pseudo
1922			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
1923			//   but not by others (comment: 8; processing instruction: 7; etc.)
1924			// nodeType < 6 works because attributes (2) do not appear as children
1925			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1926				if ( elem.nodeType < 6 ) {
1927					return false;
1928				}
1929			}
1930			return true;
1931		},
1932
1933		"parent": function( elem ) {
1934			return !Expr.pseudos["empty"]( elem );
1935		},
1936
1937		// Element/input types
1938		"header": function( elem ) {
1939			return rheader.test( elem.nodeName );
1940		},
1941
1942		"input": function( elem ) {
1943			return rinputs.test( elem.nodeName );
1944		},
1945
1946		"button": function( elem ) {
1947			var name = elem.nodeName.toLowerCase();
1948			return name === "input" && elem.type === "button" || name === "button";
1949		},
1950
1951		"text": function( elem ) {
1952			var attr;
1953			return elem.nodeName.toLowerCase() === "input" &&
1954				elem.type === "text" &&
1955
1956				// Support: IE<8
1957				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
1958				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
1959		},
1960
1961		// Position-in-collection
1962		"first": createPositionalPseudo(function() {
1963			return [ 0 ];
1964		}),
1965
1966		"last": createPositionalPseudo(function( matchIndexes, length ) {
1967			return [ length - 1 ];
1968		}),
1969
1970		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
1971			return [ argument < 0 ? argument + length : argument ];
1972		}),
1973
1974		"even": createPositionalPseudo(function( matchIndexes, length ) {
1975			var i = 0;
1976			for ( ; i < length; i += 2 ) {
1977				matchIndexes.push( i );
1978			}
1979			return matchIndexes;
1980		}),
1981
1982		"odd": createPositionalPseudo(function( matchIndexes, length ) {
1983			var i = 1;
1984			for ( ; i < length; i += 2 ) {
1985				matchIndexes.push( i );
1986			}
1987			return matchIndexes;
1988		}),
1989
1990		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
1991			var i = argument < 0 ? argument + length : argument;
1992			for ( ; --i >= 0; ) {
1993				matchIndexes.push( i );
1994			}
1995			return matchIndexes;
1996		}),
1997
1998		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
1999			var i = argument < 0 ? argument + length : argument;
2000			for ( ; ++i < length; ) {
2001				matchIndexes.push( i );
2002			}
2003			return matchIndexes;
2004		})
2005	}
2006};
2007
2008Expr.pseudos["nth"] = Expr.pseudos["eq"];
2009
2010// Add button/input type pseudos
2011for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2012	Expr.pseudos[ i ] = createInputPseudo( i );
2013}
2014for ( i in { submit: true, reset: true } ) {
2015	Expr.pseudos[ i ] = createButtonPseudo( i );
2016}
2017
2018// Easy API for creating new setFilters
2019function setFilters() {}
2020setFilters.prototype = Expr.filters = Expr.pseudos;
2021Expr.setFilters = new setFilters();
2022
2023function tokenize( selector, parseOnly ) {
2024	var matched, match, tokens, type,
2025		soFar, groups, preFilters,
2026		cached = tokenCache[ selector + " " ];
2027
2028	if ( cached ) {
2029		return parseOnly ? 0 : cached.slice( 0 );
2030	}
2031
2032	soFar = selector;
2033	groups = [];
2034	preFilters = Expr.preFilter;
2035
2036	while ( soFar ) {
2037
2038		// Comma and first run
2039		if ( !matched || (match = rcomma.exec( soFar )) ) {
2040			if ( match ) {
2041				// Don't consume trailing commas as valid
2042				soFar = soFar.slice( match[0].length ) || soFar;
2043			}
2044			groups.push( (tokens = []) );
2045		}
2046
2047		matched = false;
2048
2049		// Combinators
2050		if ( (match = rcombinators.exec( soFar )) ) {
2051			matched = match.shift();
2052			tokens.push({
2053				value: matched,
2054				// Cast descendant combinators to space
2055				type: match[0].replace( rtrim, " " )
2056			});
2057			soFar = soFar.slice( matched.length );
2058		}
2059
2060		// Filters
2061		for ( type in Expr.filter ) {
2062			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2063				(match = preFilters[ type ]( match ))) ) {
2064				matched = match.shift();
2065				tokens.push({
2066					value: matched,
2067					type: type,
2068					matches: match
2069				});
2070				soFar = soFar.slice( matched.length );
2071			}
2072		}
2073
2074		if ( !matched ) {
2075			break;
2076		}
2077	}
2078
2079	// Return the length of the invalid excess
2080	// if we're just parsing
2081	// Otherwise, throw an error or return tokens
2082	return parseOnly ?
2083		soFar.length :
2084		soFar ?
2085			Sizzle.error( selector ) :
2086			// Cache the tokens
2087			tokenCache( selector, groups ).slice( 0 );
2088}
2089
2090function toSelector( tokens ) {
2091	var i = 0,
2092		len = tokens.length,
2093		selector = "";
2094	for ( ; i < len; i++ ) {
2095		selector += tokens[i].value;
2096	}
2097	return selector;
2098}
2099
2100function addCombinator( matcher, combinator, base ) {
2101	var dir = combinator.dir,
2102		checkNonElements = base && dir === "parentNode",
2103		doneName = done++;
2104
2105	return combinator.first ?
2106		// Check against closest ancestor/preceding element
2107		function( elem, context, xml ) {
2108			while ( (elem = elem[ dir ]) ) {
2109				if ( elem.nodeType === 1 || checkNonElements ) {
2110					return matcher( elem, context, xml );
2111				}
2112			}
2113		} :
2114
2115		// Check against all ancestor/preceding elements
2116		function( elem, context, xml ) {
2117			var oldCache, outerCache,
2118				newCache = [ dirruns, doneName ];
2119
2120			// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
2121			if ( xml ) {
2122				while ( (elem = elem[ dir ]) ) {
2123					if ( elem.nodeType === 1 || checkNonElements ) {
2124						if ( matcher( elem, context, xml ) ) {
2125							return true;
2126						}
2127					}
2128				}
2129			} else {
2130				while ( (elem = elem[ dir ]) ) {
2131					if ( elem.nodeType === 1 || checkNonElements ) {
2132						outerCache = elem[ expando ] || (elem[ expando ] = {});
2133						if ( (oldCache = outerCache[ dir ]) &&
2134							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2135
2136							// Assign to newCache so results back-propagate to previous elements
2137							return (newCache[ 2 ] = oldCache[ 2 ]);
2138						} else {
2139							// Reuse newcache so results back-propagate to previous elements
2140							outerCache[ dir ] = newCache;
2141
2142							// A match means we're done; a fail means we have to keep checking
2143							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
2144								return true;
2145							}
2146						}
2147					}
2148				}
2149			}
2150		};
2151}
2152
2153function elementMatcher( matchers ) {
2154	return matchers.length > 1 ?
2155		function( elem, context, xml ) {
2156			var i = matchers.length;
2157			while ( i-- ) {
2158				if ( !matchers[i]( elem, context, xml ) ) {
2159					return false;
2160				}
2161			}
2162			return true;
2163		} :
2164		matchers[0];
2165}
2166
2167function condense( unmatched, map, filter, context, xml ) {
2168	var elem,
2169		newUnmatched = [],
2170		i = 0,
2171		len = unmatched.length,
2172		mapped = map != null;
2173
2174	for ( ; i < len; i++ ) {
2175		if ( (elem = unmatched[i]) ) {
2176			if ( !filter || filter( elem, context, xml ) ) {
2177				newUnmatched.push( elem );
2178				if ( mapped ) {
2179					map.push( i );
2180				}
2181			}
2182		}
2183	}
2184
2185	return newUnmatched;
2186}
2187
2188function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2189	if ( postFilter && !postFilter[ expando ] ) {
2190		postFilter = setMatcher( postFilter );
2191	}
2192	if ( postFinder && !postFinder[ expando ] ) {
2193		postFinder = setMatcher( postFinder, postSelector );
2194	}
2195	return markFunction(function( seed, results, context, xml ) {
2196		var temp, i, elem,
2197			preMap = [],
2198			postMap = [],
2199			preexisting = results.length,
2200
2201			// Get initial elements from seed or context
2202			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2203
2204			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2205			matcherIn = preFilter && ( seed || !selector ) ?
2206				condense( elems, preMap, preFilter, context, xml ) :
2207				elems,
2208
2209			matcherOut = matcher ?
2210				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2211				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2212
2213					// ...intermediate processing is necessary
2214					[] :
2215
2216					// ...otherwise use results directly
2217					results :
2218				matcherIn;
2219
2220		// Find primary matches
2221		if ( matcher ) {
2222			matcher( matcherIn, matcherOut, context, xml );
2223		}
2224
2225		// Apply postFilter
2226		if ( postFilter ) {
2227			temp = condense( matcherOut, postMap );
2228			postFilter( temp, [], context, xml );
2229
2230			// Un-match failing elements by moving them back to matcherIn
2231			i = temp.length;
2232			while ( i-- ) {
2233				if ( (elem = temp[i]) ) {
2234					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2235				}
2236			}
2237		}
2238
2239		if ( seed ) {
2240			if ( postFinder || preFilter ) {
2241				if ( postFinder ) {
2242					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2243					temp = [];
2244					i = matcherOut.length;
2245					while ( i-- ) {
2246						if ( (elem = matcherOut[i]) ) {
2247							// Restore matcherIn since elem is not yet a final match
2248							temp.push( (matcherIn[i] = elem) );
2249						}
2250					}
2251					postFinder( null, (matcherOut = []), temp, xml );
2252				}
2253
2254				// Move matched elements from seed to results to keep them synchronized
2255				i = matcherOut.length;
2256				while ( i-- ) {
2257					if ( (elem = matcherOut[i]) &&
2258						(temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) {
2259
2260						seed[temp] = !(results[temp] = elem);
2261					}
2262				}
2263			}
2264
2265		// Add elements to results, through postFinder if defined
2266		} else {
2267			matcherOut = condense(
2268				matcherOut === results ?
2269					matcherOut.splice( preexisting, matcherOut.length ) :
2270					matcherOut
2271			);
2272			if ( postFinder ) {
2273				postFinder( null, results, matcherOut, xml );
2274			} else {
2275				push.apply( results, matcherOut );
2276			}
2277		}
2278	});
2279}
2280
2281function matcherFromTokens( tokens ) {
2282	var checkContext, matcher, j,
2283		len = tokens.length,
2284		leadingRelative = Expr.relative[ tokens[0].type ],
2285		implicitRelative = leadingRelative || Expr.relative[" "],
2286		i = leadingRelative ? 1 : 0,
2287
2288		// The foundational matcher ensures that elements are reachable from top-level context(s)
2289		matchContext = addCombinator( function( elem ) {
2290			return elem === checkContext;
2291		}, implicitRelative, true ),
2292		matchAnyContext = addCombinator( function( elem ) {
2293			return indexOf.call( checkContext, elem ) > -1;
2294		}, implicitRelative, true ),
2295		matchers = [ function( elem, context, xml ) {
2296			return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2297				(checkContext = context).nodeType ?
2298					matchContext( elem, context, xml ) :
2299					matchAnyContext( elem, context, xml ) );
2300		} ];
2301
2302	for ( ; i < len; i++ ) {
2303		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2304			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2305		} else {
2306			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2307
2308			// Return special upon seeing a positional matcher
2309			if ( matcher[ expando ] ) {
2310				// Find the next relative operator (if any) for proper handling
2311				j = ++i;
2312				for ( ; j < len; j++ ) {
2313					if ( Expr.relative[ tokens[j].type ] ) {
2314						break;
2315					}
2316				}
2317				return setMatcher(
2318					i > 1 && elementMatcher( matchers ),
2319					i > 1 && toSelector(
2320						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2321						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2322					).replace( rtrim, "$1" ),
2323					matcher,
2324					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2325					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2326					j < len && toSelector( tokens )
2327				);
2328			}
2329			matchers.push( matcher );
2330		}
2331	}
2332
2333	return elementMatcher( matchers );
2334}
2335
2336function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2337	var bySet = setMatchers.length > 0,
2338		byElement = elementMatchers.length > 0,
2339		superMatcher = function( seed, context, xml, results, outermost ) {
2340			var elem, j, matcher,
2341				matchedCount = 0,
2342				i = "0",
2343				unmatched = seed && [],
2344				setMatched = [],
2345				contextBackup = outermostContext,
2346				// We must always have either seed elements or outermost context
2347				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
2348				// Use integer dirruns iff this is the outermost matcher
2349				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
2350				len = elems.length;
2351
2352			if ( outermost ) {
2353				outermostContext = context !== document && context;
2354			}
2355
2356			// Add elements passing elementMatchers directly to results
2357			// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
2358			// Support: IE<9, Safari
2359			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2360			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
2361				if ( byElement && elem ) {
2362					j = 0;
2363					while ( (matcher = elementMatchers[j++]) ) {
2364						if ( matcher( elem, context, xml ) ) {
2365							results.push( elem );
2366							break;
2367						}
2368					}
2369					if ( outermost ) {
2370						dirruns = dirrunsUnique;
2371					}
2372				}
2373
2374				// Track unmatched elements for set filters
2375				if ( bySet ) {
2376					// They will have gone through all possible matchers
2377					if ( (elem = !matcher && elem) ) {
2378						matchedCount--;
2379					}
2380
2381					// Lengthen the array for every element, matched or not
2382					if ( seed ) {
2383						unmatched.push( elem );
2384					}
2385				}
2386			}
2387
2388			// Apply set filters to unmatched elements
2389			matchedCount += i;
2390			if ( bySet && i !== matchedCount ) {
2391				j = 0;
2392				while ( (matcher = setMatchers[j++]) ) {
2393					matcher( unmatched, setMatched, context, xml );
2394				}
2395
2396				if ( seed ) {
2397					// Reintegrate element matches to eliminate the need for sorting
2398					if ( matchedCount > 0 ) {
2399						while ( i-- ) {
2400							if ( !(unmatched[i] || setMatched[i]) ) {
2401								setMatched[i] = pop.call( results );
2402							}
2403						}
2404					}
2405
2406					// Discard index placeholder values to get only actual matches
2407					setMatched = condense( setMatched );
2408				}
2409
2410				// Add matches to results
2411				push.apply( results, setMatched );
2412
2413				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2414				if ( outermost && !seed && setMatched.length > 0 &&
2415					( matchedCount + setMatchers.length ) > 1 ) {
2416
2417					Sizzle.uniqueSort( results );
2418				}
2419			}
2420
2421			// Override manipulation of globals by nested matchers
2422			if ( outermost ) {
2423				dirruns = dirrunsUnique;
2424				outermostContext = contextBackup;
2425			}
2426
2427			return unmatched;
2428		};
2429
2430	return bySet ?
2431		markFunction( superMatcher ) :
2432		superMatcher;
2433}
2434
2435compile = Sizzle.compile = function( selector, group /* Internal Use Only */ ) {
2436	var i,
2437		setMatchers = [],
2438		elementMatchers = [],
2439		cached = compilerCache[ selector + " " ];
2440
2441	if ( !cached ) {
2442		// Generate a function of recursive functions that can be used to check each element
2443		if ( !group ) {
2444			group = tokenize( selector );
2445		}
2446		i = group.length;
2447		while ( i-- ) {
2448			cached = matcherFromTokens( group[i] );
2449			if ( cached[ expando ] ) {
2450				setMatchers.push( cached );
2451			} else {
2452				elementMatchers.push( cached );
2453			}
2454		}
2455
2456		// Cache the compiled function
2457		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2458	}
2459	return cached;
2460};
2461
2462function multipleContexts( selector, contexts, results ) {
2463	var i = 0,
2464		len = contexts.length;
2465	for ( ; i < len; i++ ) {
2466		Sizzle( selector, contexts[i], results );
2467	}
2468	return results;
2469}
2470
2471function select( selector, context, results, seed ) {
2472	var i, tokens, token, type, find,
2473		match = tokenize( selector );
2474
2475	if ( !seed ) {
2476		// Try to minimize operations if there is only one group
2477		if ( match.length === 1 ) {
2478
2479			// Take a shortcut and set the context if the root selector is an ID
2480			tokens = match[0] = match[0].slice( 0 );
2481			if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2482					support.getById && context.nodeType === 9 && documentIsHTML &&
2483					Expr.relative[ tokens[1].type ] ) {
2484
2485				context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2486				if ( !context ) {
2487					return results;
2488				}
2489				selector = selector.slice( tokens.shift().value.length );
2490			}
2491
2492			// Fetch a seed set for right-to-left matching
2493			i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2494			while ( i-- ) {
2495				token = tokens[i];
2496
2497				// Abort if we hit a combinator
2498				if ( Expr.relative[ (type = token.type) ] ) {
2499					break;
2500				}
2501				if ( (find = Expr.find[ type ]) ) {
2502					// Search, expanding context for leading sibling combinators
2503					if ( (seed = find(
2504						token.matches[0].replace( runescape, funescape ),
2505						rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
2506					)) ) {
2507
2508						// If seed is empty or no tokens remain, we can return early
2509						tokens.splice( i, 1 );
2510						selector = seed.length && toSelector( tokens );
2511						if ( !selector ) {
2512							push.apply( results, seed );
2513							return results;
2514						}
2515
2516						break;
2517					}
2518				}
2519			}
2520		}
2521	}
2522
2523	// Compile and execute a filtering function
2524	// Provide `match` to avoid retokenization if we modified the selector above
2525	compile( selector, match )(
2526		seed,
2527		context,
2528		!documentIsHTML,
2529		results,
2530		rsibling.test( selector ) && testContext( context.parentNode ) || context
2531	);
2532	return results;
2533}
2534
2535// One-time assignments
2536
2537// Sort stability
2538support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
2539
2540// Support: Chrome<14
2541// Always assume duplicates if they aren't passed to the comparison function
2542support.detectDuplicates = !!hasDuplicate;
2543
2544// Initialize against the default document
2545setDocument();
2546
2547// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2548// Detached nodes confoundingly follow *each other*
2549support.sortDetached = assert(function( div1 ) {
2550	// Should return 1, but returns 4 (following)
2551	return div1.compareDocumentPosition( document.createElement("div") ) & 1;
2552});
2553
2554// Support: IE<8
2555// Prevent attribute/property "interpolation"
2556// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2557if ( !assert(function( div ) {
2558	div.innerHTML = "<a href='#'></a>";
2559	return div.firstChild.getAttribute("href") === "#" ;
2560}) ) {
2561	addHandle( "type|href|height|width", function( elem, name, isXML ) {
2562		if ( !isXML ) {
2563			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2564		}
2565	});
2566}
2567
2568// Support: IE<9
2569// Use defaultValue in place of getAttribute("value")
2570if ( !support.attributes || !assert(function( div ) {
2571	div.innerHTML = "<input/>";
2572	div.firstChild.setAttribute( "value", "" );
2573	return div.firstChild.getAttribute( "value" ) === "";
2574}) ) {
2575	addHandle( "value", function( elem, name, isXML ) {
2576		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2577			return elem.defaultValue;
2578		}
2579	});
2580}
2581
2582// Support: IE<9
2583// Use getAttributeNode to fetch booleans when getAttribute lies
2584if ( !assert(function( div ) {
2585	return div.getAttribute("disabled") == null;
2586}) ) {
2587	addHandle( booleans, function( elem, name, isXML ) {
2588		var val;
2589		if ( !isXML ) {
2590			return elem[ name ] === true ? name.toLowerCase() :
2591					(val = elem.getAttributeNode( name )) && val.specified ?
2592					val.value :
2593				null;
2594		}
2595	});
2596}
2597
2598return Sizzle;
2599
2600})( window );
2601
2602
2603
2604jQuery.find = Sizzle;
2605jQuery.expr = Sizzle.selectors;
2606jQuery.expr[":"] = jQuery.expr.pseudos;
2607jQuery.unique = Sizzle.uniqueSort;
2608jQuery.text = Sizzle.getText;
2609jQuery.isXMLDoc = Sizzle.isXML;
2610jQuery.contains = Sizzle.contains;
2611
2612
2613
2614var rneedsContext = jQuery.expr.match.needsContext;
2615
2616var rsingleTag = (/^<(\w+)\s*\/?>(?:<\/\1>|)$/);
2617
2618
2619
2620var risSimple = /^.[^:#\[\.,]*$/;
2621
2622// Implement the identical functionality for filter and not
2623function winnow( elements, qualifier, not ) {
2624	if ( jQuery.isFunction( qualifier ) ) {
2625		return jQuery.grep( elements, function( elem, i ) {
2626			/* jshint -W018 */
2627			return !!qualifier.call( elem, i, elem ) !== not;
2628		});
2629
2630	}
2631
2632	if ( qualifier.nodeType ) {
2633		return jQuery.grep( elements, function( elem ) {
2634			return ( elem === qualifier ) !== not;
2635		});
2636
2637	}
2638
2639	if ( typeof qualifier === "string" ) {
2640		if ( risSimple.test( qualifier ) ) {
2641			return jQuery.filter( qualifier, elements, not );
2642		}
2643
2644		qualifier = jQuery.filter( qualifier, elements );
2645	}
2646
2647	return jQuery.grep( elements, function( elem ) {
2648		return ( jQuery.inArray( elem, qualifier ) >= 0 ) !== not;
2649	});
2650}
2651
2652jQuery.filter = function( expr, elems, not ) {
2653	var elem = elems[ 0 ];
2654
2655	if ( not ) {
2656		expr = ":not(" + expr + ")";
2657	}
2658
2659	return elems.length === 1 && elem.nodeType === 1 ?
2660		jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :
2661		jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
2662			return elem.nodeType === 1;
2663		}));
2664};
2665
2666jQuery.fn.extend({
2667	find: function( selector ) {
2668		var i,
2669			ret = [],
2670			self = this,
2671			len = self.length;
2672
2673		if ( typeof selector !== "string" ) {