https://buscacepinter.correios.com.br/lib/jquery/jquery.js

1/*!
2 * jQuery JavaScript Library v3.2.1
3 * https://jquery.com/
4 *
5 * Includes Sizzle.js
6 * https://sizzlejs.com/
7 *
8 * Copyright JS Foundation and other contributors
9 * Released under the MIT license
10 * https://jquery.org/license
11 *
12 * Date: 2017-03-20T18:59Z
13 */
14( function( global, factory ) {
15
16	"use strict";
17
18	if ( typeof module === "object" && typeof module.exports === "object" ) {
19
20		// For CommonJS and CommonJS-like environments where a proper `window`
21		// is present, execute the factory and get jQuery.
22		// For environments that do not have a `window` with a `document`
23		// (such as Node.js), expose a factory as module.exports.
24		// This accentuates the need for the creation of a real `window`.
25		// e.g. var jQuery = require("jquery")(window);
26		// See ticket #14549 for more info.
27		module.exports = global.document ?
28			factory( global, true ) :
29			function( w ) {
30				if ( !w.document ) {
31					throw new Error( "jQuery requires a window with a document" );
32				}
33				return factory( w );
34			};
35	} else {
36		factory( global );
37	}
38
39// Pass this if window is not defined yet
40} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
41
42// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
43// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
44// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
45// enough that all such attempts are guarded in a try block.
46"use strict";
47
48var arr = [];
49
50var document = window.document;
51
52var getProto = Object.getPrototypeOf;
53
54var slice = arr.slice;
55
56var concat = arr.concat;
57
58var push = arr.push;
59
60var indexOf = arr.indexOf;
61
62var class2type = {};
63
64var toString = class2type.toString;
65
66var hasOwn = class2type.hasOwnProperty;
67
68var fnToString = hasOwn.toString;
69
70var ObjectFunctionString = fnToString.call( Object );
71
72var support = {};
73
74
75
76	function DOMEval( code, doc ) {
77		doc = doc || document;
78
79		var script = doc.createElement( "script" );
80
81		script.text = code;
82		doc.head.appendChild( script ).parentNode.removeChild( script );
83	}
84/* global Symbol */
85// Defining this global in .eslintrc.json would create a danger of using the global
86// unguarded in another place, it seems safer to define global only for this module
87
88
89
90var
91	version = "3.2.1",
92
93	// Define a local copy of jQuery
94	jQuery = function( selector, context ) {
95
96		// The jQuery object is actually just the init constructor 'enhanced'
97		// Need init if jQuery is called (just allow error to be thrown if not included)
98		return new jQuery.fn.init( selector, context );
99	},
100
101	// Support: Android <=4.0 only
102	// Make sure we trim BOM and NBSP
103	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
104
105	// Matches dashed string for camelizing
106	rmsPrefix = /^-ms-/,
107	rdashAlpha = /-([a-z])/g,
108
109	// Used by jQuery.camelCase as callback to replace()
110	fcamelCase = function( all, letter ) {
111		return letter.toUpperCase();
112	};
113
114jQuery.fn = jQuery.prototype = {
115
116	// The current version of jQuery being used
117	jquery: version,
118
119	constructor: jQuery,
120
121	// The default length of a jQuery object is 0
122	length: 0,
123
124	toArray: function() {
125		return slice.call( this );
126	},
127
128	// Get the Nth element in the matched element set OR
129	// Get the whole matched element set as a clean array
130	get: function( num ) {
131
132		// Return all the elements in a clean array
133		if ( num == null ) {
134			return slice.call( this );
135		}
136
137		// Return just the one element from the set
138		return num < 0 ? this[ num + this.length ] : this[ num ];
139	},
140
141	// Take an array of elements and push it onto the stack
142	// (returning the new matched element set)
143	pushStack: function( elems ) {
144
145		// Build a new jQuery matched element set
146		var ret = jQuery.merge( this.constructor(), elems );
147
148		// Add the old object onto the stack (as a reference)
149		ret.prevObject = this;
150
151		// Return the newly-formed element set
152		return ret;
153	},
154
155	// Execute a callback for every element in the matched set.
156	each: function( callback ) {
157		return jQuery.each( this, callback );
158	},
159
160	map: function( callback ) {
161		return this.pushStack( jQuery.map( this, function( elem, i ) {
162			return callback.call( elem, i, elem );
163		} ) );
164	},
165
166	slice: function() {
167		return this.pushStack( slice.apply( this, arguments ) );
168	},
169
170	first: function() {
171		return this.eq( 0 );
172	},
173
174	last: function() {
175		return this.eq( -1 );
176	},
177
178	eq: function( i ) {
179		var len = this.length,
180			j = +i + ( i < 0 ? len : 0 );
181		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
182	},
183
184	end: function() {
185		return this.prevObject || this.constructor();
186	},
187
188	// For internal use only.
189	// Behaves like an Array's method, not like a jQuery method.
190	push: push,
191	sort: arr.sort,
192	splice: arr.splice
193};
194
195jQuery.extend = jQuery.fn.extend = function() {
196	var options, name, src, copy, copyIsArray, clone,
197		target = arguments[ 0 ] || {},
198		i = 1,
199		length = arguments.length,
200		deep = false;
201
202	// Handle a deep copy situation
203	if ( typeof target === "boolean" ) {
204		deep = target;
205
206		// Skip the boolean and the target
207		target = arguments[ i ] || {};
208		i++;
209	}
210
211	// Handle case when target is a string or something (possible in deep copy)
212	if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
213		target = {};
214	}
215
216	// Extend jQuery itself if only one argument is passed
217	if ( i === length ) {
218		target = this;
219		i--;
220	}
221
222	for ( ; i < length; i++ ) {
223
224		// Only deal with non-null/undefined values
225		if ( ( options = arguments[ i ] ) != null ) {
226
227			// Extend the base object
228			for ( name in options ) {
229				src = target[ name ];
230				copy = options[ name ];
231
232				// Prevent never-ending loop
233				if ( target === copy ) {
234					continue;
235				}
236
237				// Recurse if we're merging plain objects or arrays
238				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
239					( copyIsArray = Array.isArray( copy ) ) ) ) {
240
241					if ( copyIsArray ) {
242						copyIsArray = false;
243						clone = src && Array.isArray( src ) ? src : [];
244
245					} else {
246						clone = src && jQuery.isPlainObject( src ) ? src : {};
247					}
248
249					// Never move original objects, clone them
250					target[ name ] = jQuery.extend( deep, clone, copy );
251
252				// Don't bring in undefined values
253				} else if ( copy !== undefined ) {
254					target[ name ] = copy;
255				}
256			}
257		}
258	}
259
260	// Return the modified object
261	return target;
262};
263
264jQuery.extend( {
265
266	// Unique for each copy of jQuery on the page
267	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
268
269	// Assume jQuery is ready without the ready module
270	isReady: true,
271
272	error: function( msg ) {
273		throw new Error( msg );
274	},
275
276	noop: function() {},
277
278	isFunction: function( obj ) {
279		return jQuery.type( obj ) === "function";
280	},
281
282	isWindow: function( obj ) {
283		return obj != null && obj === obj.window;
284	},
285
286	isNumeric: function( obj ) {
287
288		// As of jQuery 3.0, isNumeric is limited to
289		// strings and numbers (primitives or objects)
290		// that can be coerced to finite numbers (gh-2662)
291		var type = jQuery.type( obj );
292		return ( type === "number" || type === "string" ) &&
293
294			// parseFloat NaNs numeric-cast false positives ("")
295			// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
296			// subtraction forces infinities to NaN
297			!isNaN( obj - parseFloat( obj ) );
298	},
299
300	isPlainObject: function( obj ) {
301		var proto, Ctor;
302
303		// Detect obvious negatives
304		// Use toString instead of jQuery.type to catch host objects
305		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
306			return false;
307		}
308
309		proto = getProto( obj );
310
311		// Objects with no prototype (e.g., `Object.create( null )`) are plain
312		if ( !proto ) {
313			return true;
314		}
315
316		// Objects with prototype are plain iff they were constructed by a global Object function
317		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
318		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
319	},
320
321	isEmptyObject: function( obj ) {
322
323		/* eslint-disable no-unused-vars */
324		// See https://github.com/eslint/eslint/issues/6125
325		var name;
326
327		for ( name in obj ) {
328			return false;
329		}
330		return true;
331	},
332
333	type: function( obj ) {
334		if ( obj == null ) {
335			return obj + "";
336		}
337
338		// Support: Android <=2.3 only (functionish RegExp)
339		return typeof obj === "object" || typeof obj === "function" ?
340			class2type[ toString.call( obj ) ] || "object" :
341			typeof obj;
342	},
343
344	// Evaluates a script in a global context
345	globalEval: function( code ) {
346		DOMEval( code );
347	},
348
349	// Convert dashed to camelCase; used by the estilos and data modules
350	// Support: IE <=9 - 11, Edge 12 - 13
351	// Microsoft forgot to hump their vendor prefix (#9572)
352	camelCase: function( string ) {
353		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
354	},
355
356	each: function( obj, callback ) {
357		var length, i = 0;
358
359		if ( isArrayLike( obj ) ) {
360			length = obj.length;
361			for ( ; i < length; i++ ) {
362				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
363					break;
364				}
365			}
366		} else {
367			for ( i in obj ) {
368				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
369					break;
370				}
371			}
372		}
373
374		return obj;
375	},
376
377	// Support: Android <=4.0 only
378	trim: function( text ) {
379		return text == null ?
380			"" :
381			( text + "" ).replace( rtrim, "" );
382	},
383
384	// results is for internal usage only
385	makeArray: function( arr, results ) {
386		var ret = results || [];
387
388		if ( arr != null ) {
389			if ( isArrayLike( Object( arr ) ) ) {
390				jQuery.merge( ret,
391					typeof arr === "string" ?
392					[ arr ] : arr
393				);
394			} else {
395				push.call( ret, arr );
396			}
397		}
398
399		return ret;
400	},
401
402	inArray: function( elem, arr, i ) {
403		return arr == null ? -1 : indexOf.call( arr, elem, i );
404	},
405
406	// Support: Android <=4.0 only, PhantomJS 1 only
407	// push.apply(_, arraylike) throws on ancient WebKit
408	merge: function( first, second ) {
409		var len = +second.length,
410			j = 0,
411			i = first.length;
412
413		for ( ; j < len; j++ ) {
414			first[ i++ ] = second[ j ];
415		}
416
417		first.length = i;
418
419		return first;
420	},
421
422	grep: function( elems, callback, invert ) {
423		var callbackInverse,
424			matches = [],
425			i = 0,
426			length = elems.length,
427			callbackExpect = !invert;
428
429		// Go through the array, only saving the items
430		// that pass the validator function
431		for ( ; i < length; i++ ) {
432			callbackInverse = !callback( elems[ i ], i );
433			if ( callbackInverse !== callbackExpect ) {
434				matches.push( elems[ i ] );
435			}
436		}
437
438		return matches;
439	},
440
441	// arg is for internal usage only
442	map: function( elems, callback, arg ) {
443		var length, value,
444			i = 0,
445			ret = [];
446
447		// Go through the array, translating each of the items to their new values
448		if ( isArrayLike( elems ) ) {
449			length = elems.length;
450			for ( ; i < length; i++ ) {
451				value = callback( elems[ i ], i, arg );
452
453				if ( value != null ) {
454					ret.push( value );
455				}
456			}
457
458		// Go through every key on the object,
459		} else {
460			for ( i in elems ) {
461				value = callback( elems[ i ], i, arg );
462
463				if ( value != null ) {
464					ret.push( value );
465				}
466			}
467		}
468
469		// Flatten any nested arrays
470		return concat.apply( [], ret );
471	},
472
473	// A global GUID counter for objects
474	guid: 1,
475
476	// Bind a function to a context, optionally partially applying any
477	// arguments.
478	proxy: function( fn, context ) {
479		var tmp, args, proxy;
480
481		if ( typeof context === "string" ) {
482			tmp = fn[ context ];
483			context = fn;
484			fn = tmp;
485		}
486
487		// Quick check to determine if target is callable, in the spec
488		// this throws a TypeError, but we will just return undefined.
489		if ( !jQuery.isFunction( fn ) ) {
490			return undefined;
491		}
492
493		// Simulated bind
494		args = slice.call( arguments, 2 );
495		proxy = function() {
496			return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
497		};
498
499		// Set the guid of unique handler to the same of original handler, so it can be removed
500		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
501
502		return proxy;
503	},
504
505	now: Date.now,
506
507	// jQuery.support is not used in Core but other projects attach their
508	// properties to it so it needs to exist.
509	support: support
510} );
511
512if ( typeof Symbol === "function" ) {
513	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
514}
515
516// Populate the class2type map
517jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
518function( i, name ) {
519	class2type[ "[object " + name + "]" ] = name.toLowerCase();
520} );
521
522function isArrayLike( obj ) {
523
524	// Support: real iOS 8.2 only (not reproducible in simulator)
525	// `in` check used to prevent JIT error (gh-2145)
526	// hasOwn isn't used here due to false negatives
527	// regarding Nodelist length in IE
528	var length = !!obj && "length" in obj && obj.length,
529		type = jQuery.type( obj );
530
531	if ( type === "function" || jQuery.isWindow( obj ) ) {
532		return false;
533	}
534
535	return type === "array" || length === 0 ||
536		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
537}
538var Sizzle =
539/*!
540 * Sizzle CSS Selector Engine v2.3.3
541 * https://sizzlejs.com/
542 *
543 * Copyright jQuery Foundation and other contributors
544 * Released under the MIT license
545 * http://jquery.org/license
546 *
547 * Date: 2016-08-08
548 */
549(function( window ) {
550
551var i,
552	support,
553	Expr,
554	getText,
555	isXML,
556	tokenize,
557	compile,
558	select,
559	outermostContext,
560	sortInput,
561	hasDuplicate,
562
563	// Local document vars
564	setDocument,
565	document,
566	docElem,
567	documentIsHTML,
568	rbuggyQSA,
569	rbuggyMatches,
570	matches,
571	contains,
572
573	// Instance-specific data
574	expando = "sizzle" + 1 * new Date(),
575	preferredDoc = window.document,
576	dirruns = 0,
577	done = 0,
578	classCache = createCache(),
579	tokenCache = createCache(),
580	compilerCache = createCache(),
581	sortOrder = function( a, b ) {
582		if ( a === b ) {
583			hasDuplicate = true;
584		}
585		return 0;
586	},
587
588	// Instance methods
589	hasOwn = ({}).hasOwnProperty,
590	arr = [],
591	pop = arr.pop,
592	push_native = arr.push,
593	push = arr.push,
594	slice = arr.slice,
595	// Use a stripped-down indexOf as it's faster than native
596	// https://jsperf.com/thor-indexof-vs-for/5
597	indexOf = function( list, elem ) {
598		var i = 0,
599			len = list.length;
600		for ( ; i < len; i++ ) {
601			if ( list[i] === elem ) {
602				return i;
603			}
604		}
605		return -1;
606	},
607
608	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
609
610	// Regular expressions
611
612	// http://www.w3.org/TR/css3-selectors/#whitespace
613	whitespace = "[\\x20\\t\\r\\n\\f]",
614
615	// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
616	identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
617
618	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
619	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
620		// Operator (capture 2)
621		"*([*^$|!~]?=)" + whitespace +
622		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
623		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
624		"*\\]",
625
626	pseudos = ":(" + identifier + ")(?:\\((" +
627		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
628		// 1. quoted (capture 3; capture 4 or capture 5)

1629			// Do not traverse comment nodes
1630			ret += getText( node );
1631		}
1632	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1633		// Use textContent for elements
1634		// innerText usage removed for consistency of new lines (jQuery #11153)
1635		if ( typeof elem.textContent === "string" ) {
1636			return elem.textContent;
1637		} else {
1638			// Traverse its children
1639			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1640				ret += getText( elem );
1641			}
1642		}
1643	} else if ( nodeType === 3 || nodeType === 4 ) {
1644		return elem.nodeValue;
1645	}
1646	// Do not include comment or processing instruction nodes
1647
1648	return ret;
1649};
1650
1651Expr = Sizzle.selectors = {
1652
1653	// Can be adjusted by the user
1654	cacheLength: 50,
1655
1656	createPseudo: markFunction,
1657
1658	match: matchExpr,
1659
1660	attrHandle: {},
1661
1662	find: {},
1663
1664	relative: {
1665		">": { dir: "parentNode", first: true },
1666		" ": { dir: "parentNode" },
1667		"+": { dir: "previousSibling", first: true },
1668		"~": { dir: "previousSibling" }
1669	},
1670
1671	preFilter: {
1672		"ATTR": function( match ) {
1673			match[1] = match[1].replace( runescape, funescape );
1674
1675			// Move the given value to match[3] whether quoted or unquoted
1676			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
1677
1678			if ( match[2] === "~=" ) {
1679				match[3] = " " + match[3] + " ";
1680			}
1681
1682			return match.slice( 0, 4 );
1683		},
1684
1685		"CHILD": function( match ) {
1686			/* matches from matchExpr["CHILD"]
1687				1 type (only|nth|...)
1688				2 what (child|of-type)
1689				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1690				4 xn-component of xn+y argument ([+-]?\d*n|)
1691				5 sign of xn-component
1692				6 x of xn-component
1693				7 sign of y-component
1694				8 y of y-component
1695			*/
1696			match[1] = match[1].toLowerCase();
1697
1698			if ( match[1].slice( 0, 3 ) === "nth" ) {
1699				// nth-* requires argument
1700				if ( !match[3] ) {
1701					Sizzle.error( match[0] );
1702				}
1703
1704				// numeric x and y parameters for Expr.filter.CHILD
1705				// remember that false/true cast respectively to 0/1
1706				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1707				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1708
1709			// other types prohibit arguments
1710			} else if ( match[3] ) {
1711				Sizzle.error( match[0] );
1712			}
1713
1714			return match;
1715		},
1716
1717		"PSEUDO": function( match ) {
1718			var excess,
1719				unquoted = !match[6] && match[2];
1720
1721			if ( matchExpr["CHILD"].test( match[0] ) ) {
1722				return null;
1723			}
1724
1725			// Accept quoted arguments as-is
1726			if ( match[3] ) {
1727				match[2] = match[4] || match[5] || "";
1728
1729			// Strip excess characters from unquoted arguments
1730			} else if ( unquoted && rpseudo.test( unquoted ) &&
1731				// Get excess from tokenize (recursively)
1732				(excess = tokenize( unquoted, true )) &&
1733				// advance to the next closing parenthesis
1734				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
1735
1736				// excess is a negative index
1737				match[0] = match[0].slice( 0, excess );
1738				match[2] = unquoted.slice( 0, excess );
1739			}
1740
1741			// Return only captures needed by the pseudo filter method (type and argument)
1742			return match.slice( 0, 3 );
1743		}
1744	},
1745
1746	filter: {
1747
1748		"TAG": function( nodeNameSelector ) {
1749			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1750			return nodeNameSelector === "*" ?
1751				function() { return true; } :
1752				function( elem ) {
1753					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1754				};
1755		},
1756
1757		"CLASS": function( className ) {
1758			var pattern = classCache[ className + " " ];
1759
1760			return pattern ||
1761				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
1762				classCache( className, function( elem ) {
1763					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
1764				});
1765		},
1766
1767		"ATTR": function( name, operator, check ) {
1768			return function( elem ) {
1769				var result = Sizzle.attr( elem, name );
1770
1771				if ( result == null ) {
1772					return operator === "!=";
1773				}
1774				if ( !operator ) {
1775					return true;
1776				}
1777
1778				result += "";
1779
1780				return operator === "=" ? result === check :
1781					operator === "!=" ? result !== check :

1810
1811					if ( parent ) {
1812
1813						// :(first|last|only)-(child|of-type)
1814						if ( simple ) {
1815							while ( dir ) {
1816								node = elem;
1817								while ( (node = node[ dir ]) ) {
1818									if ( ofType ?
1819										node.nodeName.toLowerCase() === name :
1820										node.nodeType === 1 ) {
1821
1822										return false;
1823									}
1824								}
1825								// Reverse direction for :only-* (if we haven't yet done so)
1826								start = dir = type === "only" && !start && "nextSibling";
1827							}
1828							return true;
1829						}
1830
1831						start = [ forward ? parent.firstChild : parent.lastChild ];
1832
1833						// non-xml :nth-child(...) stores cache data on `parent`
1834						if ( forward && useCache ) {
1835
1836							// Seek `elem` from a previously-cached index
1837
1838							// ...in a gzip-friendly way
1839							node = parent;
1840							outerCache = node[ expando ] || (node[ expando ] = {});
1841
1842							// Support: IE <9 only
1843							// Defend against cloned attroperties (jQuery gh-1709)
1844							uniqueCache = outerCache[ node.uniqueID ] ||
1845								(outerCache[ node.uniqueID ] = {});
1846
1847							cache = uniqueCache[ type ] || [];
1848							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1849							diff = nodeIndex && cache[ 2 ];
1850							node = nodeIndex && parent.childNodes[ nodeIndex ];
1851
1852							while ( (node = ++nodeIndex && node && node[ dir ] ||
1853
1854								// Fallback to seeking `elem` from the start
1855								(diff = nodeIndex = 0) || start.pop()) ) {
1856
1857								// When found, cache indexes on `parent` and break
1858								if ( node.nodeType === 1 && ++diff && node === elem ) {
1859									uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
1860									break;
1861								}
1862							}
1863
1864						} else {
1865							// Use previously-cached element index if available
1866							if ( useCache ) {
1867								// ...in a gzip-friendly way
1868								node = elem;
1869								outerCache = node[ expando ] || (node[ expando ] = {});
1870
1871								// Support: IE <9 only
1872								// Defend against cloned attroperties (jQuery gh-1709)
1873								uniqueCache = outerCache[ node.uniqueID ] ||
1874									(outerCache[ node.uniqueID ] = {});
1875
1876								cache = uniqueCache[ type ] || [];
1877								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1878								diff = nodeIndex;
1879							}
1880
1881							// xml :nth-child(...)
1882							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
1883							if ( diff === false ) {
1884								// Use the same loop as above to seek `elem` from the start
1885								while ( (node = ++nodeIndex && node && node[ dir ] ||
1886									(diff = nodeIndex = 0) || start.pop()) ) {
1887
1888									if ( ( ofType ?
1889										node.nodeName.toLowerCase() === name :
1890										node.nodeType === 1 ) &&
1891										++diff ) {
1892
1893										// Cache the index of each encountered element
1894										if ( useCache ) {
1895											outerCache = node[ expando ] || (node[ expando ] = {});
1896
1897											// Support: IE <9 only
1898											// Defend against cloned attroperties (jQuery gh-1709)
1899											uniqueCache = outerCache[ node.uniqueID ] ||
1900												(outerCache[ node.uniqueID ] = {});
1901
1902											uniqueCache[ type ] = [ dirruns, diff ];
1903										}
1904
1905										if ( node === elem ) {
1906											break;
1907										}
1908									}
1909								}
1910							}
1911						}
1912
1913						// Incorporate the offset, then check against cycle size
1914						diff -= last;
1915						return diff === first || ( diff % first === 0 && diff / first >= 0 );
1916					}
1917				};
1918		},
1919
1920		"PSEUDO": function( pseudo, argument ) {
1921			// pseudo-class names are case-insensitive
1922			// http://www.w3.org/TR/selectors/#pseudo-classes
1923			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1924			// Remember that setFilters inherits from pseudos
1925			var args,
1926				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
1927					Sizzle.error( "unsupported pseudo: " + pseudo );
1928
1929			// The user may use createPseudo to indicate that
1930			// arguments are needed to create the filter function
1931			// just as Sizzle does
1932			if ( fn[ expando ] ) {
1933				return fn( argument );
1934			}
1935
1936			// But maintain support for old signatures
1937			if ( fn.length > 1 ) {
1938				args = [ pseudo, pseudo, "", argument ];
1939				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
1940					markFunction(function( seed, matches ) {
1941						var idx,
1942							matched = fn( seed, argument ),
1943							i = matched.length;
1944						while ( i-- ) {
1945							idx = indexOf( seed, matched[i] );
1946							seed[ idx ] = !( matches[ idx ] = matched[i] );
1947						}
1948					}) :
1949					function( elem ) {
1950						return fn( elem, 0, args );
1951					};
1952			}
1953
1954			return fn;
1955		}
1956	},
1957
1958	pseudos: {
1959		// Potentially complex pseudos
1960		"not": markFunction(function( selector ) {
1961			// Trim the selector passed to compile
1962			// to avoid treating leading and trailing
1963			// spaces as combinators
1964			var input = [],
1965				results = [],
1966				matcher = compile( selector.replace( rtrim, "$1" ) );
1967
1968			return matcher[ expando ] ?
1969				markFunction(function( seed, matches, context, xml ) {
1970					var elem,
1971						unmatched = matcher( seed, null, xml, [] ),
1972						i = seed.length;
1973
1974					// Match elements unmatched by `matcher`
1975					while ( i-- ) {
1976						if ( (elem = unmatched[i]) ) {
1977							seed[i] = !(matches[i] = elem);
1978						}
1979					}
1980				}) :
1981				function( elem, context, xml ) {
1982					input[0] = elem;
1983					matcher( input, null, xml, results );
1984					// Don't keep the element (issue #299)
1985					input[0] = null;
1986					return !results.pop();
1987				};
1988		}),
1989
1990		"has": markFunction(function( selector ) {
1991			return function( elem ) {
1992				return Sizzle( selector, elem ).length > 0;
1993			};
1994		}),
1995
1996		"contains": markFunction(function( text ) {
1997			text = text.replace( runescape, funescape );
1998			return function( elem ) {
1999				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
2000			};
2001		}),
2002
2003		// "Whether an element is represented by a :lang() selector
2004		// is based solely on the element's language value
2005		// being equal to the identifier C,
2006		// or beginning with the identifier C immediately followed by "-".
2007		// The matching of C against the element's language value is performed case-insensitively.
2008		// The identifier C does not have to be a valid language name."
2009		// http://www.w3.org/TR/selectors/#lang-pseudo
2010		"lang": markFunction( function( lang ) {
2011			// lang value must be a valid identifier
2012			if ( !ridentifier.test(lang || "") ) {
2013				Sizzle.error( "unsupported lang: " + lang );
2014			}
2015			lang = lang.replace( runescape, funescape ).toLowerCase();
2016			return function( elem ) {
2017				var elemLang;
2018				do {
2019					if ( (elemLang = documentIsHTML ?
2020						elem.lang :
2021						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
2022
2023						elemLang = elemLang.toLowerCase();
2024						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2025					}
2026				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
2027				return false;

2195
2196		// Combinators
2197		if ( (match = rcombinators.exec( soFar )) ) {
2198			matched = match.shift();
2199			tokens.push({
2200				value: matched,
2201				// Cast descendant combinators to space
2202				type: match[0].replace( rtrim, " " )
2203			});
2204			soFar = soFar.slice( matched.length );
2205		}
2206
2207		// Filters
2208		for ( type in Expr.filter ) {
2209			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2210				(match = preFilters[ type ]( match ))) ) {
2211				matched = match.shift();
2212				tokens.push({
2213					value: matched,
2214					type: type,
2215					matches: match
2216				});
2217				soFar = soFar.slice( matched.length );
2218			}
2219		}
2220
2221		if ( !matched ) {
2222			break;
2223		}
2224	}
2225
2226	// Return the length of the invalid excess
2227	// if we're just parsing
2228	// Otherwise, throw an error or return tokens
2229	return parseOnly ?
2230		soFar.length :
2231		soFar ?
2232			Sizzle.error( selector ) :
2233			// Cache the tokens
2234			tokenCache( selector, groups ).slice( 0 );
2235};
2236
2237function toSelector( tokens ) {
2238	var i = 0,
2239		len = tokens.length,
2240		selector = "";
2241	for ( ; i < len; i++ ) {
2242		selector += tokens[i].value;
2243	}
2244	return selector;
2245}
2246
2247function addCombinator( matcher, combinator, base ) {
2248	var dir = combinator.dir,
2249		skip = combinator.next,
2250		key = skip || dir,
2251		checkNonElements = base && key === "parentNode",
2252		doneName = done++;
2253
2254	return combinator.first ?
2255		// Check against closest ancestor/preceding element
2256		function( elem, context, xml ) {
2257			while ( (elem = elem[ dir ]) ) {
2258				if ( elem.nodeType === 1 || checkNonElements ) {
2259					return matcher( elem, context, xml );
2260				}
2261			}
2262			return false;
2263		} :
2264
2265		// Check against all ancestor/preceding elements
2266		function( elem, context, xml ) {
2267			var oldCache, uniqueCache, outerCache,
2268				newCache = [ dirruns, doneName ];
2269
2270			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2271			if ( xml ) {
2272				while ( (elem = elem[ dir ]) ) {
2273					if ( elem.nodeType === 1 || checkNonElements ) {
2274						if ( matcher( elem, context, xml ) ) {
2275							return true;
2276						}
2277					}
2278				}
2279			} else {
2280				while ( (elem = elem[ dir ]) ) {
2281					if ( elem.nodeType === 1 || checkNonElements ) {
2282						outerCache = elem[ expando ] || (elem[ expando ] = {});
2283
2284						// Support: IE <9 only
2285						// Defend against cloned attroperties (jQuery gh-1709)
2286						uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});
2287
2288						if ( skip && skip === elem.nodeName.toLowerCase() ) {
2289							elem = elem[ dir ] || elem;
2290						} else if ( (oldCache = uniqueCache[ key ]) &&
2291							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2292
2293							// Assign to newCache so results back-propagate to previous elements
2294							return (newCache[ 2 ] = oldCache[ 2 ]);
2295						} else {
2296							// Reuse newcache so results back-propagate to previous elements
2297							uniqueCache[ key ] = newCache;
2298
2299							// A match means we're done; a fail means we have to keep checking
2300							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
2301								return true;
2302							}
2303						}
2304					}
2305				}
2306			}
2307			return false;
2308		};
2309}
2310
2311function elementMatcher( matchers ) {
2312	return matchers.length > 1 ?
2313		function( elem, context, xml ) {
2314			var i = matchers.length;
2315			while ( i-- ) {
2316				if ( !matchers[i]( elem, context, xml ) ) {
2317					return false;
2318				}
2319			}
2320			return true;
2321		} :
2322		matchers[0];
2323}
2324
2325function multipleContexts( selector, contexts, results ) {
2326	var i = 0,
2327		len = contexts.length;
2328	for ( ; i < len; i++ ) {
2329		Sizzle( selector, contexts[i], results );
2330	}
2331	return results;
2332}
2333
2334function condense( unmatched, map, filter, context, xml ) {
2335	var elem,
2336		newUnmatched = [],
2337		i = 0,
2338		len = unmatched.length,
2339		mapped = map != null;
2340
2341	for ( ; i < len; i++ ) {
2342		if ( (elem = unmatched[i]) ) {
2343			if ( !filter || filter( elem, context, xml ) ) {
2344				newUnmatched.push( elem );
2345				if ( mapped ) {
2346					map.push( i );
2347				}
2348			}
2349		}
2350	}
2351
2352	return newUnmatched;
2353}
2354
2355function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2356	if ( postFilter && !postFilter[ expando ] ) {
2357		postFilter = setMatcher( postFilter );
2358	}
2359	if ( postFinder && !postFinder[ expando ] ) {
2360		postFinder = setMatcher( postFinder, postSelector );
2361	}
2362	return markFunction(function( seed, results, context, xml ) {
2363		var temp, i, elem,
2364			preMap = [],
2365			postMap = [],
2366			preexisting = results.length,
2367
2368			// Get initial elements from seed or context
2369			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2370
2371			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2372			matcherIn = preFilter && ( seed || !selector ) ?
2373				condense( elems, preMap, preFilter, context, xml ) :
2374				elems,
2375
2376			matcherOut = matcher ?
2377				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2378				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2379
2380					// ...intermediate processing is necessary
2381					[] :
2382
2383					// ...otherwise use results directly
2384					results :
2385				matcherIn;
2386
2387		// Find primary matches
2388		if ( matcher ) {
2389			matcher( matcherIn, matcherOut, context, xml );
2390		}
2391
2392		// Apply postFilter
2393		if ( postFilter ) {
2394			temp = condense( matcherOut, postMap );
2395			postFilter( temp, [], context, xml );
2396
2397			// Un-match failing elements by moving them back to matcherIn
2398			i = temp.length;
2399			while ( i-- ) {
2400				if ( (elem = temp[i]) ) {
2401					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2402				}
2403			}
2404		}
2405
2406		if ( seed ) {
2407			if ( postFinder || preFilter ) {
2408				if ( postFinder ) {
2409					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2410					temp = [];
2411					i = matcherOut.length;
2412					while ( i-- ) {
2413						if ( (elem = matcherOut[i]) ) {
2414							// Restore matcherIn since elem is not yet a final match
2415							temp.push( (matcherIn[i] = elem) );
2416						}
2417					}
2418					postFinder( null, (matcherOut = []), temp, xml );
2419				}
2420
2421				// Move matched elements from seed to results to keep them synchronized
2422				i = matcherOut.length;
2423				while ( i-- ) {
2424					if ( (elem = matcherOut[i]) &&
2425						(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
2426
2427						seed[temp] = !(results[temp] = elem);
2428					}
2429				}
2430			}
2431
2432		// Add elements to results, through postFinder if defined
2433		} else {
2434			matcherOut = condense(
2435				matcherOut === results ?
2436					matcherOut.splice( preexisting, matcherOut.length ) :
2437					matcherOut
2438			);
2439			if ( postFinder ) {
2440				postFinder( null, results, matcherOut, xml );
2441			} else {
2442				push.apply( results, matcherOut );
2443			}
2444		}
2445	});
2446}
2447
2448function matcherFromTokens( tokens ) {
2449	var checkContext, matcher, j,
2450		len = tokens.length,
2451		leadingRelative = Expr.relative[ tokens[0].type ],
2452		implicitRelative = leadingRelative || Expr.relative[" "],
2453		i = leadingRelative ? 1 : 0,
2454
2455		// The foundational matcher ensures that elements are reachable from top-level context(s)
2456		matchContext = addCombinator( function( elem ) {
2457			return elem === checkContext;
2458		}, implicitRelative, true ),
2459		matchAnyContext = addCombinator( function( elem ) {
2460			return indexOf( checkContext, elem ) > -1;
2461		}, implicitRelative, true ),
2462		matchers = [ function( elem, context, xml ) {
2463			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2464				(checkContext = context).nodeType ?
2465					matchContext( elem, context, xml ) :
2466					matchAnyContext( elem, context, xml ) );
2467			// Avoid hanging onto element (issue #299)
2468			checkContext = null;
2469			return ret;
2470		} ];
2471
2472	for ( ; i < len; i++ ) {
2473		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2474			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2475		} else {
2476			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2477
2478			// Return special upon seeing a positional matcher
2479			if ( matcher[ expando ] ) {
2480				// Find the next relative operator (if any) for proper handling
2481				j = ++i;
2482				for ( ; j < len; j++ ) {
2483					if ( Expr.relative[ tokens[j].type ] ) {
2484						break;
2485					}
2486				}
2487				return setMatcher(
2488					i > 1 && elementMatcher( matchers ),
2489					i > 1 && toSelector(
2490						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2491						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2492					).replace( rtrim, "$1" ),
2493					matcher,
2494					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2495					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2496					j < len && toSelector( tokens )
2497				);
2498			}
2499			matchers.push( matcher );
2500		}
2501	}
2502
2503	return elementMatcher( matchers );
2504}
2505
2506function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2507	var bySet = setMatchers.length > 0,
2508		byElement = elementMatchers.length > 0,
2509		superMatcher = function( seed, context, xml, results, outermost ) {
2510			var elem, j, matcher,
2511				matchedCount = 0,
2512				i = "0",
2513				unmatched = seed && [],
2514				setMatched = [],
2515				contextBackup = outermostContext,
2516				// We must always have either seed elements or outermost context
2517				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
2518				// Use integer dirruns iff this is the outermost matcher
2519				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
2520				len = elems.length;
2521
2522			if ( outermost ) {
2523				outermostContext = context === document || context || outermost;
2524			}
2525
2526			// Add elements passing elementMatchers directly to results
2527			// Support: IE<9, Safari
2528			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2529			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
2530				if ( byElement && elem ) {
2531					j = 0;
2532					if ( !context && elem.ownerDocument !== document ) {
2533						setDocument( elem );
2534						xml = !documentIsHTML;
2535					}
2536					while ( (matcher = elementMatchers[j++]) ) {
2537						if ( matcher( elem, context || document, xml) ) {
2538							results.push( elem );
2539							break;
2540						}
2541					}
2542					if ( outermost ) {
2543						dirruns = dirrunsUnique;
2544					}
2545				}
2546
2547				// Track unmatched elements for set filters
2548				if ( bySet ) {
2549					// They will have gone through all possible matchers
2550					if ( (elem = !matcher && elem) ) {
2551						matchedCount--;
2552					}
2553
2554					// Lengthen the array for every element, matched or not
2555					if ( seed ) {
2556						unmatched.push( elem );
2557					}
2558				}
2559			}
2560
2561			// `i` is now the count of elements visited above, and adding it to `matchedCount`
2562			// makes the latter nonnegative.
2563			matchedCount += i;
2564
2565			// Apply set filters to unmatched elements
2566			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2567			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2568			// no element matchers and no seed.
2569			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2570			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
2571			// numerically zero.
2572			if ( bySet && i !== matchedCount ) {
2573				j = 0;
2574				while ( (matcher = setMatchers[j++]) ) {
2575					matcher( unmatched, setMatched, context, xml );
2576				}
2577
2578				if ( seed ) {
2579					// Reintegrate element matches to eliminate the need for sorting
2580					if ( matchedCount > 0 ) {
2581						while ( i-- ) {
2582							if ( !(unmatched[i] || setMatched[i]) ) {
2583								setMatched[i] = pop.call( results );
2584							}
2585						}
2586					}
2587
2588					// Discard index placeholder values to get only actual matches
2589					setMatched = condense( setMatched );
2590				}
2591
2592				// Add matches to results
2593				push.apply( results, setMatched );
2594
2595				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2596				if ( outermost && !seed && setMatched.length > 0 &&
2597					( matchedCount + setMatchers.length ) > 1 ) {
2598
2599					Sizzle.uniqueSort( results );
2600				}
2601			}
2602
2603			// Override manipulation of globals by nested matchers
2604			if ( outermost ) {
2605				dirruns = dirrunsUnique;
2606				outermostContext = contextBackup;
2607			}
2608
2609			return unmatched;
2610		};
2611
2612	return bySet ?
2613		markFunction( superMatcher ) :
2614		superMatcher;
2615}
2616
2617compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2618	var i,
2619		setMatchers = [],
2620		elementMatchers = [],
2621		cached = compilerCache[ selector + " " ];
2622
2623	if ( !cached ) {
2624		// Generate a function of recursive functions that can be used to check each element
2625		if ( !match ) {
2626			match = tokenize( selector );
2627		}
2628		i = match.length;
2629		while ( i-- ) {
2630			cached = matcherFromTokens( match[i] );
2631			if ( cached[ expando ] ) {
2632				setMatchers.push( cached );
2633			} else {
2634				elementMatchers.push( cached );
2635			}
2636		}
2637
2638		// Cache the compiled function
2639		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2640
2641		// Save selector and tokenization
2642		cached.selector = selector;
2643	}
2644	return cached;
2645};
2646
2647/**
2648 * A low-level selection function that works with Sizzle's compiled
2649 *  selector functions
2650 * @param {String|Function} selector A selector or a pre-compiled
2651 *  selector function built with Sizzle.compile
2652 * @param {Element} context
2653 * @param {Array} [results]
2654 * @param {Array} [seed] A set of elements to match against
2655 */
2656select = Sizzle.select = function( selector, context, results, seed ) {
2657	var i, tokens, token, type, find,
2658		compiled = typeof selector === "function" && selector,
2659		match = !seed && tokenize( (selector = compiled.selector || selector) );
2660
2661	results = results || [];
2662
2663	// Try to minimize operations if there is only one selector in the list and no seed
2664	// (the latter of which guarantees us context)
2665	if ( match.length === 1 ) {
2666
2667		// Reduce context if the leading compound selector is an ID
2668		tokens = match[0] = match[0].slice( 0 );
2669		if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2670				context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {
2671
2672			context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2673			if ( !context ) {
2674				return results;
2675
2676			// Precompiled matchers will still verify ancestry, so step up a level
2677			} else if ( compiled ) {
2678				context = context.parentNode;
2679			}
2680
2681			selector = selector.slice( tokens.shift().value.length );
2682		}
2683
2684		// Fetch a seed set for right-to-left matching
2685		i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2686		while ( i-- ) {
2687			token = tokens[i];
2688
2689			// Abort if we hit a combinator
2690			if ( Expr.relative[ (type = token.type) ] ) {
2691				break;
2692			}
2693			if ( (find = Expr.find[ type ]) ) {
2694				// Search, expanding context for leading sibling combinators
2695				if ( (seed = find(
2696					token.matches[0].replace( runescape, funescape ),