Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

scratch – Blame information for rev 125

Rev	Author	Line No.	Line
125	office	1	/*!
		2	* Sizzle CSS Selector Engine v2.2.0-pre
		3	* http://sizzlejs.com/
		4	*
		5	* Copyright 2008, 2014 jQuery Foundation, Inc. and other contributors
		6	* Released under the MIT license
		7	* http://jquery.org/license
		8	*
		9	* Date: 2014-12-16
		10	*/
		11	(function( window ) {
		12
		13	var i,
		14	support,
		15	Expr,
		16	getText,
		17	isXML,
		18	tokenize,
		19	compile,
		20	select,
		21	outermostContext,
		22	sortInput,
		23	hasDuplicate,
		24
		25	// Local document vars
		26	setDocument,
		27	document,
		28	docElem,
		29	documentIsHTML,
		30	rbuggyQSA,
		31	rbuggyMatches,
		32	matches,
		33	contains,
		34
		35	// Instance-specific data
		36	expando = "sizzle" + 1 * new Date(),
		37	preferredDoc = window.document,
		38	dirruns = 0,
		39	done = 0,
		40	classCache = createCache(),
		41	tokenCache = createCache(),
		42	compilerCache = createCache(),
		43	sortOrder = function( a, b ) {
		44	if ( a === b ) {
		45	hasDuplicate = true;
		46	}
		47	return 0;
		48	},
		49
		50	// General-purpose constants
		51	MAX_NEGATIVE = 1 << 31,
		52
		53	// Instance methods
		54	hasOwn = ({}).hasOwnProperty,
		55	arr = [],
		56	pop = arr.pop,
		57	push_native = arr.push,
		58	push = arr.push,
		59	slice = arr.slice,
		60	// Use a stripped-down indexOf as it's faster than native
		61	// http://jsperf.com/thor-indexof-vs-for/5
		62	indexOf = function( list, elem ) {
		63	var i = 0,
		64	len = list.length;
		65	for ( ; i < len; i++ ) {
		66	if ( list[i] === elem ) {
		67	return i;
		68	}
		69	}
		70	return -1;
		71	},
		72
		73	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
		74
		75	// Regular expressions
		76
		77	// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
		78	whitespace = "[\\x20\\t\\r\\n\\f]",
		79	// http://www.w3.org/TR/css3-syntax/#characters
		80	characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
		81
		82	// Loosely modeled on CSS identifier characters
		83	// An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
		84	// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
		85	identifier = characterEncoding.replace( "w", "w#" ),
		86
		87	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
		88	attributes = "\\[" + whitespace + "*(" + characterEncoding + ")(?:" + whitespace +
		89	// Operator (capture 2)
		90	"*([*^$|!~]?=)" + whitespace +
		91	// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
		92	"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
		93	"*\\]",
		94
		95	pseudos = ":(" + characterEncoding + ")(?:\\((" +
		96	// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
		97	// 1. quoted (capture 3; capture 4 or capture 5)
		98	"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
		99	// 2. simple (capture 6)
		100	"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
		101	// 3. anything else (capture 2)
		102	".*" +
		103	")\\)|)",
		104
		105	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
		106	rwhitespace = new RegExp( whitespace + "+", "g" ),
		107	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
		108
		109	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
		110	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
		111
		112	rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
		113
		114	rpseudo = new RegExp( pseudos ),
		115	ridentifier = new RegExp( "^" + identifier + "$" ),
		116
		117	matchExpr = {
		118	"ID": new RegExp( "^#(" + characterEncoding + ")" ),
		119	"CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
		120	"TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),
		121	"ATTR": new RegExp( "^" + attributes ),
		122	"PSEUDO": new RegExp( "^" + pseudos ),
		123	"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
		124	"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
		125	"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
		126	"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
		127	// For use in libraries implementing .is()
		128	// We use this for POS matching in `select`
		129	"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
		130	whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
		131	},
		132
		133	rinputs = /^(?:input|select|textarea|button)$/i,
		134	rheader = /^h\d$/i,
		135
		136	rnative = /^[^{]+\{\s*\[native \w/,
		137
		138	// Easily-parseable/retrievable ID or TAG or CLASS selectors
		139	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
		140
		141	rsibling = /[+~]/,
		142	rescape = /'|\\/g,
		143
		144	// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
		145	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
		146	funescape = function( _, escaped, escapedWhitespace ) {
		147	var high = "0x" + escaped - 0x10000;
		148	// NaN means non-codepoint
		149	// Support: Firefox<24
		150	// Workaround erroneous numeric interpretation of +"0x"
		151	return high !== high || escapedWhitespace ?
		152	escaped :
		153	high < 0 ?
		154	// BMP codepoint
		155	String.fromCharCode( high + 0x10000 ) :
		156	// Supplemental Plane codepoint (surrogate pair)
		157	String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
		158	},
		159
		160	// Used for iframes
		161	// See setDocument()
		162	// Removing the function wrapper causes a "Permission Denied"
		163	// error in IE
		164	unloadHandler = function() {
		165	setDocument();
		166	};
		167
		168	// Optimize for push.apply( _, NodeList )
		169	try {
		170	push.apply(
		171	(arr = slice.call( preferredDoc.childNodes )),
		172	preferredDoc.childNodes
		173	);
		174	// Support: Android<4.0
		175	// Detect silently failing push.apply
		176	arr[ preferredDoc.childNodes.length ].nodeType;
		177	} catch ( e ) {
		178	push = { apply: arr.length ?
		179
		180	// Leverage slice if possible
		181	function( target, els ) {
		182	push_native.apply( target, slice.call(els) );
		183	} :
		184
		185	// Support: IE<9
		186	// Otherwise append directly
		187	function( target, els ) {
		188	var j = target.length,
		189	i = 0;
		190	// Can't trust NodeList.length
		191	while ( (target[j++] = els[i++]) ) {}
		192	target.length = j - 1;
		193	}
		194	};
		195	}
		196
		197	function Sizzle( selector, context, results, seed ) {
		198	var match, elem, m, nodeType,
		199	// QSA vars
		200	i, groups, old, nid, newContext, newSelector;
		201
		202	if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
		203	setDocument( context );
		204	}
		205
		206	context = context || document;
		207	results = results || [];
		208	nodeType = context.nodeType;
		209
		210	if ( typeof selector !== "string" || !selector ||
		211	nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
		212
		213	return results;
		214	}
		215
		216	if ( !seed && documentIsHTML ) {
		217
		218	// Try to shortcut find operations when possible (e.g., not under DocumentFragment)
		219	if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
		220	// Speed-up: Sizzle("#ID")
		221	if ( (m = match[1]) ) {
		222	if ( nodeType === 9 ) {
		223	elem = context.getElementById( m );
		224	// Check parentNode to catch when Blackberry 4.6 returns
		225	// nodes that are no longer in the document (jQuery #6963)
		226	if ( elem && elem.parentNode ) {
		227	// Handle the case where IE, Opera, and Webkit return items
		228	// by name instead of ID
		229	if ( elem.id === m ) {
		230	results.push( elem );
		231	return results;
		232	}
		233	} else {
		234	return results;
		235	}
		236	} else {
		237	// Context is not a document
		238	if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
		239	contains( context, elem ) && elem.id === m ) {
		240	results.push( elem );
		241	return results;
		242	}
		243	}
		244
		245	// Speed-up: Sizzle("TAG")
		246	} else if ( match[2] ) {
		247	push.apply( results, context.getElementsByTagName( selector ) );
		248	return results;
		249
		250	// Speed-up: Sizzle(".CLASS")
		251	} else if ( (m = match[3]) && support.getElementsByClassName ) {
		252	push.apply( results, context.getElementsByClassName( m ) );
		253	return results;
		254	}
		255	}
		256
		257	// QSA path
		258	if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
		259	nid = old = expando;
		260	newContext = context;
		261	newSelector = nodeType !== 1 && selector;
		262
		263	// qSA works strangely on Element-rooted queries
		264	// We can work around this by specifying an extra ID on the root
		265	// and working up from there (Thanks to Andrew Dupont for the technique)
		266	// IE 8 doesn't work on object elements
		267	if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
		268	groups = tokenize( selector );
		269
		270	if ( (old = context.getAttribute("id")) ) {
		271	nid = old.replace( rescape, "\\$&" );
		272	} else {
		273	context.setAttribute( "id", nid );
		274	}
		275	nid = "[id='" + nid + "'] ";
		276
		277	i = groups.length;
		278	while ( i-- ) {
		279	groups[i] = nid + toSelector( groups[i] );
		280	}
		281	newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context;
		282	newSelector = groups.join(",");
		283	}
		284
		285	if ( newSelector ) {
		286	try {
		287	push.apply( results,
		288	newContext.querySelectorAll( newSelector )
		289	);
		290	return results;
		291	} catch(qsaError) {
		292	} finally {
		293	if ( !old ) {
		294	context.removeAttribute("id");
		295	}
		296	}
		297	}
		298	}
		299	}
		300
		301	// All others
		302	return select( selector.replace( rtrim, "$1" ), context, results, seed );
		303	}
		304
		305	/**
		306	* Create key-value caches of limited size
		307	* @returns {Function(string, Object)} Returns the Object data after storing it on itself with
		308	* property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
		309	* deleting the oldest entry
		310	*/
		311	function createCache() {
		312	var keys = [];
		313
		314	function cache( key, value ) {
		315	// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
		316	if ( keys.push( key + " " ) > Expr.cacheLength ) {
		317	// Only keep the most recent entries
		318	delete cache[ keys.shift() ];
		319	}
		320	return (cache[ key + " " ] = value);
		321	}
		322	return cache;
		323	}
		324
		325	/**
		326	* Mark a function for special use by Sizzle
		327	* @param {Function} fn The function to mark
		328	*/
		329	function markFunction( fn ) {
		330	fn[ expando ] = true;
		331	return fn;
		332	}
		333
		334	/**
		335	* Support testing using an element
		336	* @param {Function} fn Passed the created div and expects a boolean result
		337	*/
		338	function assert( fn ) {
		339	var div = document.createElement("div");
		340
		341	try {
		342	return !!fn( div );
		343	} catch (e) {
		344	return false;
		345	} finally {
		346	// Remove from its parent by default
		347	if ( div.parentNode ) {
		348	div.parentNode.removeChild( div );
		349	}
		350	// release memory in IE
		351	div = null;
		352	}
		353	}
		354
		355	/**
		356	* Adds the same handler for all of the specified attrs
		357	* @param {String} attrs Pipe-separated list of attributes
		358	* @param {Function} handler The method that will be applied
		359	*/
		360	function addHandle( attrs, handler ) {
		361	var arr = attrs.split("|"),
		362	i = attrs.length;
		363
		364	while ( i-- ) {
		365	Expr.attrHandle[ arr[i] ] = handler;
		366	}
		367	}
		368
		369	/**
		370	* Checks document order of two siblings
		371	* @param {Element} a
		372	* @param {Element} b
		373	* @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
		374	*/
		375	function siblingCheck( a, b ) {
		376	var cur = b && a,
		377	diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
		378	( ~b.sourceIndex || MAX_NEGATIVE ) -
		379	( ~a.sourceIndex || MAX_NEGATIVE );
		380
		381	// Use IE sourceIndex if available on both nodes
		382	if ( diff ) {
		383	return diff;
		384	}
		385
		386	// Check if b follows a
		387	if ( cur ) {
		388	while ( (cur = cur.nextSibling) ) {
		389	if ( cur === b ) {
		390	return -1;
		391	}
		392	}
		393	}
		394
		395	return a ? 1 : -1;
		396	}
		397
		398	/**
		399	* Returns a function to use in pseudos for input types
		400	* @param {String} type
		401	*/
		402	function createInputPseudo( type ) {
		403	return function( elem ) {
		404	var name = elem.nodeName.toLowerCase();
		405	return name === "input" && elem.type === type;
		406	};
		407	}
		408
		409	/**
		410	* Returns a function to use in pseudos for buttons
		411	* @param {String} type
		412	*/
		413	function createButtonPseudo( type ) {
		414	return function( elem ) {
		415	var name = elem.nodeName.toLowerCase();
		416	return (name === "input" || name === "button") && elem.type === type;
		417	};
		418	}
		419
		420	/**
		421	* Returns a function to use in pseudos for positionals
		422	* @param {Function} fn
		423	*/
		424	function createPositionalPseudo( fn ) {
		425	return markFunction(function( argument ) {
		426	argument = +argument;
		427	return markFunction(function( seed, matches ) {
		428	var j,
		429	matchIndexes = fn( [], seed.length, argument ),
		430	i = matchIndexes.length;
		431
		432	// Match elements found at the specified indexes
		433	while ( i-- ) {
		434	if ( seed[ (j = matchIndexes[i]) ] ) {
		435	seed[j] = !(matches[j] = seed[j]);
		436	}
		437	}
		438	});
		439	});
		440	}
		441
		442	/**
		443	* Checks a node for validity as a Sizzle context
		444	* @param {Element|Object=} context
		445	* @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
		446	*/
		447	function testContext( context ) {
		448	return context && typeof context.getElementsByTagName !== "undefined" && context;
		449	}
		450
		451	// Expose support vars for convenience
		452	support = Sizzle.support = {};
		453
		454	/**
		455	* Detects XML nodes
		456	* @param {Element|Object} elem An element or a document
		457	* @returns {Boolean} True iff elem is a non-HTML XML node
		458	*/
		459	isXML = Sizzle.isXML = function( elem ) {
		460	// documentElement is verified for cases where it doesn't yet exist
		461	// (such as loading iframes in IE - #4833)
		462	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
		463	return documentElement ? documentElement.nodeName !== "HTML" : false;
		464	};
		465
		466	/**
		467	* Sets document-related variables once based on the current document
		468	* @param {Element|Object} [doc] An element or document object to use to set the document
		469	* @returns {Object} Returns the current document
		470	*/
		471	setDocument = Sizzle.setDocument = function( node ) {
		472	var hasCompare, parent,
		473	doc = node ? node.ownerDocument || node : preferredDoc;
		474
		475	// If no document and documentElement is available, return
		476	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
		477	return document;
		478	}
		479
		480	// Set our document
		481	document = doc;
		482	docElem = doc.documentElement;
		483	parent = doc.defaultView;
		484
		485	// Support: IE>8
		486	// If iframe document is assigned to "document" variable and if iframe has been reloaded,
		487	// IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
		488	// IE6-8 do not support the defaultView property so parent will be undefined
		489	if ( parent && parent !== parent.top ) {
		490	// IE11 does not have attachEvent, so all must suffer
		491	if ( parent.addEventListener ) {
		492	parent.addEventListener( "unload", unloadHandler, false );
		493	} else if ( parent.attachEvent ) {
		494	parent.attachEvent( "onunload", unloadHandler );
		495	}
		496	}
		497
		498	/* Support tests
		499	---------------------------------------------------------------------- */
		500	documentIsHTML = !isXML( doc );
		501
		502	/* Attributes
		503	---------------------------------------------------------------------- */
		504
		505	// Support: IE<8
		506	// Verify that getAttribute really returns attributes and not properties
		507	// (excepting IE8 booleans)
		508	support.attributes = assert(function( div ) {
		509	div.className = "i";
		510	return !div.getAttribute("className");
		511	});
		512
		513	/* getElement(s)By*
		514	---------------------------------------------------------------------- */
		515
		516	// Check if getElementsByTagName("*") returns only elements
		517	support.getElementsByTagName = assert(function( div ) {
		518	div.appendChild( doc.createComment("") );
		519	return !div.getElementsByTagName("*").length;
		520	});
		521
		522	// Support: IE<9
		523	support.getElementsByClassName = rnative.test( doc.getElementsByClassName );
		524
		525	// Support: IE<10
		526	// Check if getElementById returns elements by name
		527	// The broken getElementById methods don't pick up programatically-set names,
		528	// so use a roundabout getElementsByName test
		529	support.getById = assert(function( div ) {
		530	docElem.appendChild( div ).id = expando;
		531	return !doc.getElementsByName || !doc.getElementsByName( expando ).length;
		532	});
		533
		534	// ID find and filter
		535	if ( support.getById ) {
		536	Expr.find["ID"] = function( id, context ) {
		537	if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
		538	var m = context.getElementById( id );
		539	// Check parentNode to catch when Blackberry 4.6 returns
		540	// nodes that are no longer in the document #6963
		541	return m && m.parentNode ? [ m ] : [];
		542	}
		543	};
		544	Expr.filter["ID"] = function( id ) {
		545	var attrId = id.replace( runescape, funescape );
		546	return function( elem ) {
		547	return elem.getAttribute("id") === attrId;
		548	};
		549	};
		550	} else {
		551	// Support: IE6/7
		552	// getElementById is not reliable as a find shortcut
		553	delete Expr.find["ID"];
		554
		555	Expr.filter["ID"] = function( id ) {
		556	var attrId = id.replace( runescape, funescape );
		557	return function( elem ) {
		558	var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
		559	return node && node.value === attrId;
		560	};
		561	};
		562	}
		563
		564	// Tag
		565	Expr.find["TAG"] = support.getElementsByTagName ?
		566	function( tag, context ) {
		567	if ( typeof context.getElementsByTagName !== "undefined" ) {
		568	return context.getElementsByTagName( tag );
		569
		570	// DocumentFragment nodes don't have gEBTN
		571	} else if ( support.qsa ) {
		572	return context.querySelectorAll( tag );
		573	}
		574	} :
		575
		576	function( tag, context ) {
		577	var elem,
		578	tmp = [],
		579	i = 0,
		580	// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
		581	results = context.getElementsByTagName( tag );
		582
		583	// Filter out possible comments
		584	if ( tag === "*" ) {
		585	while ( (elem = results[i++]) ) {
		586	if ( elem.nodeType === 1 ) {
		587	tmp.push( elem );
		588	}
		589	}
		590
		591	return tmp;
		592	}
		593	return results;
		594	};
		595
		596	// Class
		597	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
		598	if ( documentIsHTML ) {
		599	return context.getElementsByClassName( className );
		600	}
		601	};
		602
		603	/* QSA/matchesSelector
		604	---------------------------------------------------------------------- */
		605
		606	// QSA and matchesSelector support
		607
		608	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
		609	rbuggyMatches = [];
		610
		611	// qSa(:focus) reports false when true (Chrome 21)
		612	// We allow this because of a bug in IE8/9 that throws an error
		613	// whenever `document.activeElement` is accessed on an iframe
		614	// So, we allow :focus to pass through QSA all the time to avoid the IE error
		615	// See http://bugs.jquery.com/ticket/13378
		616	rbuggyQSA = [];
		617
		618	if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {
		619	// Build QSA regex
		620	// Regex strategy adopted from Diego Perini
		621	assert(function( div ) {
		622	// Select is set to empty string on purpose
		623	// This is to test IE's treatment of not explicitly
		624	// setting a boolean content attribute,
		625	// since its presence should be enough
		626	// http://bugs.jquery.com/ticket/12359
		627	docElem.appendChild( div ).innerHTML = "<a id='" + expando + "'></a>" +
		628	"<select id='" + expando + "-\f]' msallowcapture=''>" +
		629	"<option selected=''></option></select>";
		630
		631	// Support: IE8, Opera 11-12.16
		632	// Nothing should be selected when empty strings follow ^= or $= or *=
		633	// The test attribute must be unknown in Opera but "safe" for WinRT
		634	// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
		635	if ( div.querySelectorAll("[msallowcapture^='']").length ) {
		636	rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
		637	}
		638
		639	// Support: IE8
		640	// Boolean attributes and "value" are not treated correctly
		641	if ( !div.querySelectorAll("[selected]").length ) {
		642	rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
		643	}
		644
		645	// Support: Chrome<29, Android<4.2+, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.7+
		646	if ( !div.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
		647	rbuggyQSA.push("~=");
		648	}
		649
		650	// Webkit/Opera - :checked should return selected option elements
		651	// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
		652	// IE8 throws error here and will not see later tests
		653	if ( !div.querySelectorAll(":checked").length ) {
		654	rbuggyQSA.push(":checked");
		655	}
		656
		657	// Support: Safari 8+, iOS 8+
		658	// https://bugs.webkit.org/show_bug.cgi?id=136851
		659	// In-page `selector#id sibing-combinator selector` fails
		660	if ( !div.querySelectorAll( "a#" + expando + "+*" ).length ) {
		661	rbuggyQSA.push(".#.+[+~]");
		662	}
		663	});
		664
		665	assert(function( div ) {
		666	// Support: Windows 8 Native Apps
		667	// The type and name attributes are restricted during .innerHTML assignment
		668	var input = doc.createElement("input");
		669	input.setAttribute( "type", "hidden" );
		670	div.appendChild( input ).setAttribute( "name", "D" );
		671
		672	// Support: IE8
		673	// Enforce case-sensitivity of name attribute
		674	if ( div.querySelectorAll("[name=d]").length ) {
		675	rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
		676	}
		677
		678	// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
		679	// IE8 throws error here and will not see later tests
		680	if ( !div.querySelectorAll(":enabled").length ) {
		681	rbuggyQSA.push( ":enabled", ":disabled" );
		682	}
		683
		684	// Opera 10-11 does not throw on post-comma invalid pseudos
		685	div.querySelectorAll("*,:x");
		686	rbuggyQSA.push(",.*:");
		687	});
		688	}
		689
		690	if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
		691	docElem.webkitMatchesSelector ||
		692	docElem.mozMatchesSelector ||
		693	docElem.oMatchesSelector ||
		694	docElem.msMatchesSelector) )) ) {
		695
		696	assert(function( div ) {
		697	// Check to see if it's possible to do matchesSelector
		698	// on a disconnected node (IE 9)
		699	support.disconnectedMatch = matches.call( div, "div" );
		700
		701	// This should fail with an exception
		702	// Gecko does not error, returns false instead
		703	matches.call( div, "[s!='']:x" );
		704	rbuggyMatches.push( "!=", pseudos );
		705	});
		706	}
		707
		708	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
		709	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
		710
		711	/* Contains
		712	---------------------------------------------------------------------- */
		713	hasCompare = rnative.test( docElem.compareDocumentPosition );
		714
		715	// Element contains another
		716	// Purposefully does not implement inclusive descendent
		717	// As in, an element does not contain itself
		718	contains = hasCompare || rnative.test( docElem.contains ) ?
		719	function( a, b ) {
		720	var adown = a.nodeType === 9 ? a.documentElement : a,
		721	bup = b && b.parentNode;
		722	return a === bup || !!( bup && bup.nodeType === 1 && (
		723	adown.contains ?
		724	adown.contains( bup ) :
		725	a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
		726	));
		727	} :
		728	function( a, b ) {
		729	if ( b ) {
		730	while ( (b = b.parentNode) ) {
		731	if ( b === a ) {
		732	return true;
		733	}
		734	}
		735	}
		736	return false;
		737	};
		738
		739	/* Sorting
		740	---------------------------------------------------------------------- */
		741
		742	// Document order sorting
		743	sortOrder = hasCompare ?
		744	function( a, b ) {
		745
		746	// Flag for duplicate removal
		747	if ( a === b ) {
		748	hasDuplicate = true;
		749	return 0;
		750	}
		751
		752	// Sort on method existence if only one input has compareDocumentPosition
		753	var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
		754	if ( compare ) {
		755	return compare;
		756	}
		757
		758	// Calculate position if both inputs belong to the same document
		759	compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
		760	a.compareDocumentPosition( b ) :
		761
		762	// Otherwise we know they are disconnected
		763	1;
		764
		765	// Disconnected nodes
		766	if ( compare & 1 ||
		767	(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
		768
		769	// Choose the first element that is related to our preferred document
		770	if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
		771	return -1;
		772	}
		773	if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
		774	return 1;
		775	}
		776
		777	// Maintain original order
		778	return sortInput ?
		779	( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
		780	0;
		781	}
		782
		783	return compare & 4 ? -1 : 1;
		784	} :
		785	function( a, b ) {
		786	// Exit early if the nodes are identical
		787	if ( a === b ) {
		788	hasDuplicate = true;
		789	return 0;
		790	}
		791
		792	var cur,
		793	i = 0,
		794	aup = a.parentNode,
		795	bup = b.parentNode,
		796	ap = [ a ],
		797	bp = [ b ];
		798
		799	// Parentless nodes are either documents or disconnected
		800	if ( !aup || !bup ) {
		801	return a === doc ? -1 :
		802	b === doc ? 1 :
		803	aup ? -1 :
		804	bup ? 1 :
		805	sortInput ?
		806	( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
		807	0;
		808
		809	// If the nodes are siblings, we can do a quick check
		810	} else if ( aup === bup ) {
		811	return siblingCheck( a, b );
		812	}
		813
		814	// Otherwise we need full lists of their ancestors for comparison
		815	cur = a;
		816	while ( (cur = cur.parentNode) ) {
		817	ap.unshift( cur );
		818	}
		819	cur = b;
		820	while ( (cur = cur.parentNode) ) {
		821	bp.unshift( cur );
		822	}
		823
		824	// Walk down the tree looking for a discrepancy
		825	while ( ap[i] === bp[i] ) {
		826	i++;
		827	}
		828
		829	return i ?
		830	// Do a sibling check if the nodes have a common ancestor
		831	siblingCheck( ap[i], bp[i] ) :
		832
		833	// Otherwise nodes in our document sort first
		834	ap[i] === preferredDoc ? -1 :
		835	bp[i] === preferredDoc ? 1 :
		836	0;
		837	};
		838
		839	return doc;
		840	};
		841
		842	Sizzle.matches = function( expr, elements ) {
		843	return Sizzle( expr, null, null, elements );
		844	};
		845
		846	Sizzle.matchesSelector = function( elem, expr ) {
		847	// Set document vars if needed
		848	if ( ( elem.ownerDocument || elem ) !== document ) {
		849	setDocument( elem );
		850	}
		851
		852	// Make sure that attribute selectors are quoted
		853	expr = expr.replace( rattributeQuotes, "='$1']" );
		854
		855	if ( support.matchesSelector && documentIsHTML &&
		856	( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
		857	( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {
		858
		859	try {
		860	var ret = matches.call( elem, expr );
		861
		862	// IE 9's matchesSelector returns false on disconnected nodes
		863	if ( ret || support.disconnectedMatch ||
		864	// As well, disconnected nodes are said to be in a document
		865	// fragment in IE 9
		866	elem.document && elem.document.nodeType !== 11 ) {
		867	return ret;
		868	}
		869	} catch (e) {}
		870	}
		871
		872	return Sizzle( expr, document, null, [ elem ] ).length > 0;
		873	};
		874
		875	Sizzle.contains = function( context, elem ) {
		876	// Set document vars if needed
		877	if ( ( context.ownerDocument || context ) !== document ) {
		878	setDocument( context );
		879	}
		880	return contains( context, elem );
		881	};
		882
		883	Sizzle.attr = function( elem, name ) {
		884	// Set document vars if needed
		885	if ( ( elem.ownerDocument || elem ) !== document ) {
		886	setDocument( elem );
		887	}
		888
		889	var fn = Expr.attrHandle[ name.toLowerCase() ],
		890	// Don't get fooled by Object.prototype properties (jQuery #13807)
		891	val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
		892	fn( elem, name, !documentIsHTML ) :
		893	undefined;
		894
		895	return val !== undefined ?
		896	val :
		897	support.attributes || !documentIsHTML ?
		898	elem.getAttribute( name ) :
		899	(val = elem.getAttributeNode(name)) && val.specified ?
		900	val.value :
		901	null;
		902	};
		903
		904	Sizzle.error = function( msg ) {
		905	throw new Error( "Syntax error, unrecognized expression: " + msg );
		906	};
		907
		908	/**
		909	* Document sorting and removing duplicates
		910	* @param {ArrayLike} results
		911	*/
		912	Sizzle.uniqueSort = function( results ) {
		913	var elem,
		914	duplicates = [],
		915	j = 0,
		916	i = 0;
		917
		918	// Unless we *know* we can detect duplicates, assume their presence
		919	hasDuplicate = !support.detectDuplicates;
		920	sortInput = !support.sortStable && results.slice( 0 );
		921	results.sort( sortOrder );
		922
		923	if ( hasDuplicate ) {
		924	while ( (elem = results[i++]) ) {
		925	if ( elem === results[ i ] ) {
		926	j = duplicates.push( i );
		927	}
		928	}
		929	while ( j-- ) {
		930	results.splice( duplicates[ j ], 1 );
		931	}
		932	}
		933
		934	// Clear input after sorting to release objects
		935	// See https://github.com/jquery/sizzle/pull/225
		936	sortInput = null;
		937
		938	return results;
		939	};
		940
		941	/**
		942	* Utility function for retrieving the text value of an array of DOM nodes
		943	* @param {Array|Element} elem
		944	*/
		945	getText = Sizzle.getText = function( elem ) {
		946	var node,
		947	ret = "",
		948	i = 0,
		949	nodeType = elem.nodeType;
		950
		951	if ( !nodeType ) {
		952	// If no nodeType, this is expected to be an array
		953	while ( (node = elem[i++]) ) {
		954	// Do not traverse comment nodes
		955	ret += getText( node );
		956	}
		957	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
		958	// Use textContent for elements
		959	// innerText usage removed for consistency of new lines (jQuery #11153)
		960	if ( typeof elem.textContent === "string" ) {
		961	return elem.textContent;
		962	} else {
		963	// Traverse its children
		964	for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
		965	ret += getText( elem );
		966	}
		967	}
		968	} else if ( nodeType === 3 || nodeType === 4 ) {
		969	return elem.nodeValue;
		970	}
		971	// Do not include comment or processing instruction nodes
		972
		973	return ret;
		974	};
		975
		976	Expr = Sizzle.selectors = {
		977
		978	// Can be adjusted by the user
		979	cacheLength: 50,
		980
		981	createPseudo: markFunction,
		982
		983	match: matchExpr,
		984
		985	attrHandle: {},
		986
		987	find: {},
		988
		989	relative: {
		990	">": { dir: "parentNode", first: true },
		991	" ": { dir: "parentNode" },
		992	"+": { dir: "previousSibling", first: true },
		993	"~": { dir: "previousSibling" }
		994	},
		995
		996	preFilter: {
		997	"ATTR": function( match ) {
		998	match[1] = match[1].replace( runescape, funescape );
		999
		1000	// Move the given value to match[3] whether quoted or unquoted
		1001	match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
		1002
		1003	if ( match[2] === "~=" ) {
		1004	match[3] = " " + match[3] + " ";
		1005	}
		1006
		1007	return match.slice( 0, 4 );
		1008	},
		1009
		1010	"CHILD": function( match ) {
		1011	/* matches from matchExpr["CHILD"]
		1012	1 type (only|nth|...)
		1013	2 what (child|of-type)
		1014	3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
		1015	4 xn-component of xn+y argument ([+-]?\d*n|)
		1016	5 sign of xn-component
		1017	6 x of xn-component
		1018	7 sign of y-component
		1019	8 y of y-component
		1020	*/
		1021	match[1] = match[1].toLowerCase();
		1022
		1023	if ( match[1].slice( 0, 3 ) === "nth" ) {
		1024	// nth-* requires argument
		1025	if ( !match[3] ) {
		1026	Sizzle.error( match[0] );
		1027	}
		1028
		1029	// numeric x and y parameters for Expr.filter.CHILD
		1030	// remember that false/true cast respectively to 0/1
		1031	match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
		1032	match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
		1033
		1034	// other types prohibit arguments
		1035	} else if ( match[3] ) {
		1036	Sizzle.error( match[0] );
		1037	}
		1038
		1039	return match;
		1040	},
		1041
		1042	"PSEUDO": function( match ) {
		1043	var excess,
		1044	unquoted = !match[6] && match[2];
		1045
		1046	if ( matchExpr["CHILD"].test( match[0] ) ) {
		1047	return null;
		1048	}
		1049
		1050	// Accept quoted arguments as-is
		1051	if ( match[3] ) {
		1052	match[2] = match[4] || match[5] || "";
		1053
		1054	// Strip excess characters from unquoted arguments
		1055	} else if ( unquoted && rpseudo.test( unquoted ) &&
		1056	// Get excess from tokenize (recursively)
		1057	(excess = tokenize( unquoted, true )) &&
		1058	// advance to the next closing parenthesis
		1059	(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
		1060
		1061	// excess is a negative index
		1062	match[0] = match[0].slice( 0, excess );
		1063	match[2] = unquoted.slice( 0, excess );
		1064	}
		1065
		1066	// Return only captures needed by the pseudo filter method (type and argument)
		1067	return match.slice( 0, 3 );
		1068	}
		1069	},
		1070
		1071	filter: {
		1072
		1073	"TAG": function( nodeNameSelector ) {
		1074	var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
		1075	return nodeNameSelector === "*" ?
		1076	function() { return true; } :
		1077	function( elem ) {
		1078	return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
		1079	};
		1080	},
		1081
		1082	"CLASS": function( className ) {
		1083	var pattern = classCache[ className + " " ];
		1084
		1085	return pattern ||
		1086	(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
		1087	classCache( className, function( elem ) {
		1088	return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
		1089	});
		1090	},
		1091
		1092	"ATTR": function( name, operator, check ) {
		1093	return function( elem ) {
		1094	var result = Sizzle.attr( elem, name );
		1095
		1096	if ( result == null ) {
		1097	return operator === "!=";
		1098	}
		1099	if ( !operator ) {
		1100	return true;
		1101	}
		1102
		1103	result += "";
		1104
		1105	return operator === "=" ? result === check :
		1106	operator === "!=" ? result !== check :
		1107	operator === "^=" ? check && result.indexOf( check ) === 0 :
		1108	operator === "*=" ? check && result.indexOf( check ) > -1 :
		1109	operator === "$=" ? check && result.slice( -check.length ) === check :
		1110	operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
		1111	operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
		1112	false;
		1113	};
		1114	},
		1115
		1116	"CHILD": function( type, what, argument, first, last ) {
		1117	var simple = type.slice( 0, 3 ) !== "nth",
		1118	forward = type.slice( -4 ) !== "last",
		1119	ofType = what === "of-type";
		1120
		1121	return first === 1 && last === 0 ?
		1122
		1123	// Shortcut for :nth-*(n)
		1124	function( elem ) {
		1125	return !!elem.parentNode;
		1126	} :
		1127
		1128	function( elem, context, xml ) {
		1129	var cache, outerCache, node, diff, nodeIndex, start,
		1130	dir = simple !== forward ? "nextSibling" : "previousSibling",
		1131	parent = elem.parentNode,
		1132	name = ofType && elem.nodeName.toLowerCase(),
		1133	useCache = !xml && !ofType;
		1134
		1135	if ( parent ) {
		1136
		1137	// :(first|last|only)-(child|of-type)
		1138	if ( simple ) {
		1139	while ( dir ) {
		1140	node = elem;
		1141	while ( (node = node[ dir ]) ) {
		1142	if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
		1143	return false;
		1144	}
		1145	}
		1146	// Reverse direction for :only-* (if we haven't yet done so)
		1147	start = dir = type === "only" && !start && "nextSibling";
		1148	}
		1149	return true;
		1150	}
		1151
		1152	start = [ forward ? parent.firstChild : parent.lastChild ];
		1153
		1154	// non-xml :nth-child(...) stores cache data on `parent`
		1155	if ( forward && useCache ) {
		1156	// Seek `elem` from a previously-cached index
		1157	outerCache = parent[ expando ] || (parent[ expando ] = {});
		1158	cache = outerCache[ type ] || [];
		1159	nodeIndex = cache[0] === dirruns && cache[1];
		1160	diff = cache[0] === dirruns && cache[2];
		1161	node = nodeIndex && parent.childNodes[ nodeIndex ];
		1162
		1163	while ( (node = ++nodeIndex && node && node[ dir ] ||
		1164
		1165	// Fallback to seeking `elem` from the start
		1166	(diff = nodeIndex = 0) || start.pop()) ) {
		1167
		1168	// When found, cache indexes on `parent` and break
		1169	if ( node.nodeType === 1 && ++diff && node === elem ) {
		1170	outerCache[ type ] = [ dirruns, nodeIndex, diff ];
		1171	break;
		1172	}
		1173	}
		1174
		1175	// Use previously-cached element index if available
		1176	} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
		1177	diff = cache[1];
		1178
		1179	// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
		1180	} else {
		1181	// Use the same loop as above to seek `elem` from the start
		1182	while ( (node = ++nodeIndex && node && node[ dir ] ||
		1183	(diff = nodeIndex = 0) || start.pop()) ) {
		1184
		1185	if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
		1186	// Cache the index of each encountered element
		1187	if ( useCache ) {
		1188	(node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
		1189	}
		1190
		1191	if ( node === elem ) {
		1192	break;
		1193	}
		1194	}
		1195	}
		1196	}
		1197
		1198	// Incorporate the offset, then check against cycle size
		1199	diff -= last;
		1200	return diff === first || ( diff % first === 0 && diff / first >= 0 );
		1201	}
		1202	};
		1203	},
		1204
		1205	"PSEUDO": function( pseudo, argument ) {
		1206	// pseudo-class names are case-insensitive
		1207	// http://www.w3.org/TR/selectors/#pseudo-classes
		1208	// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
		1209	// Remember that setFilters inherits from pseudos
		1210	var args,
		1211	fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
		1212	Sizzle.error( "unsupported pseudo: " + pseudo );
		1213
		1214	// The user may use createPseudo to indicate that
		1215	// arguments are needed to create the filter function
		1216	// just as Sizzle does
		1217	if ( fn[ expando ] ) {
		1218	return fn( argument );
		1219	}
		1220
		1221	// But maintain support for old signatures
		1222	if ( fn.length > 1 ) {
		1223	args = [ pseudo, pseudo, "", argument ];
		1224	return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
		1225	markFunction(function( seed, matches ) {
		1226	var idx,
		1227	matched = fn( seed, argument ),
		1228	i = matched.length;
		1229	while ( i-- ) {
		1230	idx = indexOf( seed, matched[i] );
		1231	seed[ idx ] = !( matches[ idx ] = matched[i] );
		1232	}
		1233	}) :
		1234	function( elem ) {
		1235	return fn( elem, 0, args );
		1236	};
		1237	}
		1238
		1239	return fn;
		1240	}
		1241	},
		1242
		1243	pseudos: {
		1244	// Potentially complex pseudos
		1245	"not": markFunction(function( selector ) {
		1246	// Trim the selector passed to compile
		1247	// to avoid treating leading and trailing
		1248	// spaces as combinators
		1249	var input = [],
		1250	results = [],
		1251	matcher = compile( selector.replace( rtrim, "$1" ) );
		1252
		1253	return matcher[ expando ] ?
		1254	markFunction(function( seed, matches, context, xml ) {
		1255	var elem,
		1256	unmatched = matcher( seed, null, xml, [] ),
		1257	i = seed.length;
		1258
		1259	// Match elements unmatched by `matcher`
		1260	while ( i-- ) {
		1261	if ( (elem = unmatched[i]) ) {
		1262	seed[i] = !(matches[i] = elem);
		1263	}
		1264	}
		1265	}) :
		1266	function( elem, context, xml ) {
		1267	input[0] = elem;
		1268	matcher( input, null, xml, results );
		1269	// Don't keep the element (issue #299)
		1270	input[0] = null;
		1271	return !results.pop();
		1272	};
		1273	}),
		1274
		1275	"has": markFunction(function( selector ) {
		1276	return function( elem ) {
		1277	return Sizzle( selector, elem ).length > 0;
		1278	};
		1279	}),
		1280
		1281	"contains": markFunction(function( text ) {
		1282	text = text.replace( runescape, funescape );
		1283	return function( elem ) {
		1284	return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
		1285	};
		1286	}),
		1287
		1288	// "Whether an element is represented by a :lang() selector
		1289	// is based solely on the element's language value
		1290	// being equal to the identifier C,
		1291	// or beginning with the identifier C immediately followed by "-".
		1292	// The matching of C against the element's language value is performed case-insensitively.
		1293	// The identifier C does not have to be a valid language name."
		1294	// http://www.w3.org/TR/selectors/#lang-pseudo
		1295	"lang": markFunction( function( lang ) {
		1296	// lang value must be a valid identifier
		1297	if ( !ridentifier.test(lang || "") ) {
		1298	Sizzle.error( "unsupported lang: " + lang );
		1299	}
		1300	lang = lang.replace( runescape, funescape ).toLowerCase();
		1301	return function( elem ) {
		1302	var elemLang;
		1303	do {
		1304	if ( (elemLang = documentIsHTML ?
		1305	elem.lang :
		1306	elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
		1307
		1308	elemLang = elemLang.toLowerCase();
		1309	return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
		1310	}
		1311	} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
		1312	return false;
		1313	};
		1314	}),
		1315
		1316	// Miscellaneous
		1317	"target": function( elem ) {
		1318	var hash = window.location && window.location.hash;
		1319	return hash && hash.slice( 1 ) === elem.id;
		1320	},
		1321
		1322	"root": function( elem ) {
		1323	return elem === docElem;
		1324	},
		1325
		1326	"focus": function( elem ) {
		1327	return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
		1328	},
		1329
		1330	// Boolean properties
		1331	"enabled": function( elem ) {
		1332	return elem.disabled === false;
		1333	},
		1334
		1335	"disabled": function( elem ) {
		1336	return elem.disabled === true;
		1337	},
		1338
		1339	"checked": function( elem ) {
		1340	// In CSS3, :checked should return both checked and selected elements
		1341	// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
		1342	var nodeName = elem.nodeName.toLowerCase();
		1343	return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
		1344	},
		1345
		1346	"selected": function( elem ) {
		1347	// Accessing this property makes selected-by-default
		1348	// options in Safari work properly
		1349	if ( elem.parentNode ) {
		1350	elem.parentNode.selectedIndex;
		1351	}
		1352
		1353	return elem.selected === true;
		1354	},
		1355
		1356	// Contents
		1357	"empty": function( elem ) {
		1358	// http://www.w3.org/TR/selectors/#empty-pseudo
		1359	// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
		1360	// but not by others (comment: 8; processing instruction: 7; etc.)
		1361	// nodeType < 6 works because attributes (2) do not appear as children
		1362	for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
		1363	if ( elem.nodeType < 6 ) {
		1364	return false;
		1365	}
		1366	}
		1367	return true;
		1368	},
		1369
		1370	"parent": function( elem ) {
		1371	return !Expr.pseudos["empty"]( elem );
		1372	},
		1373
		1374	// Element/input types
		1375	"header": function( elem ) {
		1376	return rheader.test( elem.nodeName );
		1377	},
		1378
		1379	"input": function( elem ) {
		1380	return rinputs.test( elem.nodeName );
		1381	},
		1382
		1383	"button": function( elem ) {
		1384	var name = elem.nodeName.toLowerCase();
		1385	return name === "input" && elem.type === "button" || name === "button";
		1386	},
		1387
		1388	"text": function( elem ) {
		1389	var attr;
		1390	return elem.nodeName.toLowerCase() === "input" &&
		1391	elem.type === "text" &&
		1392
		1393	// Support: IE<8
		1394	// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
		1395	( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
		1396	},
		1397
		1398	// Position-in-collection
		1399	"first": createPositionalPseudo(function() {
		1400	return [ 0 ];
		1401	}),
		1402
		1403	"last": createPositionalPseudo(function( matchIndexes, length ) {
		1404	return [ length - 1 ];
		1405	}),
		1406
		1407	"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
		1408	return [ argument < 0 ? argument + length : argument ];
		1409	}),
		1410
		1411	"even": createPositionalPseudo(function( matchIndexes, length ) {
		1412	var i = 0;
		1413	for ( ; i < length; i += 2 ) {
		1414	matchIndexes.push( i );
		1415	}
		1416	return matchIndexes;
		1417	}),
		1418
		1419	"odd": createPositionalPseudo(function( matchIndexes, length ) {
		1420	var i = 1;
		1421	for ( ; i < length; i += 2 ) {
		1422	matchIndexes.push( i );
		1423	}
		1424	return matchIndexes;
		1425	}),
		1426
		1427	"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
		1428	var i = argument < 0 ? argument + length : argument;
		1429	for ( ; --i >= 0; ) {
		1430	matchIndexes.push( i );
		1431	}
		1432	return matchIndexes;
		1433	}),
		1434
		1435	"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
		1436	var i = argument < 0 ? argument + length : argument;
		1437	for ( ; ++i < length; ) {
		1438	matchIndexes.push( i );
		1439	}
		1440	return matchIndexes;
		1441	})
		1442	}
		1443	};
		1444
		1445	Expr.pseudos["nth"] = Expr.pseudos["eq"];
		1446
		1447	// Add button/input type pseudos
		1448	for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
		1449	Expr.pseudos[ i ] = createInputPseudo( i );
		1450	}
		1451	for ( i in { submit: true, reset: true } ) {
		1452	Expr.pseudos[ i ] = createButtonPseudo( i );
		1453	}
		1454
		1455	// Easy API for creating new setFilters
		1456	function setFilters() {}
		1457	setFilters.prototype = Expr.filters = Expr.pseudos;
		1458	Expr.setFilters = new setFilters();
		1459
		1460	tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
		1461	var matched, match, tokens, type,
		1462	soFar, groups, preFilters,
		1463	cached = tokenCache[ selector + " " ];
		1464
		1465	if ( cached ) {
		1466	return parseOnly ? 0 : cached.slice( 0 );
		1467	}
		1468
		1469	soFar = selector;
		1470	groups = [];
		1471	preFilters = Expr.preFilter;
		1472
		1473	while ( soFar ) {
		1474
		1475	// Comma and first run
		1476	if ( !matched || (match = rcomma.exec( soFar )) ) {
		1477	if ( match ) {
		1478	// Don't consume trailing commas as valid
		1479	soFar = soFar.slice( match[0].length ) || soFar;
		1480	}
		1481	groups.push( (tokens = []) );
		1482	}
		1483
		1484	matched = false;
		1485
		1486	// Combinators
		1487	if ( (match = rcombinators.exec( soFar )) ) {
		1488	matched = match.shift();
		1489	tokens.push({
		1490	value: matched,
		1491	// Cast descendant combinators to space
		1492	type: match[0].replace( rtrim, " " )
		1493	});
		1494	soFar = soFar.slice( matched.length );
		1495	}
		1496
		1497	// Filters
		1498	for ( type in Expr.filter ) {
		1499	if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
		1500	(match = preFilters[ type ]( match ))) ) {
		1501	matched = match.shift();
		1502	tokens.push({
		1503	value: matched,
		1504	type: type,
		1505	matches: match
		1506	});
		1507	soFar = soFar.slice( matched.length );
		1508	}
		1509	}
		1510
		1511	if ( !matched ) {
		1512	break;
		1513	}
		1514	}
		1515
		1516	// Return the length of the invalid excess
		1517	// if we're just parsing
		1518	// Otherwise, throw an error or return tokens
		1519	return parseOnly ?
		1520	soFar.length :
		1521	soFar ?
		1522	Sizzle.error( selector ) :
		1523	// Cache the tokens
		1524	tokenCache( selector, groups ).slice( 0 );
		1525	};
		1526
		1527	function toSelector( tokens ) {
		1528	var i = 0,
		1529	len = tokens.length,
		1530	selector = "";
		1531	for ( ; i < len; i++ ) {
		1532	selector += tokens[i].value;
		1533	}
		1534	return selector;
		1535	}
		1536
		1537	function addCombinator( matcher, combinator, base ) {
		1538	var dir = combinator.dir,
		1539	checkNonElements = base && dir === "parentNode",
		1540	doneName = done++;
		1541
		1542	return combinator.first ?
		1543	// Check against closest ancestor/preceding element
		1544	function( elem, context, xml ) {
		1545	while ( (elem = elem[ dir ]) ) {
		1546	if ( elem.nodeType === 1 || checkNonElements ) {
		1547	return matcher( elem, context, xml );
		1548	}
		1549	}
		1550	} :
		1551
		1552	// Check against all ancestor/preceding elements
		1553	function( elem, context, xml ) {
		1554	var oldCache, outerCache,
		1555	newCache = [ dirruns, doneName ];
		1556
		1557	// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
		1558	if ( xml ) {
		1559	while ( (elem = elem[ dir ]) ) {
		1560	if ( elem.nodeType === 1 || checkNonElements ) {
		1561	if ( matcher( elem, context, xml ) ) {
		1562	return true;
		1563	}
		1564	}
		1565	}
		1566	} else {
		1567	while ( (elem = elem[ dir ]) ) {
		1568	if ( elem.nodeType === 1 || checkNonElements ) {
		1569	outerCache = elem[ expando ] || (elem[ expando ] = {});
		1570	if ( (oldCache = outerCache[ dir ]) &&
		1571	oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
		1572
		1573	// Assign to newCache so results back-propagate to previous elements
		1574	return (newCache[ 2 ] = oldCache[ 2 ]);
		1575	} else {
		1576	// Reuse newcache so results back-propagate to previous elements
		1577	outerCache[ dir ] = newCache;
		1578
		1579	// A match means we're done; a fail means we have to keep checking
		1580	if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
		1581	return true;
		1582	}
		1583	}
		1584	}
		1585	}
		1586	}
		1587	};
		1588	}
		1589
		1590	function elementMatcher( matchers ) {
		1591	return matchers.length > 1 ?
		1592	function( elem, context, xml ) {
		1593	var i = matchers.length;
		1594	while ( i-- ) {
		1595	if ( !matchers[i]( elem, context, xml ) ) {
		1596	return false;
		1597	}
		1598	}
		1599	return true;
		1600	} :
		1601	matchers[0];
		1602	}
		1603
		1604	function multipleContexts( selector, contexts, results ) {
		1605	var i = 0,
		1606	len = contexts.length;
		1607	for ( ; i < len; i++ ) {
		1608	Sizzle( selector, contexts[i], results );
		1609	}
		1610	return results;
		1611	}
		1612
		1613	function condense( unmatched, map, filter, context, xml ) {
		1614	var elem,
		1615	newUnmatched = [],
		1616	i = 0,
		1617	len = unmatched.length,
		1618	mapped = map != null;
		1619
		1620	for ( ; i < len; i++ ) {
		1621	if ( (elem = unmatched[i]) ) {
		1622	if ( !filter || filter( elem, context, xml ) ) {
		1623	newUnmatched.push( elem );
		1624	if ( mapped ) {
		1625	map.push( i );
		1626	}
		1627	}
		1628	}
		1629	}
		1630
		1631	return newUnmatched;
		1632	}
		1633
		1634	function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
		1635	if ( postFilter && !postFilter[ expando ] ) {
		1636	postFilter = setMatcher( postFilter );
		1637	}
		1638	if ( postFinder && !postFinder[ expando ] ) {
		1639	postFinder = setMatcher( postFinder, postSelector );
		1640	}
		1641	return markFunction(function( seed, results, context, xml ) {
		1642	var temp, i, elem,
		1643	preMap = [],
		1644	postMap = [],
		1645	preexisting = results.length,
		1646
		1647	// Get initial elements from seed or context
		1648	elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
		1649
		1650	// Prefilter to get matcher input, preserving a map for seed-results synchronization
		1651	matcherIn = preFilter && ( seed || !selector ) ?
		1652	condense( elems, preMap, preFilter, context, xml ) :
		1653	elems,
		1654
		1655	matcherOut = matcher ?
		1656	// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
		1657	postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
		1658
		1659	// ...intermediate processing is necessary
		1660	[] :
		1661
		1662	// ...otherwise use results directly
		1663	results :
		1664	matcherIn;
		1665
		1666	// Find primary matches
		1667	if ( matcher ) {
		1668	matcher( matcherIn, matcherOut, context, xml );
		1669	}
		1670
		1671	// Apply postFilter
		1672	if ( postFilter ) {
		1673	temp = condense( matcherOut, postMap );
		1674	postFilter( temp, [], context, xml );
		1675
		1676	// Un-match failing elements by moving them back to matcherIn
		1677	i = temp.length;
		1678	while ( i-- ) {
		1679	if ( (elem = temp[i]) ) {
		1680	matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
		1681	}
		1682	}
		1683	}
		1684
		1685	if ( seed ) {
		1686	if ( postFinder || preFilter ) {
		1687	if ( postFinder ) {
		1688	// Get the final matcherOut by condensing this intermediate into postFinder contexts
		1689	temp = [];
		1690	i = matcherOut.length;
		1691	while ( i-- ) {
		1692	if ( (elem = matcherOut[i]) ) {
		1693	// Restore matcherIn since elem is not yet a final match
		1694	temp.push( (matcherIn[i] = elem) );
		1695	}
		1696	}
		1697	postFinder( null, (matcherOut = []), temp, xml );
		1698	}
		1699
		1700	// Move matched elements from seed to results to keep them synchronized
		1701	i = matcherOut.length;
		1702	while ( i-- ) {
		1703	if ( (elem = matcherOut[i]) &&
		1704	(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
		1705
		1706	seed[temp] = !(results[temp] = elem);
		1707	}
		1708	}
		1709	}
		1710
		1711	// Add elements to results, through postFinder if defined
		1712	} else {
		1713	matcherOut = condense(
		1714	matcherOut === results ?
		1715	matcherOut.splice( preexisting, matcherOut.length ) :
		1716	matcherOut
		1717	);
		1718	if ( postFinder ) {
		1719	postFinder( null, results, matcherOut, xml );
		1720	} else {
		1721	push.apply( results, matcherOut );
		1722	}
		1723	}
		1724	});
		1725	}
		1726
		1727	function matcherFromTokens( tokens ) {
		1728	var checkContext, matcher, j,
		1729	len = tokens.length,
		1730	leadingRelative = Expr.relative[ tokens[0].type ],
		1731	implicitRelative = leadingRelative || Expr.relative[" "],
		1732	i = leadingRelative ? 1 : 0,
		1733
		1734	// The foundational matcher ensures that elements are reachable from top-level context(s)
		1735	matchContext = addCombinator( function( elem ) {
		1736	return elem === checkContext;
		1737	}, implicitRelative, true ),
		1738	matchAnyContext = addCombinator( function( elem ) {
		1739	return indexOf( checkContext, elem ) > -1;
		1740	}, implicitRelative, true ),
		1741	matchers = [ function( elem, context, xml ) {
		1742	var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
		1743	(checkContext = context).nodeType ?
		1744	matchContext( elem, context, xml ) :
		1745	matchAnyContext( elem, context, xml ) );
		1746	// Avoid hanging onto element (issue #299)
		1747	checkContext = null;
		1748	return ret;
		1749	} ];
		1750
		1751	for ( ; i < len; i++ ) {
		1752	if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
		1753	matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
		1754	} else {
		1755	matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
		1756
		1757	// Return special upon seeing a positional matcher
		1758	if ( matcher[ expando ] ) {
		1759	// Find the next relative operator (if any) for proper handling
		1760	j = ++i;
		1761	for ( ; j < len; j++ ) {
		1762	if ( Expr.relative[ tokens[j].type ] ) {
		1763	break;
		1764	}
		1765	}
		1766	return setMatcher(
		1767	i > 1 && elementMatcher( matchers ),
		1768	i > 1 && toSelector(
		1769	// If the preceding token was a descendant combinator, insert an implicit any-element `*`
		1770	tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
		1771	).replace( rtrim, "$1" ),
		1772	matcher,
		1773	i < j && matcherFromTokens( tokens.slice( i, j ) ),
		1774	j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
		1775	j < len && toSelector( tokens )
		1776	);
		1777	}
		1778	matchers.push( matcher );
		1779	}
		1780	}
		1781
		1782	return elementMatcher( matchers );
		1783	}
		1784
		1785	function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
		1786	var bySet = setMatchers.length > 0,
		1787	byElement = elementMatchers.length > 0,
		1788	superMatcher = function( seed, context, xml, results, outermost ) {
		1789	var elem, j, matcher,
		1790	matchedCount = 0,
		1791	i = "0",
		1792	unmatched = seed && [],
		1793	setMatched = [],
		1794	contextBackup = outermostContext,
		1795	// We must always have either seed elements or outermost context
		1796	elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
		1797	// Use integer dirruns iff this is the outermost matcher
		1798	dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
		1799	len = elems.length;
		1800
		1801	if ( outermost ) {
		1802	outermostContext = context !== document && context;
		1803	}
		1804
		1805	// Add elements passing elementMatchers directly to results
		1806	// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
		1807	// Support: IE<9, Safari
		1808	// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
		1809	for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
		1810	if ( byElement && elem ) {
		1811	j = 0;
		1812	while ( (matcher = elementMatchers[j++]) ) {
		1813	if ( matcher( elem, context, xml ) ) {
		1814	results.push( elem );
		1815	break;
		1816	}
		1817	}
		1818	if ( outermost ) {
		1819	dirruns = dirrunsUnique;
		1820	}
		1821	}
		1822
		1823	// Track unmatched elements for set filters
		1824	if ( bySet ) {
		1825	// They will have gone through all possible matchers
		1826	if ( (elem = !matcher && elem) ) {
		1827	matchedCount--;
		1828	}
		1829
		1830	// Lengthen the array for every element, matched or not
		1831	if ( seed ) {
		1832	unmatched.push( elem );
		1833	}
		1834	}
		1835	}
		1836
		1837	// Apply set filters to unmatched elements
		1838	matchedCount += i;
		1839	if ( bySet && i !== matchedCount ) {
		1840	j = 0;
		1841	while ( (matcher = setMatchers[j++]) ) {
		1842	matcher( unmatched, setMatched, context, xml );
		1843	}
		1844
		1845	if ( seed ) {
		1846	// Reintegrate element matches to eliminate the need for sorting
		1847	if ( matchedCount > 0 ) {
		1848	while ( i-- ) {
		1849	if ( !(unmatched[i] || setMatched[i]) ) {
		1850	setMatched[i] = pop.call( results );
		1851	}
		1852	}
		1853	}
		1854
		1855	// Discard index placeholder values to get only actual matches
		1856	setMatched = condense( setMatched );
		1857	}
		1858
		1859	// Add matches to results
		1860	push.apply( results, setMatched );
		1861
		1862	// Seedless set matches succeeding multiple successful matchers stipulate sorting
		1863	if ( outermost && !seed && setMatched.length > 0 &&
		1864	( matchedCount + setMatchers.length ) > 1 ) {
		1865
		1866	Sizzle.uniqueSort( results );
		1867	}
		1868	}
		1869
		1870	// Override manipulation of globals by nested matchers
		1871	if ( outermost ) {
		1872	dirruns = dirrunsUnique;
		1873	outermostContext = contextBackup;
		1874	}
		1875
		1876	return unmatched;
		1877	};
		1878
		1879	return bySet ?
		1880	markFunction( superMatcher ) :
		1881	superMatcher;
		1882	}
		1883
		1884	compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
		1885	var i,
		1886	setMatchers = [],
		1887	elementMatchers = [],
		1888	cached = compilerCache[ selector + " " ];
		1889
		1890	if ( !cached ) {
		1891	// Generate a function of recursive functions that can be used to check each element
		1892	if ( !match ) {
		1893	match = tokenize( selector );
		1894	}
		1895	i = match.length;
		1896	while ( i-- ) {
		1897	cached = matcherFromTokens( match[i] );
		1898	if ( cached[ expando ] ) {
		1899	setMatchers.push( cached );
		1900	} else {
		1901	elementMatchers.push( cached );
		1902	}
		1903	}
		1904
		1905	// Cache the compiled function
		1906	cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
		1907
		1908	// Save selector and tokenization
		1909	cached.selector = selector;
		1910	}
		1911	return cached;
		1912	};
		1913
		1914	/**
		1915	* A low-level selection function that works with Sizzle's compiled
		1916	* selector functions
		1917	* @param {String|Function} selector A selector or a pre-compiled
		1918	* selector function built with Sizzle.compile
		1919	* @param {Element} context
		1920	* @param {Array} [results]
		1921	* @param {Array} [seed] A set of elements to match against
		1922	*/
		1923	select = Sizzle.select = function( selector, context, results, seed ) {
		1924	var i, tokens, token, type, find,
		1925	compiled = typeof selector === "function" && selector,
		1926	match = !seed && tokenize( (selector = compiled.selector || selector) );
		1927
		1928	results = results || [];
		1929
		1930	// Try to minimize operations if there is no seed and only one group
		1931	if ( match.length === 1 ) {
		1932
		1933	// Take a shortcut and set the context if the root selector is an ID
		1934	tokens = match[0] = match[0].slice( 0 );
		1935	if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
		1936	support.getById && context.nodeType === 9 && documentIsHTML &&
		1937	Expr.relative[ tokens[1].type ] ) {
		1938
		1939	context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
		1940	if ( !context ) {
		1941	return results;
		1942
		1943	// Precompiled matchers will still verify ancestry, so step up a level
		1944	} else if ( compiled ) {
		1945	context = context.parentNode;
		1946	}
		1947
		1948	selector = selector.slice( tokens.shift().value.length );
		1949	}
		1950
		1951	// Fetch a seed set for right-to-left matching
		1952	i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
		1953	while ( i-- ) {
		1954	token = tokens[i];
		1955
		1956	// Abort if we hit a combinator
		1957	if ( Expr.relative[ (type = token.type) ] ) {
		1958	break;
		1959	}
		1960	if ( (find = Expr.find[ type ]) ) {
		1961	// Search, expanding context for leading sibling combinators
		1962	if ( (seed = find(
		1963	token.matches[0].replace( runescape, funescape ),
		1964	rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
		1965	)) ) {
		1966
		1967	// If seed is empty or no tokens remain, we can return early
		1968	tokens.splice( i, 1 );
		1969	selector = seed.length && toSelector( tokens );
		1970	if ( !selector ) {
		1971	push.apply( results, seed );
		1972	return results;
		1973	}
		1974
		1975	break;
		1976	}
		1977	}
		1978	}
		1979	}
		1980
		1981	// Compile and execute a filtering function if one is not provided
		1982	// Provide `match` to avoid retokenization if we modified the selector above
		1983	( compiled || compile( selector, match ) )(
		1984	seed,
		1985	context,
		1986	!documentIsHTML,
		1987	results,
		1988	rsibling.test( selector ) && testContext( context.parentNode ) || context
		1989	);
		1990	return results;
		1991	};
		1992
		1993	// One-time assignments
		1994
		1995	// Sort stability
		1996	support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
		1997
		1998	// Support: Chrome 14-35+
		1999	// Always assume duplicates if they aren't passed to the comparison function
		2000	support.detectDuplicates = !!hasDuplicate;
		2001
		2002	// Initialize against the default document
		2003	setDocument();
		2004
		2005	// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
		2006	// Detached nodes confoundingly follow *each other*
		2007	support.sortDetached = assert(function( div1 ) {
		2008	// Should return 1, but returns 4 (following)
		2009	return div1.compareDocumentPosition( document.createElement("div") ) & 1;
		2010	});
		2011
		2012	// Support: IE<8
		2013	// Prevent attribute/property "interpolation"
		2014	// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
		2015	if ( !assert(function( div ) {
		2016	div.innerHTML = "<a href='#'></a>";
		2017	return div.firstChild.getAttribute("href") === "#" ;
		2018	}) ) {
		2019	addHandle( "type|href|height|width", function( elem, name, isXML ) {
		2020	if ( !isXML ) {
		2021	return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
		2022	}
		2023	});
		2024	}
		2025
		2026	// Support: IE<9
		2027	// Use defaultValue in place of getAttribute("value")
		2028	if ( !support.attributes || !assert(function( div ) {
		2029	div.innerHTML = "<input/>";
		2030	div.firstChild.setAttribute( "value", "" );
		2031	return div.firstChild.getAttribute( "value" ) === "";
		2032	}) ) {
		2033	addHandle( "value", function( elem, name, isXML ) {
		2034	if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
		2035	return elem.defaultValue;
		2036	}
		2037	});
		2038	}
		2039
		2040	// Support: IE<9
		2041	// Use getAttributeNode to fetch booleans when getAttribute lies
		2042	if ( !assert(function( div ) {
		2043	return div.getAttribute("disabled") == null;
		2044	}) ) {
		2045	addHandle( booleans, function( elem, name, isXML ) {
		2046	var val;
		2047	if ( !isXML ) {
		2048	return elem[ name ] === true ? name.toLowerCase() :
		2049	(val = elem.getAttributeNode( name )) && val.specified ?
		2050	val.value :
		2051	null;
		2052	}
		2053	});
		2054	}
		2055
		2056	// EXPOSE
		2057	if ( typeof define === "function" && define.amd ) {
		2058	define(function() { return Sizzle; });
		2059	// Sizzle requires that there be a global window in Common-JS like environments
		2060	} else if ( typeof module !== "undefined" && module.exports ) {
		2061	module.exports = Sizzle;
		2062	} else {
		2063	window.Sizzle = Sizzle;
		2064	}
		2065	// EXPOSE
		2066
		2067	})( window );