| blob | cc89dafcd6ae69cf81adfea016a0f1a8d8341c58 |
1 /* Prototype JavaScript framework, version 1.7.3
2 * (c) 2005-2010 Sam Stephenson
3 *
4 * Prototype is freely distributable under the terms of an MIT-style license.
5 * For details, see the Prototype web site: http://www.prototypejs.org/
6 *
7 *--------------------------------------------------------------------------*/
22 }
23 })(),
25 BrowserFeatures: {
33 })(),
44 }
49 })()
50 },
58 };
62 /* Based on Alex Arnell's inheritance implementation. */
69 }
71 })();
81 }
91 }
101 }
112 }
130 }
132 }
135 }
139 Methods: {
140 addMethods: addMethods
141 }
142 };
143 })();
173 }
175 })();
181 }
187 }
189 }
195 }
205 }
206 }
210 }
216 }
225 }
231 }
244 }
245 }
253 }
261 }
262 }
264 }
267 }
268 }
272 }
276 }
280 }
288 }
294 }
295 }
298 }
305 }
309 }
313 }
317 }
324 }
328 }
332 }
336 }
340 }
344 }
348 }
366 isUndefined: isUndefined
367 });
368 })();
376 }
381 }
388 }
405 };
411 }
418 }
419 }
427 }
428 }
436 }
441 }
448 }
449 }
457 };
458 }
467 methodize: methodize
468 };
474 })());
488 }
493 }
505 };
513 },
517 },
521 },
527 },
538 }
539 }
540 }
541 });
545 },
546 specialChar: {
553 }
554 });
565 }
569 }
582 }
592 }
593 }
595 }
604 });
605 }
610 }
617 }
621 }
625 }
629 }
636 });
637 }
641 }
645 }
649 }
664 }
669 }
671 }
673 });
674 }
678 }
683 }
687 }
692 });
693 }
697 }
705 }
709 }
715 }
717 });
720 }
724 }
733 }
737 cx = /[\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff\u0000]/g;
741 });
742 }
747 }
752 }
756 }
761 }
770 }
774 }
778 }
782 }
814 interpolate: interpolate
815 };
816 })());
822 },
846 }
849 });
850 }
851 });
862 }
864 }
872 }
882 }
892 }
901 }
909 }
912 }
921 }
935 }
946 }
947 });
949 }
956 });
957 }
964 }
970 });
971 }
982 }
993 }
1003 }
1009 });
1011 }
1020 }
1027 };
1032 }
1036 }
1046 });
1047 }
1051 }
1055 }
1095 find: detect
1096 };
1097 })();
1105 }
1112 }
1125 }
1126 }
1132 }
1136 }
1140 }
1145 });
1146 }
1154 });
1155 }
1161 });
1162 }
1166 }
1173 });
1174 }
1179 });
1180 }
1185 }
1189 }
1193 }
1206 }
1214 }
1229 }
1232 }
1240 }
1250 n++;
1251 }
1254 }
1255 }
1258 }
1271 }
1272 };
1273 }
1286 }
1287 n++;
1288 }
1291 }
1295 }
1309 }
1310 }
1311 }
1313 }
1317 }
1328 }
1329 }
1332 }
1336 }
1347 }
1348 }
1351 }
1355 }
1362 }
1392 inspect: inspect
1393 });
1403 })();
1406 };
1411 }
1421 i++;
1422 }
1423 }
1427 }
1432 }
1438 }
1442 }
1448 }
1452 }
1457 });
1459 }
1463 }
1469 });
1470 }
1481 }
1493 }
1495 }
1499 }
1505 }
1509 }
1527 clone: clone
1528 };
1529 })());
1535 }
1539 }
1544 }
1549 }
1553 }
1557 }
1561 }
1565 }
1575 floor: floor
1576 };
1577 })());
1581 }
1588 }
1595 }
1596 }
1604 }
1609 include: include
1610 };
1611 })());
1628 }
1631 }
1632 };
1641 },
1644 };
1647 responders: [],
1651 },
1656 },
1660 },
1668 }
1669 });
1670 }
1671 };
1678 });
1689 };
1696 }
1697 });
1705 },
1717 }
1721 }
1741 /* Force Firefox to handle ready state 4 for synchronous requests */
1745 }
1748 }
1749 },
1755 },
1762 };
1768 /* Force "Connection: close" for older Mozilla browsers to work
1769 * around a bug where XMLHttpRequest sends an incorrect
1770 * Content-length header. See Mozilla Bugzilla #246651.
1771 */
1775 }
1783 else
1785 }
1790 },
1795 },
1802 },
1815 }
1822 }
1829 }
1833 }
1834 },
1842 }));
1843 },
1849 },
1856 }
1857 },
1862 }
1863 });
1886 }
1892 }
1893 },
1905 },
1913 },
1917 },
1921 },
1930 }
1937 }
1938 },
1951 }
1952 }
1953 });
1960 };
1970 },
1983 }
1985 }
1987 }
1988 }
1989 });
2004 },
2009 },
2015 },
2023 }
2025 },
2029 }
2030 });
2045 }
2050 }
2052 GLOBAL.$ = $;
2071 });
2072 }
2080 }
2086 }
2089 }
2090 })();
2102 }
2111 }
2132 }
2135 }
2142 }
2151 }
2157 }
2163 }
2170 show: show
2171 });
2178 }
2186 }
2189 })();
2199 }
2202 }
2203 })();
2214 }
2215 })();
2229 }
2232 })();
2254 }
2265 } else if (LINK_ELEMENT_INNERHTML_BUGGY && Object.isString(content) && content.indexOf('<link') > -1) {
2276 }
2279 }
2283 }
2296 }
2300 }
2305 },
2308 },
2311 },
2314 },
2316 tags: {
2322 }
2323 };
2331 });
2340 }
2355 else
2361 }
2365 }
2378 }
2388 }
2402 }
2414 }
2425 }
2433 }
2444 }
2446 }
2450 }
2459 }
2468 }
2471 }
2483 }
2484 }
2486 }
2495 }
2496 }
2502 }
2511 }
2512 }
2516 }
2529 }
2540 purge: purge
2541 });
2555 }
2558 }
2563 }
2567 }
2575 }
2585 }
2588 }
2592 }
2596 }
2603 }
2612 }
2619 }
2628 }
2629 }
2637 }
2648 }
2652 }
2656 }
2662 }
2671 }
2674 }
2682 }
2689 }
2695 }
2704 }
2727 childElements: immediateDescendants
2728 });
2741 }
2746 }
2760 }
2763 }
2768 }
2776 })();
2782 }
2793 }
2801 }
2807 }
2810 }
2815 }
2820 })();
2826 }
2831 }
2833 }
2836 PROBLEMATIC_HAS_ATTRIBUTE_WITH_CHECKBOXES ?
2841 }
2850 }
2861 }
2870 }
2879 }
2889 }
2900 }
2908 }
2913 }
2917 }
2922 }
2926 }
2941 };
2942 }
2948 };
2949 }
2952 names: {
2957 },
2959 values: {
2962 },
2965 }
2966 }
2967 };
2970 names: {
2975 },
2977 values: {
2982 },
2986 }
2987 }
2988 };
3001 }
3029 onchange: _getEv
3030 });
3041 toggleClassName: toggleClassName
3042 });
3049 }
3055 }
3066 }
3068 }
3078 }
3080 }
3081 }
3084 }
3095 }
3099 }
3114 }
3115 }
3124 }
3130 }
3136 }
3139 }
3143 }
3149 }
3154 })();
3162 }
3177 }
3185 }
3190 }
3201 }
3208 getOpacity: getOpacity
3209 });
3215 }
3227 }
3233 }
3248 }
3257 }
3259 }
3268 }
3271 }
3277 retrieve: retrieve
3278 });
3288 }
3302 }
3305 }
3315 }
3316 }
3322 }
3337 }
3347 }
3350 }
3354 }
3360 }
3369 }
3370 }
3384 };
3397 }
3405 }
3415 }
3416 }
3424 }
3431 }
3432 }
3441 ELEMENT_CACHE = {};
3442 }
3446 addMethods: addMethods
3447 });
3457 EXTENDED = {};
3458 };
3459 }
3470 });
3471 }
3478 }
3490 }
3499 }
3503 }
3509 }
3511 }
3522 }
3526 }
3534 }
3538 }
3542 }
3555 }
3572 }
3578 }
3579 }
3582 }
3585 }
3591 }
3598 }
3600 }
3602 }
3609 }
3611 };
3612 }
3617 }
3634 }
3635 },
3639 },
3643 },
3648 },
3657 }
3665 };
3674 }
3682 };
3703 }
3708 },
3716 },
3722 }
3725 },
3729 },
3733 },
3746 },
3751 },
3767 },
3771 }
3772 });
3775 PROPERTIES: $w('height width top left right bottom border-left border-right border-top border-bottom padding-left padding-right padding-top padding-bottom margin-top margin-bottom margin-left margin-right padding-box-width padding-box-height border-box-width border-box-height margin-box-width margin-box-height'),
3777 COMPOSITE_PROPERTIES: $w('padding-box-width padding-box-height margin-box-width margin-box-height border-box-width border-box-height'),
3779 COMPUTATIONS: {
3787 }
3798 },
3807 }
3817 },
3825 },
3833 },
3840 },
3847 },
3857 },
3867 },
3872 },
3882 },
3887 },
3897 },
3901 },
3905 },
3909 },
3913 },
3917 },
3921 },
3925 },
3929 },
3933 },
3937 },
3941 },
3945 }
3946 }
3947 });
3957 },
3965 }
3966 });
3967 }
3976 },
3982 );
3983 },
3987 },
3991 },
3995 }
3996 });
4000 }
4004 }
4008 }
4012 }
4020 }
4027 };
4032 };
4042 };
4047 }
4054 }
4065 }
4066 }
4069 }
4081 }
4083 }
4099 }
4106 }
4113 valueT += !Object.isUndefined(window.pageYOffset) ? window.pageYOffset : bodyScrollNode.scrollTop || 0;
4114 valueL += !Object.isUndefined(window.pageXOffset) ? window.pageXOffset : bodyScrollNode.scrollLeft || 0;
4120 }
4123 }
4142 }
4145 }
4152 }
4167 });
4175 });
4178 }
4184 }
4191 }
4199 }
4210 }
4213 }
4215 }
4230 });
4231 }
4233 }
4246 }
4249 }
4259 }
4262 }
4286 }
4287 }
4300 }
4302 }
4309 }
4320 }
4323 }
4326 }
4344 }
4345 );
4361 });
4371 }
4377 };
4378 }
4399 clonePosition: clonePosition
4400 });
4404 }
4408 }
4412 }
4417 }
4429 }
4430 });
4431 }
4434 })();
4445 }
4449 }
4453 }
4457 }
4466 }
4472 getScrollOffsets: getScrollOffsets
4473 };
4475 })();
4479 };
4485 }
4489 }
4498 }
4499 }
4500 }
4505 }
4507 }
4518 };
4519 })();
4525 }
4532 }
4533 })();
4535 /*!
4536 * Sizzle CSS Selector Engine v1.10.18
4537 * http://sizzlejs.com/
4538 *
4539 * Copyright 2013 jQuery Foundation, Inc. and other contributors
4540 * Released under the MIT license
4541 * http://jquery.org/license
4542 *
4543 * Date: 2014-02-05
4544 */
4548 support,
4549 Expr,
4550 getText,
4551 isXML,
4552 compile,
4553 select,
4554 outermostContext,
4555 sortInput,
4556 hasDuplicate,
4558 setDocument,
4559 document,
4560 docElem,
4561 documentIsHTML,
4562 rbuggyQSA,
4563 rbuggyMatches,
4564 matches,
4565 contains,
4577 }
4579 },
4585 arr = [],
4596 }
4597 }
4599 },
4601 booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
4610 "*(?:([*^$|!~]?=)" + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]",
4612 pseudos = ":(" + characterEncoding + ")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" + attributes.replace( 3, 8 ) + ")*)|.*)\\)|)",
4614 rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
4617 rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
4619 rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
4624 matchExpr = {
4634 "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
4636 },
4648 runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
4649 funescape = function( _, escaped, escapedWhitespace ) {
4650 var high = "0x" + escaped - 0x10000;
4651 return high !== high || escapedWhitespace ?
4652 escaped :
4653 high < 0 ?
4654 String.fromCharCode( high + 0x10000 ) :
4655 String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
4656 };
4658 try {
4659 push.apply(
4660 (arr = slice.call( preferredDoc.childNodes )),
4661 preferredDoc.childNodes
4662 );
4663 arr[ preferredDoc.childNodes.length ].nodeType;
4664 } catch ( e ) {
4665 push = { apply: arr.length ?
4667 function( target, els ) {
4668 push_native.apply( target, slice.call(els) );
4669 } :
4671 function( target, els ) {
4672 var j = target.length,
4673 i = 0;
4674 while ( (target[j++] = els[i++]) ) {}
4675 target.length = j - 1;
4676 }
4677 };
4678 }
4680 function Sizzle( selector, context, results, seed ) {
4681 var match, elem, m, nodeType,
4682 i, groups, old, nid, newContext, newSelector;
4684 if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
4685 setDocument( context );
4686 }
4688 context = context || document;
4689 results = results || [];
4691 if ( !selector || typeof selector !== "string" ) {
4692 return results;
4693 }
4695 if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) {
4696 return [];
4697 }
4699 if ( documentIsHTML && !seed ) {
4701 if ( (match = rquickExpr.exec( selector )) ) {
4702 if ( (m = match[1]) ) {
4703 if ( nodeType === 9 ) {
4704 elem = context.getElementById( m );
4705 if ( elem && elem.parentNode ) {
4706 if ( elem.id === m ) {
4707 results.push( elem );
4708 return results;
4709 }
4710 } else {
4711 return results;
4712 }
4713 } else {
4714 if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
4715 contains( context, elem ) && elem.id === m ) {
4716 results.push( elem );
4717 return results;
4718 }
4719 }
4721 } else if ( match[2] ) {
4722 push.apply( results, context.getElementsByTagName( selector ) );
4723 return results;
4725 } else if ( (m = match[3]) && support.getElementsByClassName && context.getElementsByClassName ) {
4726 push.apply( results, context.getElementsByClassName( m ) );
4727 return results;
4728 }
4729 }
4731 if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
4732 nid = old = expando;
4733 newContext = context;
4734 newSelector = nodeType === 9 && selector;
4736 if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
4737 groups = tokenize( selector );
4739 if ( (old = context.getAttribute("id")) ) {
4741 } else {
4742 context.setAttribute( "id", nid );
4743 }
4746 i = groups.length;
4747 while ( i-- ) {
4748 groups[i] = nid + toSelector( groups[i] );
4749 }
4750 newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context;
4751 newSelector = groups.join(",");
4752 }
4754 if ( newSelector ) {
4755 try {
4756 push.apply( results,
4757 newContext.querySelectorAll( newSelector )
4758 );
4759 return results;
4760 } catch(qsaError) {
4761 } finally {
4762 if ( !old ) {
4763 context.removeAttribute("id");
4764 }
4765 }
4766 }
4767 }
4768 }
4770 return select( selector.replace( rtrim, "$1" ), context, results, seed );
4771 }
4773 /**
4774 * Create key-value caches of limited size
4775 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
4776 * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
4777 * deleting the oldest entry
4778 */
4779 function createCache() {
4780 var keys = [];
4782 function cache( key, value ) {
4783 if ( keys.push( key + " " ) > Expr.cacheLength ) {
4784 delete cache[ keys.shift() ];
4785 }
4786 return (cache[ key + " " ] = value);
4787 }
4788 return cache;
4789 }
4791 /**
4792 * Mark a function for special use by Sizzle
4793 * @param {Function} fn The function to mark
4794 */
4795 function markFunction( fn ) {
4796 fn[ expando ] = true;
4797 return fn;
4798 }
4800 /**
4801 * Support testing using an element
4802 * @param {Function} fn Passed the created div and expects a boolean result
4803 */
4804 function assert( fn ) {
4805 var div = document.createElement("div");
4807 try {
4808 return !!fn( div );
4809 } catch (e) {
4810 return false;
4811 } finally {
4812 if ( div.parentNode ) {
4813 div.parentNode.removeChild( div );
4814 }
4815 div = null;
4816 }
4817 }
4819 /**
4820 * Adds the same handler for all of the specified attrs
4821 * @param {String} attrs Pipe-separated list of attributes
4822 * @param {Function} handler The method that will be applied
4823 */
4824 function addHandle( attrs, handler ) {
4825 var arr = attrs.split("|"),
4826 i = attrs.length;
4828 while ( i-- ) {
4829 Expr.attrHandle[ arr[i] ] = handler;
4830 }
4831 }
4833 /**
4834 * Checks document order of two siblings
4835 * @param {Element} a
4836 * @param {Element} b
4837 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
4838 */
4839 function siblingCheck( a, b ) {
4840 var cur = b && a,
4841 diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
4842 ( ~b.sourceIndex || MAX_NEGATIVE ) -
4843 ( ~a.sourceIndex || MAX_NEGATIVE );
4845 if ( diff ) {
4846 return diff;
4847 }
4849 if ( cur ) {
4850 while ( (cur = cur.nextSibling) ) {
4851 if ( cur === b ) {
4852 return -1;
4853 }
4854 }
4855 }
4857 return a ? 1 : -1;
4858 }
4860 /**
4861 * Returns a function to use in pseudos for input types
4862 * @param {String} type
4863 */
4864 function createInputPseudo( type ) {
4865 return function( elem ) {
4866 var name = elem.nodeName.toLowerCase();
4867 return name === "input" && elem.type === type;
4868 };
4869 }
4871 /**
4872 * Returns a function to use in pseudos for buttons
4873 * @param {String} type
4874 */
4875 function createButtonPseudo( type ) {
4876 return function( elem ) {
4877 var name = elem.nodeName.toLowerCase();
4878 return (name === "input" || name === "button") && elem.type === type;
4879 };
4880 }
4882 /**
4883 * Returns a function to use in pseudos for positionals
4884 * @param {Function} fn
4885 */
4886 function createPositionalPseudo( fn ) {
4887 return markFunction(function( argument ) {
4888 argument = +argument;
4889 return markFunction(function( seed, matches ) {
4890 var j,
4891 matchIndexes = fn( [], seed.length, argument ),
4892 i = matchIndexes.length;
4894 while ( i-- ) {
4895 if ( seed[ (j = matchIndexes[i]) ] ) {
4896 seed[j] = !(matches[j] = seed[j]);
4897 }
4898 }
4899 });
4900 });
4901 }
4903 /**
4904 * Checks a node for validity as a Sizzle context
4905 * @param {Element|Object=} context
4906 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
4907 */
4908 function testContext( context ) {
4909 return context && typeof context.getElementsByTagName !== strundefined && context;
4910 }
4912 support = Sizzle.support = {};
4914 /**
4915 * Detects XML nodes
4916 * @param {Element|Object} elem An element or a document
4917 * @returns {Boolean} True iff elem is a non-HTML XML node
4918 */
4919 isXML = Sizzle.isXML = function( elem ) {
4920 var documentElement = elem && (elem.ownerDocument || elem).documentElement;
4921 return documentElement ? documentElement.nodeName !== "HTML" : false;
4922 };
4924 /**
4925 * Sets document-related variables once based on the current document
4926 * @param {Element|Object} [doc] An element or document object to use to set the document
4927 * @returns {Object} Returns the current document
4928 */
4929 setDocument = Sizzle.setDocument = function( node ) {
4930 var hasCompare,
4931 doc = node ? node.ownerDocument || node : preferredDoc,
4932 parent = doc.defaultView;
4934 if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
4935 return document;
4936 }
4938 document = doc;
4939 docElem = doc.documentElement;
4941 documentIsHTML = !isXML( doc );
4943 if ( parent && parent !== parent.top ) {
4944 if ( parent.addEventListener ) {
4945 parent.addEventListener( "unload", function() {
4946 setDocument();
4947 }, false );
4948 } else if ( parent.attachEvent ) {
4949 parent.attachEvent( "onunload", function() {
4950 setDocument();
4951 });
4952 }
4953 }
4955 /* Attributes
4956 ---------------------------------------------------------------------- */
4958 support.attributes = assert(function( div ) {
4959 div.className = "i";
4960 return !div.getAttribute("className");
4961 });
4963 /* getElement(s)By*
4964 ---------------------------------------------------------------------- */
4966 support.getElementsByTagName = assert(function( div ) {
4967 div.appendChild( doc.createComment("") );
4968 return !div.getElementsByTagName("*").length;
4969 });
4971 support.getElementsByClassName = rnative.test( doc.getElementsByClassName ) && assert(function( div ) {
4974 div.firstChild.className = "i";
4975 return div.getElementsByClassName("i").length === 2;
4976 });
4978 support.getById = assert(function( div ) {
4979 docElem.appendChild( div ).id = expando;
4980 return !doc.getElementsByName || !doc.getElementsByName( expando ).length;
4981 });
4983 if ( support.getById ) {
4984 Expr.find["ID"] = function( id, context ) {
4985 if ( typeof context.getElementById !== strundefined && documentIsHTML ) {
4986 var m = context.getElementById( id );
4987 return m && m.parentNode ? [m] : [];
4988 }
4989 };
4990 Expr.filter["ID"] = function( id ) {
4991 var attrId = id.replace( runescape, funescape );
4992 return function( elem ) {
4993 return elem.getAttribute("id") === attrId;
4994 };
4995 };
4996 } else {
4997 delete Expr.find["ID"];
4999 Expr.filter["ID"] = function( id ) {
5000 var attrId = id.replace( runescape, funescape );
5001 return function( elem ) {
5002 var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
5003 return node && node.value === attrId;
5004 };
5005 };
5006 }
5008 Expr.find["TAG"] = support.getElementsByTagName ?
5009 function( tag, context ) {
5010 if ( typeof context.getElementsByTagName !== strundefined ) {
5011 return context.getElementsByTagName( tag );
5012 }
5013 } :
5014 function( tag, context ) {
5015 var elem,
5016 tmp = [],
5017 i = 0,
5018 results = context.getElementsByTagName( tag );
5020 if ( tag === "*" ) {
5021 while ( (elem = results[i++]) ) {
5022 if ( elem.nodeType === 1 ) {
5023 tmp.push( elem );
5024 }
5025 }
5027 return tmp;
5028 }
5029 return results;
5030 };
5032 Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
5033 if ( typeof context.getElementsByClassName !== strundefined && documentIsHTML ) {
5034 return context.getElementsByClassName( className );
5035 }
5036 };
5038 /* QSA/matchesSelector
5039 ---------------------------------------------------------------------- */
5042 rbuggyMatches = [];
5044 rbuggyQSA = [];
5046 if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {
5047 assert(function( div ) {
5052 }
5054 if ( !div.querySelectorAll("[selected]").length ) {
5056 }
5058 if ( !div.querySelectorAll(":checked").length ) {
5059 rbuggyQSA.push(":checked");
5060 }
5061 });
5063 assert(function( div ) {
5064 var input = doc.createElement("input");
5065 input.setAttribute( "type", "hidden" );
5066 div.appendChild( input ).setAttribute( "name", "D" );
5068 if ( div.querySelectorAll("[name=d]").length ) {
5069 rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
5070 }
5072 if ( !div.querySelectorAll(":enabled").length ) {
5073 rbuggyQSA.push( ":enabled", ":disabled" );
5074 }
5076 div.querySelectorAll("*,:x");
5077 rbuggyQSA.push(",.*:");
5078 });
5079 }
5081 if ( (support.matchesSelector = rnative.test( (matches = docElem.webkitMatchesSelector ||
5082 docElem.mozMatchesSelector ||
5083 docElem.oMatchesSelector ||
5084 docElem.msMatchesSelector) )) ) {
5086 assert(function( div ) {
5087 support.disconnectedMatch = matches.call( div, "div" );
5090 rbuggyMatches.push( "!=", pseudos );
5091 });
5092 }
5094 rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
5095 rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
5097 /* Contains
5098 ---------------------------------------------------------------------- */
5099 hasCompare = rnative.test( docElem.compareDocumentPosition );
5101 contains = hasCompare || rnative.test( docElem.contains ) ?
5102 function( a, b ) {
5103 var adown = a.nodeType === 9 ? a.documentElement : a,
5104 bup = b && b.parentNode;
5105 return a === bup || !!( bup && bup.nodeType === 1 && (
5106 adown.contains ?
5107 adown.contains( bup ) :
5108 a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
5109 ));
5110 } :
5111 function( a, b ) {
5112 if ( b ) {
5113 while ( (b = b.parentNode) ) {
5114 if ( b === a ) {
5115 return true;
5116 }
5117 }
5118 }
5119 return false;
5120 };
5122 /* Sorting
5123 ---------------------------------------------------------------------- */
5125 sortOrder = hasCompare ?
5126 function( a, b ) {
5128 if ( a === b ) {
5129 hasDuplicate = true;
5130 return 0;
5131 }
5133 var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
5134 if ( compare ) {
5135 return compare;
5136 }
5138 compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
5139 a.compareDocumentPosition( b ) :
5141 1;
5143 if ( compare & 1 ||
5144 (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
5146 if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
5147 return -1;
5148 }
5149 if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
5150 return 1;
5151 }
5153 return sortInput ?
5154 ( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
5155 0;
5156 }
5158 return compare & 4 ? -1 : 1;
5159 } :
5160 function( a, b ) {
5161 if ( a === b ) {
5162 hasDuplicate = true;
5163 return 0;
5164 }
5166 var cur,
5167 i = 0,
5168 aup = a.parentNode,
5169 bup = b.parentNode,
5170 ap = [ a ],
5171 bp = [ b ];
5173 if ( !aup || !bup ) {
5174 return a === doc ? -1 :
5175 b === doc ? 1 :
5176 aup ? -1 :
5177 bup ? 1 :
5178 sortInput ?
5179 ( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
5180 0;
5182 } else if ( aup === bup ) {
5183 return siblingCheck( a, b );
5184 }
5186 cur = a;
5187 while ( (cur = cur.parentNode) ) {
5188 ap.unshift( cur );
5189 }
5190 cur = b;
5191 while ( (cur = cur.parentNode) ) {
5192 bp.unshift( cur );
5193 }
5195 while ( ap[i] === bp[i] ) {
5196 i++;
5197 }
5199 return i ?
5200 siblingCheck( ap[i], bp[i] ) :
5202 ap[i] === preferredDoc ? -1 :
5203 bp[i] === preferredDoc ? 1 :
5204 0;
5205 };
5207 return doc;
5208 };
5210 Sizzle.matches = function( expr, elements ) {
5211 return Sizzle( expr, null, null, elements );
5212 };
5214 Sizzle.matchesSelector = function( elem, expr ) {
5215 if ( ( elem.ownerDocument || elem ) !== document ) {
5216 setDocument( elem );
5217 }
5221 if ( support.matchesSelector && documentIsHTML &&
5222 ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
5223 ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {
5225 try {
5226 var ret = matches.call( elem, expr );
5228 if ( ret || support.disconnectedMatch ||
5229 elem.document && elem.document.nodeType !== 11 ) {
5230 return ret;
5231 }
5232 } catch(e) {}
5233 }
5235 return Sizzle( expr, document, null, [elem] ).length > 0;
5236 };
5238 Sizzle.contains = function( context, elem ) {
5239 if ( ( context.ownerDocument || context ) !== document ) {
5240 setDocument( context );
5241 }
5242 return contains( context, elem );
5243 };
5245 Sizzle.attr = function( elem, name ) {
5246 if ( ( elem.ownerDocument || elem ) !== document ) {
5247 setDocument( elem );
5248 }
5250 var fn = Expr.attrHandle[ name.toLowerCase() ],
5251 val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
5252 fn( elem, name, !documentIsHTML ) :
5253 undefined;
5255 return val !== undefined ?
5256 val :
5257 support.attributes || !documentIsHTML ?
5258 elem.getAttribute( name ) :
5259 (val = elem.getAttributeNode(name)) && val.specified ?
5260 val.value :
5261 null;
5262 };
5264 Sizzle.error = function( msg ) {
5265 throw new Error( "Syntax error, unrecognized expression: " + msg );
5266 };
5268 /**
5269 * Document sorting and removing duplicates
5270 * @param {ArrayLike} results
5271 */
5272 Sizzle.uniqueSort = function( results ) {
5273 var elem,
5274 duplicates = [],
5275 j = 0,
5276 i = 0;
5278 hasDuplicate = !support.detectDuplicates;
5279 sortInput = !support.sortStable && results.slice( 0 );
5280 results.sort( sortOrder );
5282 if ( hasDuplicate ) {
5283 while ( (elem = results[i++]) ) {
5284 if ( elem === results[ i ] ) {
5285 j = duplicates.push( i );
5286 }
5287 }
5288 while ( j-- ) {
5289 results.splice( duplicates[ j ], 1 );
5290 }
5291 }
5293 sortInput = null;
5295 return results;
5296 };
5298 /**
5299 * Utility function for retrieving the text value of an array of DOM nodes
5300 * @param {Array|Element} elem
5301 */
5302 getText = Sizzle.getText = function( elem ) {
5303 var node,
5304 ret = "",
5305 i = 0,
5306 nodeType = elem.nodeType;
5308 if ( !nodeType ) {
5309 while ( (node = elem[i++]) ) {
5310 ret += getText( node );
5311 }
5312 } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
5313 if ( typeof elem.textContent === "string" ) {
5314 return elem.textContent;
5315 } else {
5316 for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
5317 ret += getText( elem );
5318 }
5319 }
5320 } else if ( nodeType === 3 || nodeType === 4 ) {
5321 return elem.nodeValue;
5322 }
5324 return ret;
5325 };
5327 Expr = Sizzle.selectors = {
5329 cacheLength: 50,
5331 createPseudo: markFunction,
5333 match: matchExpr,
5335 attrHandle: {},
5337 find: {},
5339 relative: {
5340 ">": { dir: "parentNode", first: true },
5341 " ": { dir: "parentNode" },
5342 "+": { dir: "previousSibling", first: true },
5343 "~": { dir: "previousSibling" }
5344 },
5346 preFilter: {
5347 "ATTR": function( match ) {
5348 match[1] = match[1].replace( runescape, funescape );
5350 match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape );
5352 if ( match[2] === "~=" ) {
5353 match[3] = " " + match[3] + " ";
5354 }
5356 return match.slice( 0, 4 );
5357 },
5359 "CHILD": function( match ) {
5360 /* matches from matchExpr["CHILD"]
5361 1 type (only|nth|...)
5362 2 what (child|of-type)
5363 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
5364 4 xn-component of xn+y argument ([+-]?\d*n|)
5365 5 sign of xn-component
5366 6 x of xn-component
5367 7 sign of y-component
5368 8 y of y-component
5369 */
5370 match[1] = match[1].toLowerCase();
5372 if ( match[1].slice( 0, 3 ) === "nth" ) {
5373 if ( !match[3] ) {
5374 Sizzle.error( match[0] );
5375 }
5377 match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
5378 match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
5380 } else if ( match[3] ) {
5381 Sizzle.error( match[0] );
5382 }
5384 return match;
5385 },
5387 "PSEUDO": function( match ) {
5388 var excess,
5389 unquoted = !match[5] && match[2];
5391 if ( matchExpr["CHILD"].test( match[0] ) ) {
5392 return null;
5393 }
5395 if ( match[3] && match[4] !== undefined ) {
5396 match[2] = match[4];
5398 } else if ( unquoted && rpseudo.test( unquoted ) &&
5399 (excess = tokenize( unquoted, true )) &&
5400 (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
5402 match[0] = match[0].slice( 0, excess );
5403 match[2] = unquoted.slice( 0, excess );
5404 }
5406 return match.slice( 0, 3 );
5407 }
5408 },
5410 filter: {
5412 "TAG": function( nodeNameSelector ) {
5413 var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
5414 return nodeNameSelector === "*" ?
5415 function() { return true; } :
5416 function( elem ) {
5417 return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
5418 };
5419 },
5421 "CLASS": function( className ) {
5422 var pattern = classCache[ className + " " ];
5424 return pattern ||
5425 (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
5426 classCache( className, function( elem ) {
5427 return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute("class") || "" );
5428 });
5429 },
5431 "ATTR": function( name, operator, check ) {
5432 return function( elem ) {
5433 var result = Sizzle.attr( elem, name );
5435 if ( result == null ) {
5436 return operator === "!=";
5437 }
5438 if ( !operator ) {
5439 return true;
5440 }
5442 result += "";
5444 return operator === "=" ? result === check :
5445 operator === "!=" ? result !== check :
5446 operator === "^=" ? check && result.indexOf( check ) === 0 :
5447 operator === "*=" ? check && result.indexOf( check ) > -1 :
5448 operator === "$=" ? check && result.slice( -check.length ) === check :
5449 operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
5450 operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
5451 false;
5452 };
5453 },
5455 "CHILD": function( type, what, argument, first, last ) {
5456 var simple = type.slice( 0, 3 ) !== "nth",
5457 forward = type.slice( -4 ) !== "last",
5458 ofType = what === "of-type";
5460 return first === 1 && last === 0 ?
5462 function( elem ) {
5463 return !!elem.parentNode;
5464 } :
5466 function( elem, context, xml ) {
5467 var cache, outerCache, node, diff, nodeIndex, start,
5468 dir = simple !== forward ? "nextSibling" : "previousSibling",
5469 parent = elem.parentNode,
5470 name = ofType && elem.nodeName.toLowerCase(),
5471 useCache = !xml && !ofType;
5473 if ( parent ) {
5475 if ( simple ) {
5476 while ( dir ) {
5477 node = elem;
5478 while ( (node = node[ dir ]) ) {
5479 if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
5480 return false;
5481 }
5482 }
5483 start = dir = type === "only" && !start && "nextSibling";
5484 }
5485 return true;
5486 }
5488 start = [ forward ? parent.firstChild : parent.lastChild ];
5490 if ( forward && useCache ) {
5491 outerCache = parent[ expando ] || (parent[ expando ] = {});
5492 cache = outerCache[ type ] || [];
5493 nodeIndex = cache[0] === dirruns && cache[1];
5494 diff = cache[0] === dirruns && cache[2];
5495 node = nodeIndex && parent.childNodes[ nodeIndex ];
5497 while ( (node = ++nodeIndex && node && node[ dir ] ||
5499 (diff = nodeIndex = 0) || start.pop()) ) {
5501 if ( node.nodeType === 1 && ++diff && node === elem ) {
5502 outerCache[ type ] = [ dirruns, nodeIndex, diff ];
5503 break;
5504 }
5505 }
5507 } else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
5508 diff = cache[1];
5510 } else {
5511 while ( (node = ++nodeIndex && node && node[ dir ] ||
5512 (diff = nodeIndex = 0) || start.pop()) ) {
5514 if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
5515 if ( useCache ) {
5516 (node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
5517 }
5519 if ( node === elem ) {
5520 break;
5521 }
5522 }
5523 }
5524 }
5526 diff -= last;
5527 return diff === first || ( diff % first === 0 && diff / first >= 0 );
5528 }
5529 };
5530 },
5532 "PSEUDO": function( pseudo, argument ) {
5533 var args,
5534 fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
5535 Sizzle.error( "unsupported pseudo: " + pseudo );
5537 if ( fn[ expando ] ) {
5538 return fn( argument );
5539 }
5541 if ( fn.length > 1 ) {
5542 args = [ pseudo, pseudo, "", argument ];
5543 return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
5544 markFunction(function( seed, matches ) {
5545 var idx,
5546 matched = fn( seed, argument ),
5547 i = matched.length;
5548 while ( i-- ) {
5549 idx = indexOf.call( seed, matched[i] );
5550 seed[ idx ] = !( matches[ idx ] = matched[i] );
5551 }
5552 }) :
5553 function( elem ) {
5554 return fn( elem, 0, args );
5555 };
5556 }
5558 return fn;
5559 }
5560 },
5562 pseudos: {
5563 "not": markFunction(function( selector ) {
5564 var input = [],
5565 results = [],
5566 matcher = compile( selector.replace( rtrim, "$1" ) );
5568 return matcher[ expando ] ?
5569 markFunction(function( seed, matches, context, xml ) {
5570 var elem,
5571 unmatched = matcher( seed, null, xml, [] ),
5572 i = seed.length;
5574 while ( i-- ) {
5575 if ( (elem = unmatched[i]) ) {
5576 seed[i] = !(matches[i] = elem);
5577 }
5578 }
5579 }) :
5580 function( elem, context, xml ) {
5581 input[0] = elem;
5582 matcher( input, null, xml, results );
5583 return !results.pop();
5584 };
5585 }),
5587 "has": markFunction(function( selector ) {
5588 return function( elem ) {
5589 return Sizzle( selector, elem ).length > 0;
5590 };
5591 }),
5593 "contains": markFunction(function( text ) {
5594 return function( elem ) {
5595 return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
5596 };
5597 }),
5599 "lang": markFunction( function( lang ) {
5600 if ( !ridentifier.test(lang || "") ) {
5601 Sizzle.error( "unsupported lang: " + lang );
5602 }
5603 lang = lang.replace( runescape, funescape ).toLowerCase();
5604 return function( elem ) {
5605 var elemLang;
5606 do {
5607 if ( (elemLang = documentIsHTML ?
5608 elem.lang :
5609 elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
5611 elemLang = elemLang.toLowerCase();
5612 return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
5613 }
5614 } while ( (elem = elem.parentNode) && elem.nodeType === 1 );
5615 return false;
5616 };
5617 }),
5619 "target": function( elem ) {
5620 var hash = window.location && window.location.hash;
5621 return hash && hash.slice( 1 ) === elem.id;
5622 },
5624 "root": function( elem ) {
5625 return elem === docElem;
5626 },
5628 "focus": function( elem ) {
5629 return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
5630 },
5632 "enabled": function( elem ) {
5633 return elem.disabled === false;
5634 },
5636 "disabled": function( elem ) {
5637 return elem.disabled === true;
5638 },
5640 "checked": function( elem ) {
5641 var nodeName = elem.nodeName.toLowerCase();
5642 return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
5643 },
5645 "selected": function( elem ) {
5646 if ( elem.parentNode ) {
5647 elem.parentNode.selectedIndex;
5648 }
5650 return elem.selected === true;
5651 },
5653 "empty": function( elem ) {
5654 for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
5655 if ( elem.nodeType < 6 ) {
5656 return false;
5657 }
5658 }
5659 return true;
5660 },
5662 "parent": function( elem ) {
5663 return !Expr.pseudos["empty"]( elem );
5664 },
5666 "header": function( elem ) {
5667 return rheader.test( elem.nodeName );
5668 },
5670 "input": function( elem ) {
5671 return rinputs.test( elem.nodeName );
5672 },
5674 "button": function( elem ) {
5675 var name = elem.nodeName.toLowerCase();
5676 return name === "input" && elem.type === "button" || name === "button";
5677 },
5679 "text": function( elem ) {
5680 var attr;
5681 return elem.nodeName.toLowerCase() === "input" &&
5682 elem.type === "text" &&
5684 ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
5685 },
5687 "first": createPositionalPseudo(function() {
5688 return [ 0 ];
5689 }),
5691 "last": createPositionalPseudo(function( matchIndexes, length ) {
5692 return [ length - 1 ];
5693 }),
5695 "eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
5696 return [ argument < 0 ? argument + length : argument ];
5697 }),
5699 "even": createPositionalPseudo(function( matchIndexes, length ) {
5700 var i = 0;
5701 for ( ; i < length; i += 2 ) {
5702 matchIndexes.push( i );
5703 }
5704 return matchIndexes;
5705 }),
5707 "odd": createPositionalPseudo(function( matchIndexes, length ) {
5708 var i = 1;
5709 for ( ; i < length; i += 2 ) {
5710 matchIndexes.push( i );
5711 }
5712 return matchIndexes;
5713 }),
5715 "lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
5716 var i = argument < 0 ? argument + length : argument;
5717 for ( ; --i >= 0; ) {
5718 matchIndexes.push( i );
5719 }
5720 return matchIndexes;
5721 }),
5723 "gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
5724 var i = argument < 0 ? argument + length : argument;
5725 for ( ; ++i < length; ) {
5726 matchIndexes.push( i );
5727 }
5728 return matchIndexes;
5729 })
5730 }
5731 };
5733 Expr.pseudos["nth"] = Expr.pseudos["eq"];
5735 for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
5736 Expr.pseudos[ i ] = createInputPseudo( i );
5737 }
5738 for ( i in { submit: true, reset: true } ) {
5739 Expr.pseudos[ i ] = createButtonPseudo( i );
5740 }
5742 function setFilters() {}
5743 setFilters.prototype = Expr.filters = Expr.pseudos;
5744 Expr.setFilters = new setFilters();
5746 function tokenize( selector, parseOnly ) {
5747 var matched, match, tokens, type,
5748 soFar, groups, preFilters,
5749 cached = tokenCache[ selector + " " ];
5751 if ( cached ) {
5752 return parseOnly ? 0 : cached.slice( 0 );
5753 }
5755 soFar = selector;
5756 groups = [];
5757 preFilters = Expr.preFilter;
5759 while ( soFar ) {
5761 if ( !matched || (match = rcomma.exec( soFar )) ) {
5762 if ( match ) {
5763 soFar = soFar.slice( match[0].length ) || soFar;
5764 }
5765 groups.push( (tokens = []) );
5766 }
5768 matched = false;
5770 if ( (match = rcombinators.exec( soFar )) ) {
5771 matched = match.shift();
5772 tokens.push({
5773 value: matched,
5774 type: match[0].replace( rtrim, " " )
5775 });
5776 soFar = soFar.slice( matched.length );
5777 }
5779 for ( type in Expr.filter ) {
5780 if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
5781 (match = preFilters[ type ]( match ))) ) {
5782 matched = match.shift();
5783 tokens.push({
5784 value: matched,
5785 type: type,
5786 matches: match
5787 });
5788 soFar = soFar.slice( matched.length );
5789 }
5790 }
5792 if ( !matched ) {
5793 break;
5794 }
5795 }
5797 return parseOnly ?
5798 soFar.length :
5799 soFar ?
5800 Sizzle.error( selector ) :
5801 tokenCache( selector, groups ).slice( 0 );
5802 }
5804 function toSelector( tokens ) {
5805 var i = 0,
5806 len = tokens.length,
5807 selector = "";
5808 for ( ; i < len; i++ ) {
5809 selector += tokens[i].value;
5810 }
5811 return selector;
5812 }
5814 function addCombinator( matcher, combinator, base ) {
5815 var dir = combinator.dir,
5816 checkNonElements = base && dir === "parentNode",
5817 doneName = done++;
5819 return combinator.first ?
5820 function( elem, context, xml ) {
5821 while ( (elem = elem[ dir ]) ) {
5822 if ( elem.nodeType === 1 || checkNonElements ) {
5823 return matcher( elem, context, xml );
5824 }
5825 }
5826 } :
5828 function( elem, context, xml ) {
5829 var oldCache, outerCache,
5830 newCache = [ dirruns, doneName ];
5832 if ( xml ) {
5833 while ( (elem = elem[ dir ]) ) {
5834 if ( elem.nodeType === 1 || checkNonElements ) {
5835 if ( matcher( elem, context, xml ) ) {
5836 return true;
5837 }
5838 }
5839 }
5840 } else {
5841 while ( (elem = elem[ dir ]) ) {
5842 if ( elem.nodeType === 1 || checkNonElements ) {
5843 outerCache = elem[ expando ] || (elem[ expando ] = {});
5844 if ( (oldCache = outerCache[ dir ]) &&
5845 oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
5847 return (newCache[ 2 ] = oldCache[ 2 ]);
5848 } else {
5849 outerCache[ dir ] = newCache;
5851 if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
5852 return true;
5853 }
5854 }
5855 }
5856 }
5857 }
5858 };
5859 }
5861 function elementMatcher( matchers ) {
5862 return matchers.length > 1 ?
5863 function( elem, context, xml ) {
5864 var i = matchers.length;
5865 while ( i-- ) {
5866 if ( !matchers[i]( elem, context, xml ) ) {
5867 return false;
5868 }
5869 }
5870 return true;
5871 } :
5872 matchers[0];
5873 }
5875 function multipleContexts( selector, contexts, results ) {
5876 var i = 0,
5877 len = contexts.length;
5878 for ( ; i < len; i++ ) {
5879 Sizzle( selector, contexts[i], results );
5880 }
5881 return results;
5882 }
5884 function condense( unmatched, map, filter, context, xml ) {
5885 var elem,
5886 newUnmatched = [],
5887 i = 0,
5888 len = unmatched.length,
5889 mapped = map != null;
5891 for ( ; i < len; i++ ) {
5892 if ( (elem = unmatched[i]) ) {
5893 if ( !filter || filter( elem, context, xml ) ) {
5894 newUnmatched.push( elem );
5895 if ( mapped ) {
5896 map.push( i );
5897 }
5898 }
5899 }
5900 }
5902 return newUnmatched;
5903 }
5905 function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
5906 if ( postFilter && !postFilter[ expando ] ) {
5907 postFilter = setMatcher( postFilter );
5908 }
5909 if ( postFinder && !postFinder[ expando ] ) {
5910 postFinder = setMatcher( postFinder, postSelector );
5911 }
5912 return markFunction(function( seed, results, context, xml ) {
5913 var temp, i, elem,
5914 preMap = [],
5915 postMap = [],
5916 preexisting = results.length,
5918 elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
5920 matcherIn = preFilter && ( seed || !selector ) ?
5921 condense( elems, preMap, preFilter, context, xml ) :
5922 elems,
5924 matcherOut = matcher ?
5925 postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
5927 [] :
5929 results :
5930 matcherIn;
5932 if ( matcher ) {
5933 matcher( matcherIn, matcherOut, context, xml );
5934 }
5936 if ( postFilter ) {
5937 temp = condense( matcherOut, postMap );
5938 postFilter( temp, [], context, xml );
5940 i = temp.length;
5941 while ( i-- ) {
5942 if ( (elem = temp[i]) ) {
5943 matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
5944 }
5945 }
5946 }
5948 if ( seed ) {
5949 if ( postFinder || preFilter ) {
5950 if ( postFinder ) {
5951 temp = [];
5952 i = matcherOut.length;
5953 while ( i-- ) {
5954 if ( (elem = matcherOut[i]) ) {
5955 temp.push( (matcherIn[i] = elem) );
5956 }
5957 }
5958 postFinder( null, (matcherOut = []), temp, xml );
5959 }
5961 i = matcherOut.length;
5962 while ( i-- ) {
5963 if ( (elem = matcherOut[i]) &&
5964 (temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) {
5966 seed[temp] = !(results[temp] = elem);
5967 }
5968 }
5969 }
5971 } else {
5972 matcherOut = condense(
5973 matcherOut === results ?
5974 matcherOut.splice( preexisting, matcherOut.length ) :
5975 matcherOut
5976 );
5977 if ( postFinder ) {
5978 postFinder( null, results, matcherOut, xml );
5979 } else {
5980 push.apply( results, matcherOut );
5981 }
5982 }
5983 });
5984 }
5986 function matcherFromTokens( tokens ) {
5987 var checkContext, matcher, j,
5988 len = tokens.length,
5989 leadingRelative = Expr.relative[ tokens[0].type ],
5990 implicitRelative = leadingRelative || Expr.relative[" "],
5991 i = leadingRelative ? 1 : 0,
5993 matchContext = addCombinator( function( elem ) {
5994 return elem === checkContext;
5995 }, implicitRelative, true ),
5996 matchAnyContext = addCombinator( function( elem ) {
5997 return indexOf.call( checkContext, elem ) > -1;
5998 }, implicitRelative, true ),
5999 matchers = [ function( elem, context, xml ) {
6000 return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
6001 (checkContext = context).nodeType ?
6002 matchContext( elem, context, xml ) :
6003 matchAnyContext( elem, context, xml ) );
6004 } ];
6006 for ( ; i < len; i++ ) {
6007 if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
6008 matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
6009 } else {
6010 matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
6012 if ( matcher[ expando ] ) {
6013 j = ++i;
6014 for ( ; j < len; j++ ) {
6015 if ( Expr.relative[ tokens[j].type ] ) {
6016 break;
6017 }
6018 }
6019 return setMatcher(
6020 i > 1 && elementMatcher( matchers ),
6021 i > 1 && toSelector(
6022 tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
6023 ).replace( rtrim, "$1" ),
6024 matcher,
6025 i < j && matcherFromTokens( tokens.slice( i, j ) ),
6026 j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
6027 j < len && toSelector( tokens )
6028 );
6029 }
6030 matchers.push( matcher );
6031 }
6032 }
6034 return elementMatcher( matchers );
6035 }
6037 function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
6038 var bySet = setMatchers.length > 0,
6039 byElement = elementMatchers.length > 0,
6040 superMatcher = function( seed, context, xml, results, outermost ) {
6041 var elem, j, matcher,
6042 matchedCount = 0,
6043 i = "0",
6044 unmatched = seed && [],
6045 setMatched = [],
6046 contextBackup = outermostContext,
6047 elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
6048 dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
6049 len = elems.length;
6051 if ( outermost ) {
6052 outermostContext = context !== document && context;
6053 }
6055 for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
6056 if ( byElement && elem ) {
6057 j = 0;
6058 while ( (matcher = elementMatchers[j++]) ) {
6059 if ( matcher( elem, context, xml ) ) {
6060 results.push( elem );
6061 break;
6062 }
6063 }
6064 if ( outermost ) {
6065 dirruns = dirrunsUnique;
6066 }
6067 }
6069 if ( bySet ) {
6070 if ( (elem = !matcher && elem) ) {
6071 matchedCount--;
6072 }
6074 if ( seed ) {
6075 unmatched.push( elem );
6076 }
6077 }
6078 }
6080 matchedCount += i;
6081 if ( bySet && i !== matchedCount ) {
6082 j = 0;
6083 while ( (matcher = setMatchers[j++]) ) {
6084 matcher( unmatched, setMatched, context, xml );
6085 }
6087 if ( seed ) {
6088 if ( matchedCount > 0 ) {
6089 while ( i-- ) {
6090 if ( !(unmatched[i] || setMatched[i]) ) {
6091 setMatched[i] = pop.call( results );
6092 }
6093 }
6094 }
6096 setMatched = condense( setMatched );
6097 }
6099 push.apply( results, setMatched );
6101 if ( outermost && !seed && setMatched.length > 0 &&
6102 ( matchedCount + setMatchers.length ) > 1 ) {
6104 Sizzle.uniqueSort( results );
6105 }
6106 }
6108 if ( outermost ) {
6109 dirruns = dirrunsUnique;
6110 outermostContext = contextBackup;
6111 }
6113 return unmatched;
6114 };
6116 return bySet ?
6117 markFunction( superMatcher ) :
6118 superMatcher;
6119 }
6121 compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
6122 var i,
6123 setMatchers = [],
6124 elementMatchers = [],
6125 cached = compilerCache[ selector + " " ];
6127 if ( !cached ) {
6128 if ( !match ) {
6129 match = tokenize( selector );
6130 }
6131 i = match.length;
6132 while ( i-- ) {
6133 cached = matcherFromTokens( match[i] );
6134 if ( cached[ expando ] ) {
6135 setMatchers.push( cached );
6136 } else {
6137 elementMatchers.push( cached );
6138 }
6139 }
6141 cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
6143 cached.selector = selector;
6144 }
6145 return cached;
6146 };
6148 /**
6149 * A low-level selection function that works with Sizzle's compiled
6150 * selector functions
6156 */
6171 context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
6177 }
6180 }
6188 }
6193 )) ) {
6200 }
6203 }
6204 }
6205 }
6206 }
6209 seed,
6210 context,
6212 results,
6214 );
6216 };
6227 });
6232 }) ) {
6236 }
6237 });
6238 }
6244 }) ) {
6248 }
6249 });
6250 }
6254 }) ) {
6262 }
6263 });
6264 }
6272 }
6279 }
6289 }
6290 })();
6297 }
6301 }
6316 },
6324 initial = {};
6331 };
6344 };
6345 }
6353 }
6354 }
6356 });
6357 }
6358 };
6363 },
6373 }
6375 },
6388 }
6391 },
6397 },
6403 },
6408 });
6415 });
6416 },
6423 },
6435 }
6441 }
6442 };
6444 /*--------------------------------------------------------------------------*/
6451 },
6456 }
6457 };
6469 }
6470 }
6472 },
6478 },
6485 },
6490 },
6494 },
6505 },
6511 },
6517 }
6518 };
6520 /*--------------------------------------------------------------------------*/
6526 /*--------------------------------------------------------------------------*/
6536 }
6537 }
6543 }
6548 }
6562 }
6563 }
6565 }
6566 }
6571 }
6580 }
6582 }
6586 }
6596 button: valueSelector
6597 };
6598 })();
6600 /*--------------------------------------------------------------------------*/
6608 },
6616 }
6617 }
6618 });
6623 }
6624 });
6629 }
6630 });
6632 /*--------------------------------------------------------------------------*/
6642 else
6644 },
6651 }
6652 },
6656 },
6668 }
6669 }
6670 }
6671 });
6676 }
6677 });
6682 }
6683 });
6705 };
6714 };
6717 }
6718 }
6724 }
6729 }
6737 }
6738 }
6747 }
6748 }
6753 }
6763 }
6776 }
6779 }
6788 }
6789 }
6793 }
6802 }
6811 }
6820 }
6835 stop: stop
6836 };
6841 });
6857 }
6859 }
6865 };
6882 });
6888 };
6891 }
6896 }
6901 };
6905 }
6916 }
6922 }
6929 }
6939 }
6945 }
6961 handler: handler
6962 };
6966 }
6977 }
6978 }
6983 }
6989 }
6992 }
7004 else
7008 }
7016 }
7017 }
7025 }
7026 }
7036 }
7041 }
7048 }
7056 }
7057 }
7065 }
7066 }
7084 }
7085 }
7092 }
7103 }
7106 }
7112 else
7114 }
7123 }
7132 }
7143 }
7154 }
7167 },
7173 },
7178 },
7183 }
7184 });
7190 }
7193 }
7201 on: on
7202 });
7211 on: on
7212 });
7224 });
7233 }
7243 /* Code for creating leak-free event responders is based on work by
7244 John-David Dalton. */
7253 }
7267 };
7268 }
7283 };
7284 }
7296 }
7300 }
7301 }
7308 /* Support for the DOMContentLoaded event is based on work by Dan Webb,
7309 Matthias Miller, Dean Edwards, John Resig, and Diego Perini. */
7318 }
7324 }
7325 }
7333 }
7336 }
7342 }
7349 }
7356 /*------------------------------- DEPRECATED -------------------------------*/
7364 });
7369 },
7373 },
7377 },
7381 }
7382 };
7398 },
7411 },
7424 },
7434 },
7444 },
7449 },
7460 }
7461 };
7463 /*--------------------------------------------------------------------------*/
7465 if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
7468 }
7487 }))))
7489 }
7491 };
7495 };
7498 /*--------------------------------------------------------------------------*/
7504 },
7510 },
7514 },
7519 },
7524 },
7528 }
7529 };
7533 /*--------------------------------------------------------------------------*/
7539 },
7543 },
7547 },
7551 },
7555 }
7556 });
7561 results = [];
7567 }
7568 }
7570 },
7579 }
7580 }
7581 },
7586 }
7587 });
7588 })();