Changeset 23358


Ignore:
Timestamp:
06/19/13 06:36:23 (7 years ago)
Author:
rvelices
Message:

upgraded jquery to 1.10.1

Location:
trunk/themes/default/js
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/themes/default/js/jquery.js

    r22176 r23358  
    11/*! 
    2  * jQuery JavaScript Library v1.9.1 
     2 * jQuery JavaScript Library v1.10.1 
    33 * http://jquery.com/ 
    44 * 
     
    66 * http://sizzlejs.com/ 
    77 * 
    8  * Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors 
     8 * Copyright 2005, 2013 jQuery Foundation, Inc. and other contributors 
    99 * Released under the MIT license 
    1010 * http://jquery.org/license 
    1111 * 
    12  * Date: 2013-2-4 
     12 * Date: 2013-05-30T21:49Z 
    1313 */ 
    1414(function( window, undefined ) { 
     
    2626        rootjQuery, 
    2727 
    28         // Support: IE<9 
    29         // For `typeof node.method` instead of `node.method !== undefined` 
     28        // Support: IE<10 
     29        // For `typeof xmlNode.method` instead of `xmlNode.method !== undefined` 
    3030        core_strundefined = typeof undefined, 
    3131 
    3232        // Use the correct document accordingly with window argument (sandbox) 
     33        location = window.location, 
    3334        document = window.document, 
    34         location = window.location, 
     35        docElem = document.documentElement, 
    3536 
    3637        // Map over jQuery in case of overwrite 
     
    4647        core_deletedIds = [], 
    4748 
    48         core_version = "1.9.1", 
     49        core_version = "1.10.1", 
    4950 
    5051        // Save a reference to some core methods 
     
    7576        // Prioritize #id over <tag> to avoid XSS via location.hash (#9521) 
    7677        // Strict HTML recognition (#11290: must start with <) 
    77         rquickExpr = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/, 
     78        rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/, 
    7879 
    7980        // Match a standalone tag 
     
    228229        length: 0, 
    229230 
    230         // The number of elements contained in the matched element set 
    231         size: function() { 
    232                 return this.length; 
    233         }, 
    234  
    235231        toArray: function() { 
    236232                return core_slice.call( this ); 
     
    381377 
    382378jQuery.extend({ 
     379        // Unique for each copy of jQuery on the page 
     380        // Non-digits removed to match rinlinejQuery 
     381        expando: "jQuery" + ( core_version + Math.random() ).replace( /\D/g, "" ), 
     382 
    383383        noConflict: function( deep ) { 
    384384                if ( window.$ === jQuery ) { 
     
    451451 
    452452        isWindow: function( obj ) { 
     453                /* jshint eqeqeq: false */ 
    453454                return obj != null && obj == obj.window; 
    454455        }, 
     
    468469 
    469470        isPlainObject: function( obj ) { 
     471                var key; 
     472 
    470473                // Must be an Object. 
    471474                // Because of IE, we also have to check the presence of the constructor property. 
     
    487490                } 
    488491 
     492                // Support: IE<9 
     493                // Handle iteration over inherited properties before own properties. 
     494                if ( jQuery.support.ownLast ) { 
     495                        for ( key in obj ) { 
     496                                return core_hasOwn.call( obj, key ); 
     497                        } 
     498                } 
     499 
    489500                // Own properties are enumerated firstly, so to speed up, 
    490501                // if last one is own, then all properties are own. 
    491  
    492                 var key; 
    493502                for ( key in obj ) {} 
    494503 
     
    880889        now: function() { 
    881890                return ( new Date() ).getTime(); 
     891        }, 
     892 
     893        // A method for quickly swapping in/out CSS properties to get correct calculations. 
     894        // Note: this method belongs to the css module but it's needed here for the support module. 
     895        // If support gets modularized, this method should be moved back to the css module. 
     896        swap: function( elem, options, callback, args ) { 
     897                var ret, name, 
     898                        old = {}; 
     899 
     900                // Remember the old values, and insert the new ones 
     901                for ( name in options ) { 
     902                        old[ name ] = elem.style[ name ]; 
     903                        elem.style[ name ] = options[ name ]; 
     904                } 
     905 
     906                ret = callback.apply( elem, args || [] ); 
     907 
     908                // Revert the old values 
     909                for ( name in options ) { 
     910                        elem.style[ name ] = old[ name ]; 
     911                } 
     912 
     913                return ret; 
    882914        } 
    883915}); 
     
    9681000// All jQuery objects should point back to these 
    9691001rootjQuery = jQuery(document); 
     1002/*! 
     1003 * Sizzle CSS Selector Engine v1.9.4-pre 
     1004 * http://sizzlejs.com/ 
     1005 * 
     1006 * Copyright 2013 jQuery Foundation, Inc. and other contributors 
     1007 * Released under the MIT license 
     1008 * http://jquery.org/license 
     1009 * 
     1010 * Date: 2013-05-27 
     1011 */ 
     1012(function( window, undefined ) { 
     1013 
     1014var i, 
     1015        support, 
     1016        cachedruns, 
     1017        Expr, 
     1018        getText, 
     1019        isXML, 
     1020        compile, 
     1021        outermostContext, 
     1022        sortInput, 
     1023 
     1024        // Local document vars 
     1025        setDocument, 
     1026        document, 
     1027        docElem, 
     1028        documentIsHTML, 
     1029        rbuggyQSA, 
     1030        rbuggyMatches, 
     1031        matches, 
     1032        contains, 
     1033 
     1034        // Instance-specific data 
     1035        expando = "sizzle" + -(new Date()), 
     1036        preferredDoc = window.document, 
     1037        dirruns = 0, 
     1038        done = 0, 
     1039        classCache = createCache(), 
     1040        tokenCache = createCache(), 
     1041        compilerCache = createCache(), 
     1042        hasDuplicate = false, 
     1043        sortOrder = function() { return 0; }, 
     1044 
     1045        // General-purpose constants 
     1046        strundefined = typeof undefined, 
     1047        MAX_NEGATIVE = 1 << 31, 
     1048 
     1049        // Instance methods 
     1050        hasOwn = ({}).hasOwnProperty, 
     1051        arr = [], 
     1052        pop = arr.pop, 
     1053        push_native = arr.push, 
     1054        push = arr.push, 
     1055        slice = arr.slice, 
     1056        // Use a stripped-down indexOf if we can't use a native one 
     1057        indexOf = arr.indexOf || function( elem ) { 
     1058                var i = 0, 
     1059                        len = this.length; 
     1060                for ( ; i < len; i++ ) { 
     1061                        if ( this[i] === elem ) { 
     1062                                return i; 
     1063                        } 
     1064                } 
     1065                return -1; 
     1066        }, 
     1067 
     1068        booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", 
     1069 
     1070        // Regular expressions 
     1071 
     1072        // Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace 
     1073        whitespace = "[\\x20\\t\\r\\n\\f]", 
     1074        // http://www.w3.org/TR/css3-syntax/#characters 
     1075        characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+", 
     1076 
     1077        // Loosely modeled on CSS identifier characters 
     1078        // An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors 
     1079        // Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier 
     1080        identifier = characterEncoding.replace( "w", "w#" ), 
     1081 
     1082        // Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors 
     1083        attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace + 
     1084                "*(?:([*^$|!~]?=)" + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]", 
     1085 
     1086        // Prefer arguments quoted, 
     1087        //   then not containing pseudos/brackets, 
     1088        //   then attribute selectors/non-parenthetical expressions, 
     1089        //   then anything else 
     1090        // These preferences are here to reduce the number of selectors 
     1091        //   needing tokenize in the PSEUDO preFilter 
     1092        pseudos = ":(" + characterEncoding + ")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" + attributes.replace( 3, 8 ) + ")*)|.*)\\)|)", 
     1093 
     1094        // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter 
     1095        rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ), 
     1096 
     1097        rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), 
     1098        rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ), 
     1099 
     1100        rsibling = new RegExp( whitespace + "*[+~]" ), 
     1101        rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*)" + whitespace + "*\\]", "g" ), 
     1102 
     1103        rpseudo = new RegExp( pseudos ), 
     1104        ridentifier = new RegExp( "^" + identifier + "$" ), 
     1105 
     1106        matchExpr = { 
     1107                "ID": new RegExp( "^#(" + characterEncoding + ")" ), 
     1108                "CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ), 
     1109                "TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ), 
     1110                "ATTR": new RegExp( "^" + attributes ), 
     1111                "PSEUDO": new RegExp( "^" + pseudos ), 
     1112                "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + 
     1113                        "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + 
     1114                        "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), 
     1115                "bool": new RegExp( "^(?:" + booleans + ")$", "i" ), 
     1116                // For use in libraries implementing .is() 
     1117                // We use this for POS matching in `select` 
     1118                "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + 
     1119                        whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) 
     1120        }, 
     1121 
     1122        rnative = /^[^{]+\{\s*\[native \w/, 
     1123 
     1124        // Easily-parseable/retrievable ID or TAG or CLASS selectors 
     1125        rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, 
     1126 
     1127        rinputs = /^(?:input|select|textarea|button)$/i, 
     1128        rheader = /^h\d$/i, 
     1129 
     1130        rescape = /'|\\/g, 
     1131 
     1132        // CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters 
     1133        runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ), 
     1134        funescape = function( _, escaped, escapedWhitespace ) { 
     1135                var high = "0x" + escaped - 0x10000; 
     1136                // NaN means non-codepoint 
     1137                // Support: Firefox 
     1138                // Workaround erroneous numeric interpretation of +"0x" 
     1139                return high !== high || escapedWhitespace ? 
     1140                        escaped : 
     1141                        // BMP codepoint 
     1142                        high < 0 ? 
     1143                                String.fromCharCode( high + 0x10000 ) : 
     1144                                // Supplemental Plane codepoint (surrogate pair) 
     1145                                String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); 
     1146        }; 
     1147 
     1148// Optimize for push.apply( _, NodeList ) 
     1149try { 
     1150        push.apply( 
     1151                (arr = slice.call( preferredDoc.childNodes )), 
     1152                preferredDoc.childNodes 
     1153        ); 
     1154        // Support: Android<4.0 
     1155        // Detect silently failing push.apply 
     1156        arr[ preferredDoc.childNodes.length ].nodeType; 
     1157} catch ( e ) { 
     1158        push = { apply: arr.length ? 
     1159 
     1160                // Leverage slice if possible 
     1161                function( target, els ) { 
     1162                        push_native.apply( target, slice.call(els) ); 
     1163                } : 
     1164 
     1165                // Support: IE<9 
     1166                // Otherwise append directly 
     1167                function( target, els ) { 
     1168                        var j = target.length, 
     1169                                i = 0; 
     1170                        // Can't trust NodeList.length 
     1171                        while ( (target[j++] = els[i++]) ) {} 
     1172                        target.length = j - 1; 
     1173                } 
     1174        }; 
     1175} 
     1176 
     1177function Sizzle( selector, context, results, seed ) { 
     1178        var match, elem, m, nodeType, 
     1179                // QSA vars 
     1180                i, groups, old, nid, newContext, newSelector; 
     1181 
     1182        if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) { 
     1183                setDocument( context ); 
     1184        } 
     1185 
     1186        context = context || document; 
     1187        results = results || []; 
     1188 
     1189        if ( !selector || typeof selector !== "string" ) { 
     1190                return results; 
     1191        } 
     1192 
     1193        if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) { 
     1194                return []; 
     1195        } 
     1196 
     1197        if ( documentIsHTML && !seed ) { 
     1198 
     1199                // Shortcuts 
     1200                if ( (match = rquickExpr.exec( selector )) ) { 
     1201                        // Speed-up: Sizzle("#ID") 
     1202                        if ( (m = match[1]) ) { 
     1203                                if ( nodeType === 9 ) { 
     1204                                        elem = context.getElementById( m ); 
     1205                                        // Check parentNode to catch when Blackberry 4.6 returns 
     1206                                        // nodes that are no longer in the document #6963 
     1207                                        if ( elem && elem.parentNode ) { 
     1208                                                // Handle the case where IE, Opera, and Webkit return items 
     1209                                                // by name instead of ID 
     1210                                                if ( elem.id === m ) { 
     1211                                                        results.push( elem ); 
     1212                                                        return results; 
     1213                                                } 
     1214                                        } else { 
     1215                                                return results; 
     1216                                        } 
     1217                                } else { 
     1218                                        // Context is not a document 
     1219                                        if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) && 
     1220                                                contains( context, elem ) && elem.id === m ) { 
     1221                                                results.push( elem ); 
     1222                                                return results; 
     1223                                        } 
     1224                                } 
     1225 
     1226                        // Speed-up: Sizzle("TAG") 
     1227                        } else if ( match[2] ) { 
     1228                                push.apply( results, context.getElementsByTagName( selector ) ); 
     1229                                return results; 
     1230 
     1231                        // Speed-up: Sizzle(".CLASS") 
     1232                        } else if ( (m = match[3]) && support.getElementsByClassName && context.getElementsByClassName ) { 
     1233                                push.apply( results, context.getElementsByClassName( m ) ); 
     1234                                return results; 
     1235                        } 
     1236                } 
     1237 
     1238                // QSA path 
     1239                if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) { 
     1240                        nid = old = expando; 
     1241                        newContext = context; 
     1242                        newSelector = nodeType === 9 && selector; 
     1243 
     1244                        // qSA works strangely on Element-rooted queries 
     1245                        // We can work around this by specifying an extra ID on the root 
     1246                        // and working up from there (Thanks to Andrew Dupont for the technique) 
     1247                        // IE 8 doesn't work on object elements 
     1248                        if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) { 
     1249                                groups = tokenize( selector ); 
     1250 
     1251                                if ( (old = context.getAttribute("id")) ) { 
     1252                                        nid = old.replace( rescape, "\\$&" ); 
     1253                                } else { 
     1254                                        context.setAttribute( "id", nid ); 
     1255                                } 
     1256                                nid = "[id='" + nid + "'] "; 
     1257 
     1258                                i = groups.length; 
     1259                                while ( i-- ) { 
     1260                                        groups[i] = nid + toSelector( groups[i] ); 
     1261                                } 
     1262                                newContext = rsibling.test( selector ) && context.parentNode || context; 
     1263                                newSelector = groups.join(","); 
     1264                        } 
     1265 
     1266                        if ( newSelector ) { 
     1267                                try { 
     1268                                        push.apply( results, 
     1269                                                newContext.querySelectorAll( newSelector ) 
     1270                                        ); 
     1271                                        return results; 
     1272                                } catch(qsaError) { 
     1273                                } finally { 
     1274                                        if ( !old ) { 
     1275                                                context.removeAttribute("id"); 
     1276                                        } 
     1277                                } 
     1278                        } 
     1279                } 
     1280        } 
     1281 
     1282        // All others 
     1283        return select( selector.replace( rtrim, "$1" ), context, results, seed ); 
     1284} 
     1285 
     1286/** 
     1287 * For feature detection 
     1288 * @param {Function} fn The function to test for native support 
     1289 */ 
     1290function isNative( fn ) { 
     1291        return rnative.test( fn + "" ); 
     1292} 
     1293 
     1294/** 
     1295 * Create key-value caches of limited size 
     1296 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with 
     1297 *      property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) 
     1298 *      deleting the oldest entry 
     1299 */ 
     1300function createCache() { 
     1301        var keys = []; 
     1302 
     1303        function cache( key, value ) { 
     1304                // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) 
     1305                if ( keys.push( key += " " ) > Expr.cacheLength ) { 
     1306                        // Only keep the most recent entries 
     1307                        delete cache[ keys.shift() ]; 
     1308                } 
     1309                return (cache[ key ] = value); 
     1310        } 
     1311        return cache; 
     1312} 
     1313 
     1314/** 
     1315 * Mark a function for special use by Sizzle 
     1316 * @param {Function} fn The function to mark 
     1317 */ 
     1318function markFunction( fn ) { 
     1319        fn[ expando ] = true; 
     1320        return fn; 
     1321} 
     1322 
     1323/** 
     1324 * Support testing using an element 
     1325 * @param {Function} fn Passed the created div and expects a boolean result 
     1326 */ 
     1327function assert( fn ) { 
     1328        var div = document.createElement("div"); 
     1329 
     1330        try { 
     1331                return !!fn( div ); 
     1332        } catch (e) { 
     1333                return false; 
     1334        } finally { 
     1335                // Remove from its parent by default 
     1336                if ( div.parentNode ) { 
     1337                        div.parentNode.removeChild( div ); 
     1338                } 
     1339                // release memory in IE 
     1340                div = null; 
     1341        } 
     1342} 
     1343 
     1344/** 
     1345 * Adds the same handler for all of the specified attrs 
     1346 * @param {String} attrs Pipe-separated list of attributes 
     1347 * @param {Function} handler The method that will be applied if the test fails 
     1348 * @param {Boolean} test The result of a test. If true, null will be set as the handler in leiu of the specified handler 
     1349 */ 
     1350function addHandle( attrs, handler, test ) { 
     1351        attrs = attrs.split("|"); 
     1352        var current, 
     1353                i = attrs.length, 
     1354                setHandle = test ? null : handler; 
     1355 
     1356        while ( i-- ) { 
     1357                // Don't override a user's handler 
     1358                if ( !(current = Expr.attrHandle[ attrs[i] ]) || current === handler ) { 
     1359                        Expr.attrHandle[ attrs[i] ] = setHandle; 
     1360                } 
     1361        } 
     1362} 
     1363 
     1364/** 
     1365 * Fetches boolean attributes by node 
     1366 * @param {Element} elem 
     1367 * @param {String} name 
     1368 */ 
     1369function boolHandler( elem, name ) { 
     1370        // XML does not need to be checked as this will not be assigned for XML documents 
     1371        var val = elem.getAttributeNode( name ); 
     1372        return val && val.specified ? 
     1373                val.value : 
     1374                elem[ name ] === true ? name.toLowerCase() : null; 
     1375} 
     1376 
     1377/** 
     1378 * Fetches attributes without interpolation 
     1379 * http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx 
     1380 * @param {Element} elem 
     1381 * @param {String} name 
     1382 */ 
     1383function interpolationHandler( elem, name ) { 
     1384        // XML does not need to be checked as this will not be assigned for XML documents 
     1385        return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 ); 
     1386} 
     1387 
     1388/** 
     1389 * Uses defaultValue to retrieve value in IE6/7 
     1390 * @param {Element} elem 
     1391 * @param {String} name 
     1392 */ 
     1393function valueHandler( elem ) { 
     1394        // Ignore the value *property* on inputs by using defaultValue 
     1395        // Fallback to Sizzle.attr by returning undefined where appropriate 
     1396        // XML does not need to be checked as this will not be assigned for XML documents 
     1397        if ( elem.nodeName.toLowerCase() === "input" ) { 
     1398                return elem.defaultValue; 
     1399        } 
     1400} 
     1401 
     1402/** 
     1403 * Checks document order of two siblings 
     1404 * @param {Element} a 
     1405 * @param {Element} b 
     1406 * @returns Returns -1 if a precedes b, 1 if a follows b 
     1407 */ 
     1408function siblingCheck( a, b ) { 
     1409        var cur = b && a, 
     1410                diff = cur && a.nodeType === 1 && b.nodeType === 1 && 
     1411                        ( ~b.sourceIndex || MAX_NEGATIVE ) - 
     1412                        ( ~a.sourceIndex || MAX_NEGATIVE ); 
     1413 
     1414        // Use IE sourceIndex if available on both nodes 
     1415        if ( diff ) { 
     1416                return diff; 
     1417        } 
     1418 
     1419        // Check if b follows a 
     1420        if ( cur ) { 
     1421                while ( (cur = cur.nextSibling) ) { 
     1422                        if ( cur === b ) { 
     1423                                return -1; 
     1424                        } 
     1425                } 
     1426        } 
     1427 
     1428        return a ? 1 : -1; 
     1429} 
     1430 
     1431/** 
     1432 * Returns a function to use in pseudos for input types 
     1433 * @param {String} type 
     1434 */ 
     1435function createInputPseudo( type ) { 
     1436        return function( elem ) { 
     1437                var name = elem.nodeName.toLowerCase(); 
     1438                return name === "input" && elem.type === type; 
     1439        }; 
     1440} 
     1441 
     1442/** 
     1443 * Returns a function to use in pseudos for buttons 
     1444 * @param {String} type 
     1445 */ 
     1446function createButtonPseudo( type ) { 
     1447        return function( elem ) { 
     1448                var name = elem.nodeName.toLowerCase(); 
     1449                return (name === "input" || name === "button") && elem.type === type; 
     1450        }; 
     1451} 
     1452 
     1453/** 
     1454 * Returns a function to use in pseudos for positionals 
     1455 * @param {Function} fn 
     1456 */ 
     1457function createPositionalPseudo( fn ) { 
     1458        return markFunction(function( argument ) { 
     1459                argument = +argument; 
     1460                return markFunction(function( seed, matches ) { 
     1461                        var j, 
     1462                                matchIndexes = fn( [], seed.length, argument ), 
     1463                                i = matchIndexes.length; 
     1464 
     1465                        // Match elements found at the specified indexes 
     1466                        while ( i-- ) { 
     1467                                if ( seed[ (j = matchIndexes[i]) ] ) { 
     1468                                        seed[j] = !(matches[j] = seed[j]); 
     1469                                } 
     1470                        } 
     1471                }); 
     1472        }); 
     1473} 
     1474 
     1475/** 
     1476 * Detect xml 
     1477 * @param {Element|Object} elem An element or a document 
     1478 */ 
     1479isXML = Sizzle.isXML = function( elem ) { 
     1480        // documentElement is verified for cases where it doesn't yet exist 
     1481        // (such as loading iframes in IE - #4833) 
     1482        var documentElement = elem && (elem.ownerDocument || elem).documentElement; 
     1483        return documentElement ? documentElement.nodeName !== "HTML" : false; 
     1484}; 
     1485 
     1486// Expose support vars for convenience 
     1487support = Sizzle.support = {}; 
     1488 
     1489/** 
     1490 * Sets document-related variables once based on the current document 
     1491 * @param {Element|Object} [doc] An element or document object to use to set the document 
     1492 * @returns {Object} Returns the current document 
     1493 */ 
     1494setDocument = Sizzle.setDocument = function( node ) { 
     1495        var doc = node ? node.ownerDocument || node : preferredDoc, 
     1496                parent = doc.parentWindow; 
     1497 
     1498        // If no document and documentElement is available, return 
     1499        if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) { 
     1500                return document; 
     1501        } 
     1502 
     1503        // Set our document 
     1504        document = doc; 
     1505        docElem = doc.documentElement; 
     1506 
     1507        // Support tests 
     1508        documentIsHTML = !isXML( doc ); 
     1509 
     1510        // Support: IE>8 
     1511        // If iframe document is assigned to "document" variable and if iframe has been reloaded, 
     1512        // IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936 
     1513        if ( parent && parent.frameElement ) { 
     1514                parent.attachEvent( "onbeforeunload", function() { 
     1515                        setDocument(); 
     1516                }); 
     1517        } 
     1518 
     1519        /* Attributes 
     1520        ---------------------------------------------------------------------- */ 
     1521 
     1522        // Support: IE<8 
     1523        // Verify that getAttribute really returns attributes and not properties (excepting IE8 booleans) 
     1524        support.attributes = assert(function( div ) { 
     1525 
     1526                // Support: IE<8 
     1527                // Prevent attribute/property "interpolation" 
     1528                div.innerHTML = "<a href='#'></a>"; 
     1529                addHandle( "type|href|height|width", interpolationHandler, div.firstChild.getAttribute("href") === "#" ); 
     1530 
     1531                // Support: IE<9 
     1532                // Use getAttributeNode to fetch booleans when getAttribute lies 
     1533                addHandle( booleans, boolHandler, div.getAttribute("disabled") == null ); 
     1534 
     1535                div.className = "i"; 
     1536                return !div.getAttribute("className"); 
     1537        }); 
     1538 
     1539        // Support: IE<9 
     1540        // Retrieving value should defer to defaultValue 
     1541        support.input = assert(function( div ) { 
     1542                div.innerHTML = "<input>"; 
     1543                div.firstChild.setAttribute( "value", "" ); 
     1544                return div.firstChild.getAttribute( "value" ) === ""; 
     1545        }); 
     1546 
     1547        // IE6/7 still return empty string for value, 
     1548        // but are actually retrieving the property 
     1549        addHandle( "value", valueHandler, support.attributes && support.input ); 
     1550 
     1551        /* getElement(s)By* 
     1552        ---------------------------------------------------------------------- */ 
     1553 
     1554        // Check if getElementsByTagName("*") returns only elements 
     1555        support.getElementsByTagName = assert(function( div ) { 
     1556                div.appendChild( doc.createComment("") ); 
     1557                return !div.getElementsByTagName("*").length; 
     1558        }); 
     1559 
     1560        // Check if getElementsByClassName can be trusted 
     1561        support.getElementsByClassName = assert(function( div ) { 
     1562                div.innerHTML = "<div class='a'></div><div class='a i'></div>"; 
     1563 
     1564                // Support: Safari<4 
     1565                // Catch class over-caching 
     1566                div.firstChild.className = "i"; 
     1567                // Support: Opera<10 
     1568                // Catch gEBCN failure to find non-leading classes 
     1569                return div.getElementsByClassName("i").length === 2; 
     1570        }); 
     1571 
     1572        // Support: IE<10 
     1573        // Check if getElementById returns elements by name 
     1574        // The broken getElementById methods don't pick up programatically-set names, 
     1575        // so use a roundabout getElementsByName test 
     1576        support.getById = assert(function( div ) { 
     1577                docElem.appendChild( div ).id = expando; 
     1578                return !doc.getElementsByName || !doc.getElementsByName( expando ).length; 
     1579        }); 
     1580 
     1581        // ID find and filter 
     1582        if ( support.getById ) { 
     1583                Expr.find["ID"] = function( id, context ) { 
     1584                        if ( typeof context.getElementById !== strundefined && documentIsHTML ) { 
     1585                                var m = context.getElementById( id ); 
     1586                                // Check parentNode to catch when Blackberry 4.6 returns 
     1587                                // nodes that are no longer in the document #6963 
     1588                                return m && m.parentNode ? [m] : []; 
     1589                        } 
     1590                }; 
     1591                Expr.filter["ID"] = function( id ) { 
     1592                        var attrId = id.replace( runescape, funescape ); 
     1593                        return function( elem ) { 
     1594                                return elem.getAttribute("id") === attrId; 
     1595                        }; 
     1596                }; 
     1597        } else { 
     1598                // Support: IE6/7 
     1599                // getElementById is not reliable as a find shortcut 
     1600                delete Expr.find["ID"]; 
     1601 
     1602                Expr.filter["ID"] =  function( id ) { 
     1603                        var attrId = id.replace( runescape, funescape ); 
     1604                        return function( elem ) { 
     1605                                var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id"); 
     1606                                return node && node.value === attrId; 
     1607                        }; 
     1608                }; 
     1609        } 
     1610 
     1611        // Tag 
     1612        Expr.find["TAG"] = support.getElementsByTagName ? 
     1613                function( tag, context ) { 
     1614                        if ( typeof context.getElementsByTagName !== strundefined ) { 
     1615                                return context.getElementsByTagName( tag ); 
     1616                        } 
     1617                } : 
     1618                function( tag, context ) { 
     1619                        var elem, 
     1620                                tmp = [], 
     1621                                i = 0, 
     1622                                results = context.getElementsByTagName( tag ); 
     1623 
     1624                        // Filter out possible comments 
     1625                        if ( tag === "*" ) { 
     1626                                while ( (elem = results[i++]) ) { 
     1627                                        if ( elem.nodeType === 1 ) { 
     1628                                                tmp.push( elem ); 
     1629                                        } 
     1630                                } 
     1631 
     1632                                return tmp; 
     1633                        } 
     1634                        return results; 
     1635                }; 
     1636 
     1637        // Class 
     1638        Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) { 
     1639                if ( typeof context.getElementsByClassName !== strundefined && documentIsHTML ) { 
     1640                        return context.getElementsByClassName( className ); 
     1641                } 
     1642        }; 
     1643 
     1644        /* QSA/matchesSelector 
     1645        ---------------------------------------------------------------------- */ 
     1646 
     1647        // QSA and matchesSelector support 
     1648 
     1649        // matchesSelector(:active) reports false when true (IE9/Opera 11.5) 
     1650        rbuggyMatches = []; 
     1651 
     1652        // qSa(:focus) reports false when true (Chrome 21) 
     1653        // We allow this because of a bug in IE8/9 that throws an error 
     1654        // whenever `document.activeElement` is accessed on an iframe 
     1655        // So, we allow :focus to pass through QSA all the time to avoid the IE error 
     1656        // See http://bugs.jquery.com/ticket/13378 
     1657        rbuggyQSA = []; 
     1658 
     1659        if ( (support.qsa = isNative(doc.querySelectorAll)) ) { 
     1660                // Build QSA regex 
     1661                // Regex strategy adopted from Diego Perini 
     1662                assert(function( div ) { 
     1663                        // Select is set to empty string on purpose 
     1664                        // This is to test IE's treatment of not explicitly 
     1665                        // setting a boolean content attribute, 
     1666                        // since its presence should be enough 
     1667                        // http://bugs.jquery.com/ticket/12359 
     1668                        div.innerHTML = "<select><option selected=''></option></select>"; 
     1669 
     1670                        // Support: IE8 
     1671                        // Boolean attributes and "value" are not treated correctly 
     1672                        if ( !div.querySelectorAll("[selected]").length ) { 
     1673                                rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); 
     1674                        } 
     1675 
     1676                        // Webkit/Opera - :checked should return selected option elements 
     1677                        // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked 
     1678                        // IE8 throws error here and will not see later tests 
     1679                        if ( !div.querySelectorAll(":checked").length ) { 
     1680                                rbuggyQSA.push(":checked"); 
     1681                        } 
     1682                }); 
     1683 
     1684                assert(function( div ) { 
     1685 
     1686                        // Support: Opera 10-12/IE8 
     1687                        // ^= $= *= and empty values 
     1688                        // Should not select anything 
     1689                        // Support: Windows 8 Native Apps 
     1690                        // The type attribute is restricted during .innerHTML assignment 
     1691                        var input = doc.createElement("input"); 
     1692                        input.setAttribute( "type", "hidden" ); 
     1693                        div.appendChild( input ).setAttribute( "t", "" ); 
     1694 
     1695                        if ( div.querySelectorAll("[t^='']").length ) { 
     1696                                rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" ); 
     1697                        } 
     1698 
     1699                        // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) 
     1700                        // IE8 throws error here and will not see later tests 
     1701                        if ( !div.querySelectorAll(":enabled").length ) { 
     1702                                rbuggyQSA.push( ":enabled", ":disabled" ); 
     1703                        } 
     1704 
     1705                        // Opera 10-11 does not throw on post-comma invalid pseudos 
     1706                        div.querySelectorAll("*,:x"); 
     1707                        rbuggyQSA.push(",.*:"); 
     1708                }); 
     1709        } 
     1710 
     1711        if ( (support.matchesSelector = isNative( (matches = docElem.webkitMatchesSelector || 
     1712                docElem.mozMatchesSelector || 
     1713                docElem.oMatchesSelector || 
     1714                docElem.msMatchesSelector) )) ) { 
     1715 
     1716                assert(function( div ) { 
     1717                        // Check to see if it's possible to do matchesSelector 
     1718                        // on a disconnected node (IE 9) 
     1719                        support.disconnectedMatch = matches.call( div, "div" ); 
     1720 
     1721                        // This should fail with an exception 
     1722                        // Gecko does not error, returns false instead 
     1723                        matches.call( div, "[s!='']:x" ); 
     1724                        rbuggyMatches.push( "!=", pseudos ); 
     1725                }); 
     1726        } 
     1727 
     1728        rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") ); 
     1729        rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") ); 
     1730 
     1731        /* Contains 
     1732        ---------------------------------------------------------------------- */ 
     1733 
     1734        // Element contains another 
     1735        // Purposefully does not implement inclusive descendent 
     1736        // As in, an element does not contain itself 
     1737        contains = isNative(docElem.contains) || docElem.compareDocumentPosition ? 
     1738                function( a, b ) { 
     1739                        var adown = a.nodeType === 9 ? a.documentElement : a, 
     1740                                bup = b && b.parentNode; 
     1741                        return a === bup || !!( bup && bup.nodeType === 1 && ( 
     1742                                adown.contains ? 
     1743                                        adown.contains( bup ) : 
     1744                                        a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 
     1745                        )); 
     1746                } : 
     1747                function( a, b ) { 
     1748                        if ( b ) { 
     1749                                while ( (b = b.parentNode) ) { 
     1750                                        if ( b === a ) { 
     1751                                                return true; 
     1752                                        } 
     1753                                } 
     1754                        } 
     1755                        return false; 
     1756                }; 
     1757 
     1758        /* Sorting 
     1759        ---------------------------------------------------------------------- */ 
     1760 
     1761        // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27) 
     1762        // Detached nodes confoundingly follow *each other* 
     1763        support.sortDetached = assert(function( div1 ) { 
     1764                // Should return 1, but returns 4 (following) 
     1765                return div1.compareDocumentPosition( doc.createElement("div") ) & 1; 
     1766        }); 
     1767 
     1768        // Document order sorting 
     1769        sortOrder = docElem.compareDocumentPosition ? 
     1770        function( a, b ) { 
     1771 
     1772                // Flag for duplicate removal 
     1773                if ( a === b ) { 
     1774                        hasDuplicate = true; 
     1775                        return 0; 
     1776                } 
     1777 
     1778                var compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition( b ); 
     1779 
     1780                if ( compare ) { 
     1781                        // Disconnected nodes 
     1782                        if ( compare & 1 || 
     1783                                (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) { 
     1784 
     1785                                // Choose the first element that is related to our preferred document 
     1786                                if ( a === doc || contains(preferredDoc, a) ) { 
     1787                                        return -1; 
     1788                                } 
     1789                                if ( b === doc || contains(preferredDoc, b) ) { 
     1790                                        return 1; 
     1791                                } 
     1792 
     1793                                // Maintain original order 
     1794                                return sortInput ? 
     1795                                        ( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) : 
     1796                                        0; 
     1797                        } 
     1798 
     1799                        return compare & 4 ? -1 : 1; 
     1800                } 
     1801 
     1802                // Not directly comparable, sort on existence of method 
     1803                return a.compareDocumentPosition ? -1 : 1; 
     1804        } : 
     1805        function( a, b ) { 
     1806                var cur, 
     1807                        i = 0, 
     1808                        aup = a.parentNode, 
     1809                        bup = b.parentNode, 
     1810                        ap = [ a ], 
     1811                        bp = [ b ]; 
     1812 
     1813                // Exit early if the nodes are identical 
     1814                if ( a === b ) { 
     1815                        hasDuplicate = true; 
     1816                        return 0; 
     1817 
     1818                // Parentless nodes are either documents or disconnected 
     1819                } else if ( !aup || !bup ) { 
     1820                        return a === doc ? -1 : 
     1821                                b === doc ? 1 : 
     1822                                aup ? -1 : 
     1823                                bup ? 1 : 
     1824                                sortInput ? 
     1825                                ( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) : 
     1826                                0; 
     1827 
     1828                // If the nodes are siblings, we can do a quick check 
     1829                } else if ( aup === bup ) { 
     1830                        return siblingCheck( a, b ); 
     1831                } 
     1832 
     1833                // Otherwise we need full lists of their ancestors for comparison 
     1834                cur = a; 
     1835                while ( (cur = cur.parentNode) ) { 
     1836                        ap.unshift( cur ); 
     1837                } 
     1838                cur = b; 
     1839                while ( (cur = cur.parentNode) ) { 
     1840                        bp.unshift( cur ); 
     1841                } 
     1842 
     1843                // Walk down the tree looking for a discrepancy 
     1844                while ( ap[i] === bp[i] ) { 
     1845                        i++; 
     1846                } 
     1847 
     1848                return i ? 
     1849                        // Do a sibling check if the nodes have a common ancestor 
     1850                        siblingCheck( ap[i], bp[i] ) : 
     1851 
     1852                        // Otherwise nodes in our document sort first 
     1853                        ap[i] === preferredDoc ? -1 : 
     1854                        bp[i] === preferredDoc ? 1 : 
     1855                        0; 
     1856        }; 
     1857 
     1858        return doc; 
     1859}; 
     1860 
     1861Sizzle.matches = function( expr, elements ) { 
     1862        return Sizzle( expr, null, null, elements ); 
     1863}; 
     1864 
     1865Sizzle.matchesSelector = function( elem, expr ) { 
     1866        // Set document vars if needed 
     1867        if ( ( elem.ownerDocument || elem ) !== document ) { 
     1868                setDocument( elem ); 
     1869        } 
     1870 
     1871        // Make sure that attribute selectors are quoted 
     1872        expr = expr.replace( rattributeQuotes, "='$1']" ); 
     1873 
     1874        if ( support.matchesSelector && documentIsHTML && 
     1875                ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) && 
     1876                ( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) { 
     1877 
     1878                try { 
     1879                        var ret = matches.call( elem, expr ); 
     1880 
     1881                        // IE 9's matchesSelector returns false on disconnected nodes 
     1882                        if ( ret || support.disconnectedMatch || 
     1883                                        // As well, disconnected nodes are said to be in a document 
     1884                                        // fragment in IE 9 
     1885                                        elem.document && elem.document.nodeType !== 11 ) { 
     1886                                return ret; 
     1887                        } 
     1888                } catch(e) {} 
     1889        } 
     1890 
     1891        return Sizzle( expr, document, null, [elem] ).length > 0; 
     1892}; 
     1893 
     1894Sizzle.contains = function( context, elem ) { 
     1895        // Set document vars if needed 
     1896        if ( ( context.ownerDocument || context ) !== document ) { 
     1897                setDocument( context ); 
     1898        } 
     1899        return contains( context, elem ); 
     1900}; 
     1901 
     1902Sizzle.attr = function( elem, name ) { 
     1903        // Set document vars if needed 
     1904        if ( ( elem.ownerDocument || elem ) !== document ) { 
     1905                setDocument( elem ); 
     1906        } 
     1907 
     1908        var fn = Expr.attrHandle[ name.toLowerCase() ], 
     1909                // Don't get fooled by Object.prototype properties (jQuery #13807) 
     1910                val = ( fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? 
     1911                        fn( elem, name, !documentIsHTML ) : 
     1912                        undefined ); 
     1913 
     1914        return val === undefined ? 
     1915                support.attributes || !documentIsHTML ? 
     1916                        elem.getAttribute( name ) : 
     1917                        (val = elem.getAttributeNode(name)) && val.specified ? 
     1918                                val.value : 
     1919                                null : 
     1920                val; 
     1921}; 
     1922 
     1923Sizzle.error = function( msg ) { 
     1924        throw new Error( "Syntax error, unrecognized expression: " + msg ); 
     1925}; 
     1926 
     1927/** 
     1928 * Document sorting and removing duplicates 
     1929 * @param {ArrayLike} results 
     1930 */ 
     1931Sizzle.uniqueSort = function( results ) { 
     1932        var elem, 
     1933                duplicates = [], 
     1934                j = 0, 
     1935                i = 0; 
     1936 
     1937        // Unless we *know* we can detect duplicates, assume their presence 
     1938        hasDuplicate = !support.detectDuplicates; 
     1939        sortInput = !support.sortStable && results.slice( 0 ); 
     1940        results.sort( sortOrder ); 
     1941 
     1942        if ( hasDuplicate ) { 
     1943                while ( (elem = results[i++]) ) { 
     1944                        if ( elem === results[ i ] ) { 
     1945                                j = duplicates.push( i ); 
     1946                        } 
     1947                } 
     1948                while ( j-- ) { 
     1949                        results.splice( duplicates[ j ], 1 ); 
     1950                } 
     1951        } 
     1952 
     1953        return results; 
     1954}; 
     1955 
     1956/** 
     1957 * Utility function for retrieving the text value of an array of DOM nodes 
     1958 * @param {Array|Element} elem 
     1959 */ 
     1960getText = Sizzle.getText = function( elem ) { 
     1961        var node, 
     1962                ret = "", 
     1963                i = 0, 
     1964                nodeType = elem.nodeType; 
     1965 
     1966        if ( !nodeType ) { 
     1967                // If no nodeType, this is expected to be an array 
     1968                for ( ; (node = elem[i]); i++ ) { 
     1969                        // Do not traverse comment nodes 
     1970                        ret += getText( node ); 
     1971                } 
     1972        } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { 
     1973                // Use textContent for elements 
     1974                // innerText usage removed for consistency of new lines (see #11153) 
     1975                if ( typeof elem.textContent === "string" ) { 
     1976                        return elem.textContent; 
     1977                } else { 
     1978                        // Traverse its children 
     1979                        for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { 
     1980                                ret += getText( elem ); 
     1981                        } 
     1982                } 
     1983        } else if ( nodeType === 3 || nodeType === 4 ) { 
     1984                return elem.nodeValue; 
     1985        } 
     1986        // Do not include comment or processing instruction nodes 
     1987 
     1988        return ret; 
     1989}; 
     1990 
     1991Expr = Sizzle.selectors = { 
     1992 
     1993        // Can be adjusted by the user 
     1994        cacheLength: 50, 
     1995 
     1996        createPseudo: markFunction, 
     1997 
     1998        match: matchExpr, 
     1999 
     2000        attrHandle: {}, 
     2001 
     2002        find: {}, 
     2003 
     2004        relative: { 
     2005                ">": { dir: "parentNode", first: true }, 
     2006                " ": { dir: "parentNode" }, 
     2007                "+": { dir: "previousSibling", first: true }, 
     2008                "~": { dir: "previousSibling" } 
     2009        }, 
     2010 
     2011        preFilter: { 
     2012                "ATTR": function( match ) { 
     2013                        match[1] = match[1].replace( runescape, funescape ); 
     2014 
     2015                        // Move the given value to match[3] whether quoted or unquoted 
     2016                        match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape ); 
     2017 
     2018                        if ( match[2] === "~=" ) { 
     2019                                match[3] = " " + match[3] + " "; 
     2020                        } 
     2021 
     2022                        return match.slice( 0, 4 ); 
     2023                }, 
     2024 
     2025                "CHILD": function( match ) { 
     2026                        /* matches from matchExpr["CHILD"] 
     2027                                1 type (only|nth|...) 
     2028                                2 what (child|of-type) 
     2029                                3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 
     2030                                4 xn-component of xn+y argument ([+-]?\d*n|) 
     2031                                5 sign of xn-component 
     2032                                6 x of xn-component 
     2033                                7 sign of y-component 
     2034                                8 y of y-component 
     2035                        */ 
     2036                        match[1] = match[1].toLowerCase(); 
     2037 
     2038                        if ( match[1].slice( 0, 3 ) === "nth" ) { 
     2039                                // nth-* requires argument 
     2040                                if ( !match[3] ) { 
     2041                                        Sizzle.error( match[0] ); 
     2042                                } 
     2043 
     2044                                // numeric x and y parameters for Expr.filter.CHILD 
     2045                                // remember that false/true cast respectively to 0/1 
     2046                                match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) ); 
     2047                                match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" ); 
     2048 
     2049                        // other types prohibit arguments 
     2050                        } else if ( match[3] ) { 
     2051                                Sizzle.error( match[0] ); 
     2052                        } 
     2053 
     2054                        return match; 
     2055                }, 
     2056 
     2057                "PSEUDO": function( match ) { 
     2058                        var excess, 
     2059                                unquoted = !match[5] && match[2]; 
     2060 
     2061                        if ( matchExpr["CHILD"].test( match[0] ) ) { 
     2062                                return null; 
     2063                        } 
     2064 
     2065                        // Accept quoted arguments as-is 
     2066                        if ( match[3] && match[4] !== undefined ) { 
     2067                                match[2] = match[4]; 
     2068 
     2069                        // Strip excess characters from unquoted arguments 
     2070                        } else if ( unquoted && rpseudo.test( unquoted ) && 
     2071                                // Get excess from tokenize (recursively) 
     2072                                (excess = tokenize( unquoted, true )) && 
     2073                                // advance to the next closing parenthesis 
     2074                                (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) { 
     2075 
     2076                                // excess is a negative index 
     2077                                match[0] = match[0].slice( 0, excess ); 
     2078                                match[2] = unquoted.slice( 0, excess ); 
     2079                        } 
     2080 
     2081                        // Return only captures needed by the pseudo filter method (type and argument) 
     2082                        return match.slice( 0, 3 ); 
     2083                } 
     2084        }, 
     2085 
     2086        filter: { 
     2087 
     2088                "TAG": function( nodeNameSelector ) { 
     2089                        var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); 
     2090                        return nodeNameSelector === "*" ? 
     2091                                function() { return true; } : 
     2092                                function( elem ) { 
     2093                                        return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; 
     2094                                }; 
     2095                }, 
     2096 
     2097                "CLASS": function( className ) { 
     2098                        var pattern = classCache[ className + " " ]; 
     2099 
     2100                        return pattern || 
     2101                                (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) && 
     2102                                classCache( className, function( elem ) { 
     2103                                        return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute("class") || "" ); 
     2104                                }); 
     2105                }, 
     2106 
     2107                "ATTR": function( name, operator, check ) { 
     2108                        return function( elem ) { 
     2109                                var result = Sizzle.attr( elem, name ); 
     2110 
     2111                                if ( result == null ) { 
     2112                                        return operator === "!="; 
     2113                                } 
     2114                                if ( !operator ) { 
     2115                                        return true; 
     2116                                } 
     2117 
     2118                                result += ""; 
     2119 
     2120                                return operator === "=" ? result === check : 
     2121                                        operator === "!=" ? result !== check : 
     2122                                        operator === "^=" ? check && result.indexOf( check ) === 0 : 
     2123                                        operator === "*=" ? check && result.indexOf( check ) > -1 : 
     2124                                        operator === "$=" ? check && result.slice( -check.length ) === check : 
     2125                                        operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 : 
     2126                                        operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" : 
     2127                                        false; 
     2128                        }; 
     2129                }, 
     2130 
     2131                "CHILD": function( type, what, argument, first, last ) { 
     2132                        var simple = type.slice( 0, 3 ) !== "nth", 
     2133                                forward = type.slice( -4 ) !== "last", 
     2134                                ofType = what === "of-type"; 
     2135 
     2136                        return first === 1 && last === 0 ? 
     2137 
     2138                                // Shortcut for :nth-*(n) 
     2139                                function( elem ) { 
     2140                                        return !!elem.parentNode; 
     2141                                } : 
     2142 
     2143                                function( elem, context, xml ) { 
     2144                                        var cache, outerCache, node, diff, nodeIndex, start, 
     2145                                                dir = simple !== forward ? "nextSibling" : "previousSibling", 
     2146                                                parent = elem.parentNode, 
     2147                                                name = ofType && elem.nodeName.toLowerCase(), 
     2148                                                useCache = !xml && !ofType; 
     2149 
     2150                                        if ( parent ) { 
     2151 
     2152                                                // :(first|last|only)-(child|of-type) 
     2153                                                if ( simple ) { 
     2154                                                        while ( dir ) { 
     2155                                                                node = elem; 
     2156                                                                while ( (node = node[ dir ]) ) { 
     2157                                                                        if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) { 
     2158                                                                                return false; 
     2159                                                                        } 
     2160                                                                } 
     2161                                                                // Reverse direction for :only-* (if we haven't yet done so) 
     2162                                                                start = dir = type === "only" && !start && "nextSibling"; 
     2163                                                        } 
     2164                                                        return true; 
     2165                                                } 
     2166 
     2167                                                start = [ forward ? parent.firstChild : parent.lastChild ]; 
     2168 
     2169                                                // non-xml :nth-child(...) stores cache data on `parent` 
     2170                                                if ( forward && useCache ) { 
     2171                                                        // Seek `elem` from a previously-cached index 
     2172                                                        outerCache = parent[ expando ] || (parent[ expando ] = {}); 
     2173                                                        cache = outerCache[ type ] || []; 
     2174                                                        nodeIndex = cache[0] === dirruns && cache[1]; 
     2175                                                        diff = cache[0] === dirruns && cache[2]; 
     2176                                                        node = nodeIndex && parent.childNodes[ nodeIndex ]; 
     2177 
     2178                                                        while ( (node = ++nodeIndex && node && node[ dir ] || 
     2179 
     2180                                                                // Fallback to seeking `elem` from the start 
     2181                                                                (diff = nodeIndex = 0) || start.pop()) ) { 
     2182 
     2183                                                                // When found, cache indexes on `parent` and break 
     2184                                                                if ( node.nodeType === 1 && ++diff && node === elem ) { 
     2185                                                                        outerCache[ type ] = [ dirruns, nodeIndex, diff ]; 
     2186                                                                        break; 
     2187                                                                } 
     2188                                                        } 
     2189 
     2190                                                // Use previously-cached element index if available 
     2191                                                } else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) { 
     2192                                                        diff = cache[1]; 
     2193 
     2194                                                // xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...) 
     2195                                                } else { 
     2196                                                        // Use the same loop as above to seek `elem` from the start 
     2197                                                        while ( (node = ++nodeIndex && node && node[ dir ] || 
     2198                                                                (diff = nodeIndex = 0) || start.pop()) ) { 
     2199 
     2200                                                                if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) { 
     2201                                                                        // Cache the index of each encountered element 
     2202                                                                        if ( useCache ) { 
     2203                                                                                (node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ]; 
     2204                                                                        } 
     2205 
     2206                                                                        if ( node === elem ) { 
     2207                                                                                break; 
     2208                                                                        } 
     2209                                                                } 
     2210                                                        } 
     2211                                                } 
     2212 
     2213                                                // Incorporate the offset, then check against cycle size 
     2214                                                diff -= last; 
     2215                                                return diff === first || ( diff % first === 0 && diff / first >= 0 ); 
     2216                                        } 
     2217                                }; 
     2218                }, 
     2219 
     2220                "PSEUDO": function( pseudo, argument ) { 
     2221                        // pseudo-class names are case-insensitive 
     2222                        // http://www.w3.org/TR/selectors/#pseudo-classes 
     2223                        // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters 
     2224                        // Remember that setFilters inherits from pseudos 
     2225                        var args, 
     2226                                fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || 
     2227                                        Sizzle.error( "unsupported pseudo: " + pseudo ); 
     2228 
     2229                        // The user may use createPseudo to indicate that 
     2230                        // arguments are needed to create the filter function 
     2231                        // just as Sizzle does 
     2232                        if ( fn[ expando ] ) { 
     2233                                return fn( argument ); 
     2234                        } 
     2235 
     2236                        // But maintain support for old signatures 
     2237                        if ( fn.length > 1 ) { 
     2238                                args = [ pseudo, pseudo, "", argument ]; 
     2239                                return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? 
     2240                                        markFunction(function( seed, matches ) { 
     2241                                                var idx, 
     2242                                                        matched = fn( seed, argument ), 
     2243                                                        i = matched.length; 
     2244                                                while ( i-- ) { 
     2245                                                        idx = indexOf.call( seed, matched[i] ); 
     2246                                                        seed[ idx ] = !( matches[ idx ] = matched[i] ); 
     2247                                                } 
     2248                                        }) : 
     2249                                        function( elem ) { 
     2250                                                return fn( elem, 0, args ); 
     2251                                        }; 
     2252                        } 
     2253 
     2254                        return fn; 
     2255                } 
     2256        }, 
     2257 
     2258        pseudos: { 
     2259                // Potentially complex pseudos 
     2260                "not": markFunction(function( selector ) { 
     2261                        // Trim the selector passed to compile 
     2262                        // to avoid treating leading and trailing 
     2263                        // spaces as combinators 
     2264                        var input = [], 
     2265                                results = [], 
     2266                                matcher = compile( selector.replace( rtrim, "$1" ) ); 
     2267 
     2268                        return matcher[ expando ] ? 
     2269                                markFunction(function( seed, matches, context, xml ) { 
     2270                                        var elem, 
     2271                                                unmatched = matcher( seed, null, xml, [] ), 
     2272                                                i = seed.length; 
     2273 
     2274                                        // Match elements unmatched by `matcher` 
     2275                                        while ( i-- ) { 
     2276                                                if ( (elem = unmatched[i]) ) { 
     2277                                                        seed[i] = !(matches[i] = elem); 
     2278                                                } 
     2279                                        } 
     2280                                }) : 
     2281                                function( elem, context, xml ) { 
     2282                                        input[0] = elem; 
     2283                                        matcher( input, null, xml, results ); 
     2284                                        return !results.pop(); 
     2285                                }; 
     2286                }), 
     2287 
     2288                "has": markFunction(function( selector ) { 
     2289                        return function( elem ) { 
     2290                                return Sizzle( selector, elem ).length > 0; 
     2291                        }; 
     2292                }), 
     2293 
     2294                "contains": markFunction(function( text ) { 
     2295                        return function( elem ) { 
     2296                                return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1; 
     2297                        }; 
     2298                }), 
     2299 
     2300                // "Whether an element is represented by a :lang() selector 
     2301                // is based solely on the element's language value 
     2302                // being equal to the identifier C, 
     2303                // or beginning with the identifier C immediately followed by "-". 
     2304                // The matching of C against the element's language value is performed case-insensitively. 
     2305                // The identifier C does not have to be a valid language name." 
     2306                // http://www.w3.org/TR/selectors/#lang-pseudo 
     2307                "lang": markFunction( function( lang ) { 
     2308                        // lang value must be a valid identifier 
     2309                        if ( !ridentifier.test(lang || "") ) { 
     2310                                Sizzle.error( "unsupported lang: " + lang ); 
     2311                        } 
     2312                        lang = lang.replace( runescape, funescape ).toLowerCase(); 
     2313                        return function( elem ) { 
     2314                                var elemLang; 
     2315                                do { 
     2316                                        if ( (elemLang = documentIsHTML ? 
     2317                                                elem.lang : 
     2318                                                elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) { 
     2319 
     2320                                                elemLang = elemLang.toLowerCase(); 
     2321                                                return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; 
     2322                                        } 
     2323                                } while ( (elem = elem.parentNode) && elem.nodeType === 1 ); 
     2324                                return false; 
     2325                        }; 
     2326                }), 
     2327 
     2328                // Miscellaneous 
     2329                "target": function( elem ) { 
     2330                        var hash = window.location && window.location.hash; 
     2331                        return hash && hash.slice( 1 ) === elem.id; 
     2332                }, 
     2333 
     2334                "root": function( elem ) { 
     2335                        return elem === docElem; 
     2336                }, 
     2337 
     2338                "focus": function( elem ) { 
     2339                        return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex); 
     2340                }, 
     2341 
     2342                // Boolean properties 
     2343                "enabled": function( elem ) { 
     2344                        return elem.disabled === false; 
     2345                }, 
     2346 
     2347                "disabled": function( elem ) { 
     2348                        return elem.disabled === true; 
     2349                }, 
     2350 
     2351                "checked": function( elem ) { 
     2352                        // In CSS3, :checked should return both checked and selected elements 
     2353                        // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked 
     2354                        var nodeName = elem.nodeName.toLowerCase(); 
     2355                        return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected); 
     2356                }, 
     2357 
     2358                "selected": function( elem ) { 
     2359                        // Accessing this property makes selected-by-default 
     2360                        // options in Safari work properly 
     2361                        if ( elem.parentNode ) { 
     2362                                elem.parentNode.selectedIndex; 
     2363                        } 
     2364 
     2365                        return elem.selected === true; 
     2366                }, 
     2367 
     2368                // Contents 
     2369                "empty": function( elem ) { 
     2370                        // http://www.w3.org/TR/selectors/#empty-pseudo 
     2371                        // :empty is only affected by element nodes and content nodes(including text(3), cdata(4)), 
     2372                        //   not comment, processing instructions, or others 
     2373                        // Thanks to Diego Perini for the nodeName shortcut 
     2374                        //   Greater than "@" means alpha characters (specifically not starting with "#" or "?") 
     2375                        for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { 
     2376                                if ( elem.nodeName > "@" || elem.nodeType === 3 || elem.nodeType === 4 ) { 
     2377                                        return false; 
     2378                                } 
     2379                        } 
     2380                        return true; 
     2381                }, 
     2382 
     2383                "parent": function( elem ) { 
     2384                        return !Expr.pseudos["empty"]( elem ); 
     2385                }, 
     2386 
     2387                // Element/input types 
     2388                "header": function( elem ) { 
     2389                        return rheader.test( elem.nodeName ); 
     2390                }, 
     2391 
     2392                "input": function( elem ) { 
     2393                        return rinputs.test( elem.nodeName ); 
     2394                }, 
     2395 
     2396                "button": function( elem ) { 
     2397                        var name = elem.nodeName.toLowerCase(); 
     2398                        return name === "input" && elem.type === "button" || name === "button"; 
     2399                }, 
     2400 
     2401                "text": function( elem ) { 
     2402                        var attr; 
     2403                        // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc) 
     2404                        // use getAttribute instead to test this case 
     2405                        return elem.nodeName.toLowerCase() === "input" && 
     2406                                elem.type === "text" && 
     2407                                ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === elem.type ); 
     2408                }, 
     2409 
     2410                // Position-in-collection 
     2411                "first": createPositionalPseudo(function() { 
     2412                        return [ 0 ]; 
     2413                }), 
     2414 
     2415                "last": createPositionalPseudo(function( matchIndexes, length ) { 
     2416                        return [ length - 1 ]; 
     2417                }), 
     2418 
     2419                "eq": createPositionalPseudo(function( matchIndexes, length, argument ) { 
     2420                        return [ argument < 0 ? argument + length : argument ]; 
     2421                }), 
     2422 
     2423                "even": createPositionalPseudo(function( matchIndexes, length ) { 
     2424                        var i = 0; 
     2425                        for ( ; i < length; i += 2 ) { 
     2426                                matchIndexes.push( i ); 
     2427                        } 
     2428                        return matchIndexes; 
     2429                }), 
     2430 
     2431                "odd": createPositionalPseudo(function( matchIndexes, length ) { 
     2432                        var i = 1; 
     2433                        for ( ; i < length; i += 2 ) { 
     2434                                matchIndexes.push( i ); 
     2435                        } 
     2436                        return matchIndexes; 
     2437                }), 
     2438 
     2439                "lt": createPositionalPseudo(function( matchIndexes, length, argument ) { 
     2440                        var i = argument < 0 ? argument + length : argument; 
     2441                        for ( ; --i >= 0; ) { 
     2442                                matchIndexes.push( i ); 
     2443                        } 
     2444                        return matchIndexes; 
     2445                }), 
     2446 
     2447                "gt": createPositionalPseudo(function( matchIndexes, length, argument ) { 
     2448                        var i = argument < 0 ? argument + length : argument; 
     2449                        for ( ; ++i < length; ) { 
     2450                                matchIndexes.push( i ); 
     2451                        } 
     2452                        return matchIndexes; 
     2453                }) 
     2454        } 
     2455}; 
     2456 
     2457// Add button/input type pseudos 
     2458for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { 
     2459        Expr.pseudos[ i ] = createInputPseudo( i ); 
     2460} 
     2461for ( i in { submit: true, reset: true } ) { 
     2462        Expr.pseudos[ i ] = createButtonPseudo( i ); 
     2463} 
     2464 
     2465function tokenize( selector, parseOnly ) { 
     2466        var matched, match, tokens, type, 
     2467                soFar, groups, preFilters, 
     2468                cached = tokenCache[ selector + " " ]; 
     2469 
     2470        if ( cached ) { 
     2471                return parseOnly ? 0 : cached.slice( 0 ); 
     2472        } 
     2473 
     2474        soFar = selector; 
     2475        groups = []; 
     2476        preFilters = Expr.preFilter; 
     2477 
     2478        while ( soFar ) { 
     2479 
     2480                // Comma and first run 
     2481                if ( !matched || (match = rcomma.exec( soFar )) ) { 
     2482                        if ( match ) { 
     2483                                // Don't consume trailing commas as valid 
     2484                                soFar = soFar.slice( match[0].length ) || soFar; 
     2485                        } 
     2486                        groups.push( tokens = [] ); 
     2487                } 
     2488 
     2489                matched = false; 
     2490 
     2491                // Combinators 
     2492                if ( (match = rcombinators.exec( soFar )) ) { 
     2493                        matched = match.shift(); 
     2494                        tokens.push({ 
     2495                                value: matched, 
     2496                                // Cast descendant combinators to space 
     2497                                type: match[0].replace( rtrim, " " ) 
     2498                        }); 
     2499                        soFar = soFar.slice( matched.length ); 
     2500                } 
     2501 
     2502                // Filters 
     2503                for ( type in Expr.filter ) { 
     2504                        if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] || 
     2505                                (match = preFilters[ type ]( match ))) ) { 
     2506                                matched = match.shift(); 
     2507                                tokens.push({ 
     2508                                        value: matched, 
     2509                                        type: type, 
     2510                                        matches: match 
     2511                                }); 
     2512                                soFar = soFar.slice( matched.length ); 
     2513                        } 
     2514                } 
     2515 
     2516                if ( !matched ) { 
     2517                        break; 
     2518                } 
     2519        } 
     2520 
     2521        // Return the length of the invalid excess 
     2522        // if we're just parsing 
     2523        // Otherwise, throw an error or return tokens 
     2524        return parseOnly ? 
     2525                soFar.length : 
     2526                soFar ? 
     2527                        Sizzle.error( selector ) : 
     2528                        // Cache the tokens 
     2529                        tokenCache( selector, groups ).slice( 0 ); 
     2530} 
     2531 
     2532function toSelector( tokens ) { 
     2533        var i = 0, 
     2534                len = tokens.length, 
     2535                selector = ""; 
     2536        for ( ; i < len; i++ ) { 
     2537                selector += tokens[i].value; 
     2538        } 
     2539        return selector; 
     2540} 
     2541 
     2542function addCombinator( matcher, combinator, base ) { 
     2543        var dir = combinator.dir, 
     2544                checkNonElements = base && dir === "parentNode", 
     2545                doneName = done++; 
     2546 
     2547        return combinator.first ? 
     2548                // Check against closest ancestor/preceding element 
     2549                function( elem, context, xml ) { 
     2550                        while ( (elem = elem[ dir ]) ) { 
     2551                                if ( elem.nodeType === 1 || checkNonElements ) { 
     2552                                        return matcher( elem, context, xml ); 
     2553                                } 
     2554                        } 
     2555                } : 
     2556 
     2557                // Check against all ancestor/preceding elements 
     2558                function( elem, context, xml ) { 
     2559                        var data, cache, outerCache, 
     2560                                dirkey = dirruns + " " + doneName; 
     2561 
     2562                        // We can't set arbitrary data on XML nodes, so they don't benefit from dir caching 
     2563                        if ( xml ) { 
     2564                                while ( (elem = elem[ dir ]) ) { 
     2565                                        if ( elem.nodeType === 1 || checkNonElements ) { 
     2566                                                if ( matcher( elem, context, xml ) ) { 
     2567                                                        return true; 
     2568                                                } 
     2569                                        } 
     2570                                } 
     2571                        } else { 
     2572                                while ( (elem = elem[ dir ]) ) { 
     2573                                        if ( elem.nodeType === 1 || checkNonElements ) { 
     2574                                                outerCache = elem[ expando ] || (elem[ expando ] = {}); 
     2575                                                if ( (cache = outerCache[ dir ]) && cache[0] === dirkey ) { 
     2576                                                        if ( (data = cache[1]) === true || data === cachedruns ) { 
     2577                                                                return data === true; 
     2578                                                        } 
     2579                                                } else { 
     2580                                                        cache = outerCache[ dir ] = [ dirkey ]; 
     2581                                                        cache[1] = matcher( elem, context, xml ) || cachedruns; 
     2582                                                        if ( cache[1] === true ) { 
     2583                                                                return true; 
     2584                                                        } 
     2585                                                } 
     2586                                        } 
     2587                                } 
     2588                        } 
     2589                }; 
     2590} 
     2591 
     2592function elementMatcher( matchers ) { 
     2593        return matchers.length > 1 ? 
     2594                function( elem, context, xml ) { 
     2595                        var i = matchers.length; 
     2596                        while ( i-- ) { 
     2597                                if ( !matchers[i]( elem, context, xml ) ) { 
     2598                                        return false; 
     2599                                } 
     2600                        } 
     2601                        return true; 
     2602                } : 
     2603                matchers[0]; 
     2604} 
     2605 
     2606function condense( unmatched, map, filter, context, xml ) { 
     2607        var elem, 
     2608                newUnmatched = [], 
     2609                i = 0, 
     2610                len = unmatched.length, 
     2611                mapped = map != null; 
     2612 
     2613        for ( ; i < len; i++ ) { 
     2614                if ( (elem = unmatched[i]) ) { 
     2615                        if ( !filter || filter( elem, context, xml ) ) { 
     2616                                newUnmatched.push( elem ); 
     2617                                if ( mapped ) { 
     2618                                        map.push( i ); 
     2619                                } 
     2620                        } 
     2621                } 
     2622        } 
     2623 
     2624        return newUnmatched; 
     2625} 
     2626 
     2627function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { 
     2628        if ( postFilter && !postFilter[ expando ] ) { 
     2629                postFilter = setMatcher( postFilter ); 
     2630        } 
     2631        if ( postFinder && !postFinder[ expando ] ) { 
     2632                postFinder = setMatcher( postFinder, postSelector ); 
     2633        } 
     2634        return markFunction(function( seed, results, context, xml ) { 
     2635                var temp, i, elem, 
     2636                        preMap = [], 
     2637                        postMap = [], 
     2638                        preexisting = results.length, 
     2639 
     2640                        // Get initial elements from seed or context 
     2641                        elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ), 
     2642 
     2643                        // Prefilter to get matcher input, preserving a map for seed-results synchronization 
     2644                        matcherIn = preFilter && ( seed || !selector ) ? 
     2645                                condense( elems, preMap, preFilter, context, xml ) : 
     2646                                elems, 
     2647 
     2648                        matcherOut = matcher ? 
     2649                                // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, 
     2650                                postFinder || ( seed ? preFilter : preexisting || postFilter ) ? 
     2651 
     2652                                        // ...intermediate processing is necessary 
     2653                                        [] : 
     2654 
     2655                                        // ...otherwise use results directly 
     2656                                        results : 
     2657                                matcherIn; 
     2658 
     2659                // Find primary matches 
     2660                if ( matcher ) { 
     2661                        matcher( matcherIn, matcherOut, context, xml ); 
     2662                } 
     2663 
     2664                // Apply postFilter 
     2665                if ( postFilter ) { 
     2666                        temp = condense( matcherOut, postMap ); 
     2667                        postFilter( temp, [], context, xml ); 
     2668 
     2669                        // Un-match failing elements by moving them back to matcherIn 
     2670                        i = temp.length; 
     2671                        while ( i-- ) { 
     2672                                if ( (elem = temp[i]) ) { 
     2673                                        matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem); 
     2674                                } 
     2675                        } 
     2676                } 
     2677 
     2678                if ( seed ) { 
     2679                        if ( postFinder || preFilter ) { 
     2680                                if ( postFinder ) { 
     2681                                        // Get the final matcherOut by condensing this intermediate into postFinder contexts 
     2682                                        temp = []; 
     2683                                        i = matcherOut.length; 
     2684                                        while ( i-- ) { 
     2685                                                if ( (elem = matcherOut[i]) ) { 
     2686                                                        // Restore matcherIn since elem is not yet a final match 
     2687                                                        temp.push( (matcherIn[i] = elem) ); 
     2688                                                } 
     2689                                        } 
     2690                                        postFinder( null, (matcherOut = []), temp, xml ); 
     2691                                } 
     2692 
     2693                                // Move matched elements from seed to results to keep them synchronized 
     2694                                i = matcherOut.length; 
     2695                                while ( i-- ) { 
     2696                                        if ( (elem = matcherOut[i]) && 
     2697                                                (temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) { 
     2698 
     2699                                                seed[temp] = !(results[temp] = elem); 
     2700                                        } 
     2701                                } 
     2702                        } 
     2703 
     2704                // Add elements to results, through postFinder if defined 
     2705                } else { 
     2706                        matcherOut = condense( 
     2707                                matcherOut === results ? 
     2708                                        matcherOut.splice( preexisting, matcherOut.length ) : 
     2709                                        matcherOut 
     2710                        ); 
     2711                        if ( postFinder ) { 
     2712                                postFinder( null, results, matcherOut, xml ); 
     2713                        } else { 
     2714                                push.apply( results, matcherOut ); 
     2715                        } 
     2716                } 
     2717        }); 
     2718} 
     2719 
     2720function matcherFromTokens( tokens ) { 
     2721        var checkContext, matcher, j, 
     2722                len = tokens.length, 
     2723                leadingRelative = Expr.relative[ tokens[0].type ], 
     2724                implicitRelative = leadingRelative || Expr.relative[" "], 
     2725                i = leadingRelative ? 1 : 0, 
     2726 
     2727                // The foundational matcher ensures that elements are reachable from top-level context(s) 
     2728                matchContext = addCombinator( function( elem ) { 
     2729                        return elem === checkContext; 
     2730                }, implicitRelative, true ), 
     2731                matchAnyContext = addCombinator( function( elem ) { 
     2732                        return indexOf.call( checkContext, elem ) > -1; 
     2733                }, implicitRelative, true ), 
     2734                matchers = [ function( elem, context, xml ) { 
     2735                        return ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( 
     2736                                (checkContext = context).nodeType ? 
     2737                                        matchContext( elem, context, xml ) : 
     2738                                        matchAnyContext( elem, context, xml ) ); 
     2739                } ]; 
     2740 
     2741        for ( ; i < len; i++ ) { 
     2742                if ( (matcher = Expr.relative[ tokens[i].type ]) ) { 
     2743                        matchers = [ addCombinator(elementMatcher( matchers ), matcher) ]; 
     2744                } else { 
     2745                        matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches ); 
     2746 
     2747                        // Return special upon seeing a positional matcher 
     2748                        if ( matcher[ expando ] ) { 
     2749                                // Find the next relative operator (if any) for proper handling 
     2750                                j = ++i; 
     2751                                for ( ; j < len; j++ ) { 
     2752                                        if ( Expr.relative[ tokens[j].type ] ) { 
     2753                                                break; 
     2754                                        } 
     2755                                } 
     2756                                return setMatcher( 
     2757                                        i > 1 && elementMatcher( matchers ), 
     2758                                        i > 1 && toSelector( 
     2759                                                // If the preceding token was a descendant combinator, insert an implicit any-element `*` 
     2760                                                tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" }) 
     2761                                        ).replace( rtrim, "$1" ), 
     2762                                        matcher, 
     2763                                        i < j && matcherFromTokens( tokens.slice( i, j ) ), 
     2764                                        j < len && matcherFromTokens( (tokens = tokens.slice( j )) ), 
     2765                                        j < len && toSelector( tokens ) 
     2766                                ); 
     2767                        } 
     2768                        matchers.push( matcher ); 
     2769                } 
     2770        } 
     2771 
     2772        return elementMatcher( matchers ); 
     2773} 
     2774 
     2775function matcherFromGroupMatchers( elementMatchers, setMatchers ) { 
     2776        // A counter to specify which element is currently being matched 
     2777        var matcherCachedRuns = 0, 
     2778                bySet = setMatchers.length > 0, 
     2779                byElement = elementMatchers.length > 0, 
     2780                superMatcher = function( seed, context, xml, results, expandContext ) { 
     2781                        var elem, j, matcher, 
     2782                                setMatched = [], 
     2783                                matchedCount = 0, 
     2784                                i = "0", 
     2785                                unmatched = seed && [], 
     2786                                outermost = expandContext != null, 
     2787                                contextBackup = outermostContext, 
     2788                                // We must always have either seed elements or context 
     2789                                elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ), 
     2790                                // Use integer dirruns iff this is the outermost matcher 
     2791                                dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1); 
     2792 
     2793                        if ( outermost ) { 
     2794                                outermostContext = context !== document && context; 
     2795                                cachedruns = matcherCachedRuns; 
     2796                        } 
     2797 
     2798                        // Add elements passing elementMatchers directly to results 
     2799                        // Keep `i` a string if there are no elements so `matchedCount` will be "00" below 
     2800                        for ( ; (elem = elems[i]) != null; i++ ) { 
     2801                                if ( byElement && elem ) { 
     2802                                        j = 0; 
     2803                                        while ( (matcher = elementMatchers[j++]) ) { 
     2804                                                if ( matcher( elem, context, xml ) ) { 
     2805                                                        results.push( elem ); 
     2806                                                        break; 
     2807                                                } 
     2808                                        } 
     2809                                        if ( outermost ) { 
     2810                                                dirruns = dirrunsUnique; 
     2811                                                cachedruns = ++matcherCachedRuns; 
     2812                                        } 
     2813                                } 
     2814 
     2815                                // Track unmatched elements for set filters 
     2816                                if ( bySet ) { 
     2817                                        // They will have gone through all possible matchers 
     2818                                        if ( (elem = !matcher && elem) ) { 
     2819                                                matchedCount--; 
     2820                                        } 
     2821 
     2822                                        // Lengthen the array for every element, matched or not 
     2823                                        if ( seed ) { 
     2824                                                unmatched.push( elem ); 
     2825                                        } 
     2826                                } 
     2827                        } 
     2828 
     2829                        // Apply set filters to unmatched elements 
     2830                        matchedCount += i; 
     2831                        if ( bySet && i !== matchedCount ) { 
     2832                                j = 0; 
     2833                                while ( (matcher = setMatchers[j++]) ) { 
     2834                                        matcher( unmatched, setMatched, context, xml ); 
     2835                                } 
     2836 
     2837                                if ( seed ) { 
     2838                                        // Reintegrate element matches to eliminate the need for sorting 
     2839                                        if ( matchedCount > 0 ) { 
     2840                                                while ( i-- ) { 
     2841                                                        if ( !(unmatched[i] || setMatched[i]) ) { 
     2842                                                                setMatched[i] = pop.call( results ); 
     2843                                                        } 
     2844                                                } 
     2845                                        } 
     2846 
     2847                                        // Discard index placeholder values to get only actual matches 
     2848                                        setMatched = condense( setMatched ); 
     2849                                } 
     2850 
     2851                                // Add matches to results 
     2852                                push.apply( results, setMatched ); 
     2853 
     2854                                // Seedless set matches succeeding multiple successful matchers stipulate sorting 
     2855                                if ( outermost && !seed && setMatched.length > 0 && 
     2856                                        ( matchedCount + setMatchers.length ) > 1 ) { 
     2857 
     2858                                        Sizzle.uniqueSort( results ); 
     2859                                } 
     2860                        } 
     2861 
     2862                        // Override manipulation of globals by nested matchers 
     2863                        if ( outermost ) { 
     2864                                dirruns = dirrunsUnique; 
     2865                                outermostContext = contextBackup; 
     2866                        } 
     2867 
     2868                        return unmatched; 
     2869                }; 
     2870 
     2871        return bySet ? 
     2872                markFunction( superMatcher ) : 
     2873                superMatcher; 
     2874} 
     2875 
     2876compile = Sizzle.compile = function( selector, group /* Internal Use Only */ ) { 
     2877        var i, 
     2878                setMatchers = [], 
     2879                elementMatchers = [], 
     2880                cached = compilerCache[ selector + " " ]; 
     2881 
     2882        if ( !cached ) { 
     2883                // Generate a function of recursive functions that can be used to check each element 
     2884                if ( !group ) { 
     2885                        group = tokenize( selector ); 
     2886                } 
     2887                i = group.length; 
     2888                while ( i-- ) { 
     2889                        cached = matcherFromTokens( group[i] ); 
     2890                        if ( cached[ expando ] ) { 
     2891                                setMatchers.push( cached ); 
     2892                        } else { 
     2893                                elementMatchers.push( cached ); 
     2894                        } 
     2895                } 
     2896 
     2897                // Cache the compiled function 
     2898                cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) ); 
     2899        } 
     2900        return cached; 
     2901}; 
     2902 
     2903function multipleContexts( selector, contexts, results ) { 
     2904        var i = 0, 
     2905                len = contexts.length; 
     2906        for ( ; i < len; i++ ) { 
     2907                Sizzle( selector, contexts[i], results ); 
     2908        } 
     2909        return results; 
     2910} 
     2911 
     2912function select( selector, context, results, seed ) { 
     2913        var i, tokens, token, type, find, 
     2914                match = tokenize( selector ); 
     2915 
     2916        if ( !seed ) { 
     2917                // Try to minimize operations if there is only one group 
     2918                if ( match.length === 1 ) { 
     2919 
     2920                        // Take a shortcut and set the context if the root selector is an ID 
     2921                        tokens = match[0] = match[0].slice( 0 ); 
     2922                        if ( tokens.length > 2 && (token = tokens[0]).type === "ID" && 
     2923                                        support.getById && context.nodeType === 9 && documentIsHTML && 
     2924                                        Expr.relative[ tokens[1].type ] ) { 
     2925 
     2926                                context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0]; 
     2927                                if ( !context ) { 
     2928                                        return results; 
     2929                                } 
     2930                                selector = selector.slice( tokens.shift().value.length ); 
     2931                        } 
     2932 
     2933                        // Fetch a seed set for right-to-left matching 
     2934                        i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length; 
     2935                        while ( i-- ) { 
     2936                                token = tokens[i]; 
     2937 
     2938                                // Abort if we hit a combinator 
     2939                                if ( Expr.relative[ (type = token.type) ] ) { 
     2940                                        break; 
     2941                                } 
     2942                                if ( (find = Expr.find[ type ]) ) { 
     2943                                        // Search, expanding context for leading sibling combinators 
     2944                                        if ( (seed = find( 
     2945                                                token.matches[0].replace( runescape, funescape ), 
     2946                                                rsibling.test( tokens[0].type ) && context.parentNode || context 
     2947                                        )) ) { 
     2948 
     2949                                                // If seed is empty or no tokens remain, we can return early 
     2950                                                tokens.splice( i, 1 ); 
     2951                                                selector = seed.length && toSelector( tokens ); 
     2952                                                if ( !selector ) { 
     2953                                                        push.apply( results, seed ); 
     2954                                                        return results; 
     2955                                                } 
     2956 
     2957                                                break; 
     2958                                        } 
     2959                                } 
     2960                        } 
     2961                } 
     2962        } 
     2963 
     2964        // Compile and execute a filtering function 
     2965        // Provide `match` to avoid retokenization if we modified the selector above 
     2966        compile( selector, match )( 
     2967                seed, 
     2968                context, 
     2969                !documentIsHTML, 
     2970                results, 
     2971                rsibling.test( selector ) 
     2972        ); 
     2973        return results; 
     2974} 
     2975 
     2976// Deprecated 
     2977Expr.pseudos["nth"] = Expr.pseudos["eq"]; 
     2978 
     2979// Easy API for creating new setFilters 
     2980function setFilters() {} 
     2981setFilters.prototype = Expr.filters = Expr.pseudos; 
     2982Expr.setFilters = new setFilters(); 
     2983 
     2984// One-time assignments 
     2985 
     2986// Sort stability 
     2987support.sortStable = expando.split("").sort( sortOrder ).join("") === expando; 
     2988 
     2989// Initialize against the default document 
     2990setDocument(); 
     2991 
     2992// Support: Chrome<<14 
     2993// Always assume duplicates if they aren't passed to the comparison function 
     2994[0, 0].sort( sortOrder ); 
     2995support.detectDuplicates = hasDuplicate; 
     2996 
     2997jQuery.find = Sizzle; 
     2998jQuery.expr = Sizzle.selectors; 
     2999jQuery.expr[":"] = jQuery.expr.pseudos; 
     3000jQuery.unique = Sizzle.uniqueSort; 
     3001jQuery.text = Sizzle.getText; 
     3002jQuery.isXMLDoc = Sizzle.isXML; 
     3003jQuery.contains = Sizzle.contains; 
     3004 
     3005 
     3006})( window ); 
    9703007// String to Object options format cache 
    9713008var optionsCache = {}; 
     
    11153152                        empty: function() { 
    11163153                                list = []; 
     3154                                firingLength = 0; 
    11173155                                return this; 
    11183156                        }, 
     
    13053343        } 
    13063344}); 
    1307 jQuery.support = (function() { 
    1308  
    1309         var support, all, a, 
    1310                 input, select, fragment, 
    1311                 opt, eventName, isSupported, i, 
     3345jQuery.support = (function( support ) { 
     3346 
     3347        var all, a, input, select, fragment, opt, eventName, isSupported, i, 
    13123348                div = document.createElement("div"); 
    13133349 
     
    13163352        div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"; 
    13173353 
    1318         // Support tests won't run in some limited or non-browser environments 
    1319         all = div.getElementsByTagName("*"); 
     3354        // Finish early in limited (non-browser) environments 
     3355        all = div.getElementsByTagName("*") || []; 
    13203356        a = div.getElementsByTagName("a")[ 0 ]; 
    1321         if ( !all || !a || !all.length ) { 
    1322                 return {}; 
     3357        if ( !a || !a.style || !all.length ) { 
     3358                return support; 
    13233359        } 
    13243360 
     
    13293365 
    13303366        a.style.cssText = "top:1px;float:left;opacity:.5"; 
    1331         support = { 
    1332                 // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7) 
    1333                 getSetAttribute: div.className !== "t", 
    1334  
    1335                 // IE strips leading whitespace when .innerHTML is used 
    1336                 leadingWhitespace: div.firstChild.nodeType === 3, 
    1337  
    1338                 // Make sure that tbody elements aren't automatically inserted 
    1339                 // IE will insert them into empty tables 
    1340                 tbody: !div.getElementsByTagName("tbody").length, 
    1341  
    1342                 // Make sure that link elements get serialized correctly by innerHTML 
    1343                 // This requires a wrapper element in IE 
    1344                 htmlSerialize: !!div.getElementsByTagName("link").length, 
    1345  
    1346                 // Get the style information from getAttribute 
    1347                 // (IE uses .cssText instead) 
    1348                 style: /top/.test( a.getAttribute("style") ), 
    1349  
    1350                 // Make sure that URLs aren't manipulated 
    1351                 // (IE normalizes it by default) 
    1352                 hrefNormalized: a.getAttribute("href") === "/a", 
    1353  
    1354                 // Make sure that element opacity exists 
    1355                 // (IE uses filter instead) 
    1356                 // Use a regex to work around a WebKit issue. See #5145 
    1357                 opacity: /^0.5/.test( a.style.opacity ), 
    1358  
    1359                 // Verify style float existence 
    1360                 // (IE uses styleFloat instead of cssFloat) 
    1361                 cssFloat: !!a.style.cssFloat, 
    1362  
    1363                 // Check the default checkbox/radio value ("" on WebKit; "on" elsewhere) 
    1364                 checkOn: !!input.value, 
    1365  
    1366                 // Make sure that a selected-by-default option has a working selected property. 
    1367                 // (WebKit defaults to false instead of true, IE too, if it's in an optgroup) 
    1368                 optSelected: opt.selected, 
    1369  
    1370                 // Tests for enctype support on a form (#6743) 
    1371                 enctype: !!document.createElement("form").enctype, 
    1372  
    1373                 // Makes sure cloning an html5 element does not cause problems 
    1374                 // Where outerHTML is undefined, this still works 
    1375                 html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>", 
    1376  
    1377                 // jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode 
    1378                 boxModel: document.compatMode === "CSS1Compat", 
    1379  
    1380                 // Will be defined later 
    1381                 deleteExpando: true, 
    1382                 noCloneEvent: true, 
    1383                 inlineBlockNeedsLayout: false, 
    1384                 shrinkWrapBlocks: false, 
    1385                 reliableMarginRight: true, 
    1386                 boxSizingReliable: true, 
    1387                 pixelPosition: false 
    1388         }; 
     3367 
     3368        // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7) 
     3369        support.getSetAttribute = div.className !== "t"; 
     3370 
     3371        // IE strips leading whitespace when .innerHTML is used 
     3372        support.leadingWhitespace = div.firstChild.nodeType === 3; 
     3373 
     3374        // Make sure that tbody elements aren't automatically inserted 
     3375        // IE will insert them into empty tables 
     3376        support.tbody = !div.getElementsByTagName("tbody").length; 
     3377 
     3378        // Make sure that link elements get serialized correctly by innerHTML 
     3379        // This requires a wrapper element in IE 
     3380        support.htmlSerialize = !!div.getElementsByTagName("link").length; 
     3381 
     3382        // Get the style information from getAttribute 
     3383        // (IE uses .cssText instead) 
     3384        support.style = /top/.test( a.getAttribute("style") ); 
     3385 
     3386        // Make sure that URLs aren't manipulated 
     3387        // (IE normalizes it by default) 
     3388        support.hrefNormalized = a.getAttribute("href") === "/a"; 
     3389 
     3390        // Make sure that element opacity exists 
     3391        // (IE uses filter instead) 
     3392        // Use a regex to work around a WebKit issue. See #5145 
     3393        support.opacity = /^0.5/.test( a.style.opacity ); 
     3394 
     3395        // Verify style float existence 
     3396        // (IE uses styleFloat instead of cssFloat) 
     3397        support.cssFloat = !!a.style.cssFloat; 
     3398 
     3399        // Check the default checkbox/radio value ("" on WebKit; "on" elsewhere) 
     3400        support.checkOn = !!input.value; 
     3401 
     3402        // Make sure that a selected-by-default option has a working selected property. 
     3403        // (WebKit defaults to false instead of true, IE too, if it's in an optgroup) 
     3404        support.optSelected = opt.selected; 
     3405 
     3406        // Tests for enctype support on a form (#6743) 
     3407        support.enctype = !!document.createElement("form").enctype; 
     3408 
     3409        // Makes sure cloning an html5 element does not cause problems 
     3410        // Where outerHTML is undefined, this still works 
     3411        support.html5Clone = document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>"; 
     3412 
     3413        // Will be defined later 
     3414        support.inlineBlockNeedsLayout = false; 
     3415        support.shrinkWrapBlocks = false; 
     3416        support.pixelPosition = false; 
     3417        support.deleteExpando = true; 
     3418        support.noCloneEvent = true; 
     3419        support.reliableMarginRight = true; 
     3420        support.boxSizingReliable = true; 
    13893421 
    13903422        // Make sure checked status is properly cloned 
     
    14403472 
    14413473        // Support: IE<9 (lack submit/change bubble), Firefox 17+ (lack focusin event) 
    1442         // Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP), test/csp.php 
     3474        // Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP) 
    14433475        for ( i in { submit: true, change: true, focusin: true }) { 
    14443476                div.setAttribute( eventName = "on" + i, "t" ); 
     
    14503482        div.cloneNode( true ).style.backgroundClip = ""; 
    14513483        support.clearCloneStyle = div.style.backgroundClip === "content-box"; 
     3484 
     3485        // Support: IE<9 
     3486        // Iteration over object's inherited properties before its own. 
     3487        for ( i in jQuery( support ) ) { 
     3488                break; 
     3489        } 
     3490        support.ownLast = i !== "0"; 
    14523491 
    14533492        // Run tests that need a body at doc ready 
     
    14863525                support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 ); 
    14873526 
    1488                 // Check box-sizing and margin behavior 
     3527                // Check box-sizing and margin behavior. 
    14893528                div.innerHTML = ""; 
    14903529                div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;"; 
    1491                 support.boxSizing = ( div.offsetWidth === 4 ); 
    1492                 support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 ); 
     3530 
     3531                // Workaround failing boxSizing test due to offsetWidth returning wrong value 
     3532                // with some non-1 values of body zoom, ticket #13543 
     3533                jQuery.swap( body, body.style.zoom != null ? { zoom: 1 } : {}, function() { 
     3534                        support.boxSizing = div.offsetWidth === 4; 
     3535                }); 
    14933536 
    14943537                // Use window.getComputedStyle because jsdom on node.js will break without it. 
     
    15443587 
    15453588        return support; 
    1546 })(); 
     3589})({}); 
    15473590 
    15483591var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/, 
     
    15543597        } 
    15553598 
    1556         var thisCache, ret, 
     3599        var ret, thisCache, 
    15573600                internalKey = jQuery.expando, 
    1558                 getByName = typeof name === "string", 
    15593601 
    15603602                // We have to handle DOM nodes and JS objects differently because IE6-7 
     
    15723614        // Avoid doing any more work than we need to when trying to get data on an 
    15733615        // object that has no data at all 
    1574         if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) { 
     3616        if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && data === undefined && typeof name === "string" ) { 
    15753617                return; 
    15763618        } 
     
    15803622                // ends up in the global cache 
    15813623                if ( isNode ) { 
    1582                         elem[ internalKey ] = id = core_deletedIds.pop() || jQuery.guid++; 
     3624                        id = elem[ internalKey ] = core_deletedIds.pop() || jQuery.guid++; 
    15833625                } else { 
    15843626                        id = internalKey; 
     
    15873629 
    15883630        if ( !cache[ id ] ) { 
    1589                 cache[ id ] = {}; 
    1590  
    1591                 // Avoids exposing jQuery metadata on plain JS objects when the object 
     3631                // Avoid exposing jQuery metadata on plain JS objects when the object 
    15923632                // is serialized using JSON.stringify 
    1593                 if ( !isNode ) { 
    1594                         cache[ id ].toJSON = jQuery.noop; 
    1595                 } 
     3633                cache[ id ] = isNode ? {} : { toJSON: jQuery.noop }; 
    15963634        } 
    15973635 
     
    16253663        // Check for both converted-to-camel and non-converted data property names 
    16263664        // If a data property was specified 
    1627         if ( getByName ) { 
     3665        if ( typeof name === "string" ) { 
    16283666 
    16293667                // First Try to find as-is property data 
     
    16483686        } 
    16493687 
    1650         var i, l, thisCache, 
     3688        var thisCache, i, 
    16513689                isNode = elem.nodeType, 
    16523690 
     
    16933731                        } 
    16943732 
    1695                         for ( i = 0, l = name.length; i < l; i++ ) { 
     3733                        i = name.length; 
     3734                        while ( i-- ) { 
    16963735                                delete thisCache[ name[i] ]; 
    16973736                        } 
     
    16993738                        // If there is no data left in the cache, we want to continue 
    17003739                        // and let the cache object itself get destroyed 
    1701                         if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) { 
     3740                        if ( pvt ? !isEmptyDataObject(thisCache) : !jQuery.isEmptyObject(thisCache) ) { 
    17023741                                return; 
    17033742                        } 
     
    17213760 
    17223761        // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080) 
     3762        /* jshint eqeqeq: false */ 
    17233763        } else if ( jQuery.support.deleteExpando || cache != cache.window ) { 
     3764                /* jshint eqeqeq: true */ 
    17243765                delete cache[ id ]; 
    17253766 
     
    17333774        cache: {}, 
    17343775 
    1735         // Unique for each copy of jQuery on the page 
    1736         // Non-digits removed to match rinlinejQuery 
    1737         expando: "jQuery" + ( core_version + Math.random() ).replace( /\D/g, "" ), 
    1738  
    17393776        // The following elements throw uncatchable exceptions if you 
    17403777        // attempt to add expando properties to them. 
    17413778        noData: { 
     3779                "applet": true, 
    17423780                "embed": true, 
    17433781                // Ban all objects except for Flash (which handle expandos) 
    1744                 "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000", 
    1745                 "applet": true 
     3782                "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" 
    17463783        }, 
    17473784 
     
    17853822        data: function( key, value ) { 
    17863823                var attrs, name, 
    1787                         elem = this[0], 
     3824                        data = null, 
    17883825                        i = 0, 
    1789                         data = null; 
     3826                        elem = this[0]; 
     3827 
     3828                // Special expections of .data basically thwart jQuery.access, 
     3829                // so implement the relevant behavior ourselves 
    17903830 
    17913831                // Gets all values 
     
    17993839                                                name = attrs[i].name; 
    18003840 
    1801                                                 if ( !name.indexOf( "data-" ) ) { 
     3841                                                if ( name.indexOf("data-") === 0 ) { 
    18023842                                                        name = jQuery.camelCase( name.slice(5) ); 
    18033843 
     
    18193859                } 
    18203860 
    1821                 return jQuery.access( this, function( value ) { 
    1822  
    1823                         if ( value === undefined ) { 
    1824                                 // Try to fetch any internally stored data first 
    1825                                 return elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : null; 
    1826                         } 
    1827  
     3861                return arguments.length > 1 ? 
     3862 
     3863                        // Sets one value 
    18283864                        this.each(function() { 
    18293865                                jQuery.data( this, key, value ); 
    1830                         }); 
    1831                 }, null, value, arguments.length > 1, null, true ); 
     3866                        }) : 
     3867 
     3868                        // Gets one value 
     3869                        // Try to fetch any internally stored data first 
     3870                        elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : null; 
    18323871        }, 
    18333872 
     
    19233962                } 
    19243963 
    1925                 hooks.cur = fn; 
    19263964                if ( fn ) { 
    19273965 
     
    20344072}); 
    20354073var nodeHook, boolHook, 
    2036         rclass = /[\t\r\n]/g, 
     4074        rclass = /[\t\r\n\f]/g, 
    20374075        rreturn = /\r/g, 
    20384076        rfocusable = /^(?:input|select|textarea|button|object)$/i, 
    20394077        rclickable = /^(?:a|area)$/i, 
    2040         rboolean = /^(?:checked|selected|autofocus|autoplay|async|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped)$/i, 
    20414078        ruseDefault = /^(?:checked|selected)$/i, 
    20424079        getSetAttribute = jQuery.support.getSetAttribute, 
     
    22274264 
    22284265                return this.each(function( i ) { 
    2229                         var val, 
    2230                                 self = jQuery(this); 
     4266                        var val; 
    22314267 
    22324268                        if ( this.nodeType !== 1 ) { 
     
    22354271 
    22364272                        if ( isFunction ) { 
    2237                                 val = value.call( this, i, self.val() ); 
     4273                                val = value.call( this, i, jQuery( this ).val() ); 
    22384274                        } else { 
    22394275                                val = value; 
     
    22654301                option: { 
    22664302                        get: function( elem ) { 
    2267                                 // attributes.value is undefined in Blackberry 4.7 but 
    2268                                 // uses .value. See #6932 
    2269                                 var val = elem.attributes.value; 
    2270                                 return !val || val.specified ? elem.value : elem.text; 
     4303                                // Use proper attribute retrieval(#6932, #12072) 
     4304                                var val = jQuery.find.attr( elem, "value" ); 
     4305                                return val != null ? 
     4306                                        val : 
     4307                                        elem.text; 
    22714308                        } 
    22724309                }, 
     
    23104347 
    23114348                        set: function( elem, value ) { 
    2312                                 var values = jQuery.makeArray( value ); 
    2313  
    2314                                 jQuery(elem).find("option").each(function() { 
    2315                                         this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0; 
    2316                                 }); 
    2317  
    2318                                 if ( !values.length ) { 
     4349                                var optionSet, option, 
     4350                                        options = elem.options, 
     4351                                        values = jQuery.makeArray( value ), 
     4352                                        i = options.length; 
     4353 
     4354                                while ( i-- ) { 
     4355                                        option = options[ i ]; 
     4356                                        if ( (option.selected = jQuery.inArray( jQuery(option).val(), values ) >= 0) ) { 
     4357                                                optionSet = true; 
     4358                                        } 
     4359                                } 
     4360 
     4361                                // force browsers to behave consistently when non-matching value is set 
     4362                                if ( !optionSet ) { 
    23194363                                        elem.selectedIndex = -1; 
    23204364                                } 
     
    23254369 
    23264370        attr: function( elem, name, value ) { 
    2327                 var hooks, notxml, ret, 
     4371                var hooks, ret, 
    23284372                        nType = elem.nodeType; 
    23294373 
     
    23384382                } 
    23394383 
    2340                 notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); 
    2341  
    23424384                // All attributes are lowercase 
    23434385                // Grab necessary hook if one is defined 
    2344                 if ( notxml ) { 
     4386                if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { 
    23454387                        name = name.toLowerCase(); 
    2346                         hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook ); 
     4388                        hooks = jQuery.attrHooks[ name ] || 
     4389                                ( jQuery.expr.match.bool.test( name ) ? boolHook : nodeHook ); 
    23474390                } 
    23484391 
     
    23524395                                jQuery.removeAttr( elem, name ); 
    23534396 
    2354                         } else if ( hooks && notxml && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) { 
     4397                        } else if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) { 
    23554398                                return ret; 
    23564399 
     
    23604403                        } 
    23614404 
    2362                 } else if ( hooks && notxml && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) { 
     4405                } else if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) { 
    23634406                        return ret; 
    23644407 
    23654408                } else { 
    2366  
    2367                         // In IE9+, Flash objects don't have .getAttribute (#12945) 
    2368                         // Support: IE9+ 
    2369                         if ( typeof elem.getAttribute !== core_strundefined ) { 
    2370                                 ret =  elem.getAttribute( name ); 
    2371                         } 
     4409                        ret = jQuery.find.attr( elem, name ); 
    23724410 
    23734411                        // Non-existent attributes return null, we normalize to undefined 
     
    23884426 
    23894427                                // Boolean attributes get special treatment (#10870) 
    2390                                 if ( rboolean.test( name ) ) { 
    2391                                         // Set corresponding property to false for boolean attributes 
    2392                                         // Also clear defaultChecked/defaultSelected (if appropriate) for IE<8 
    2393                                         if ( !getSetAttribute && ruseDefault.test( name ) ) { 
     4428                                if ( jQuery.expr.match.bool.test( name ) ) { 
     4429                                        // Set corresponding property to false 
     4430                                        if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) { 
     4431                                                elem[ propName ] = false; 
     4432                                        // Support: IE<9 
     4433                                        // Also clear defaultChecked/defaultSelected (if appropriate) 
     4434                                        } else { 
    23944435                                                elem[ jQuery.camelCase( "default-" + name ) ] = 
    23954436                                                        elem[ propName ] = false; 
    2396                                         } else { 
    2397                                                 elem[ propName ] = false; 
    23984437                                        } 
    23994438 
     
    24264465 
    24274466        propFix: { 
    2428                 tabindex: "tabIndex", 
    2429                 readonly: "readOnly", 
    24304467                "for": "htmlFor", 
    2431                 "class": "className", 
    2432                 maxlength: "maxLength", 
    2433                 cellspacing: "cellSpacing", 
    2434                 cellpadding: "cellPadding", 
    2435                 rowspan: "rowSpan", 
    2436                 colspan: "colSpan", 
    2437                 usemap: "useMap", 
    2438                 frameborder: "frameBorder", 
    2439                 contenteditable: "contentEditable" 
     4468                "class": "className" 
    24404469        }, 
    24414470 
     
    24584487 
    24594488                if ( value !== undefined ) { 
    2460                         if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) { 
    2461                                 return ret; 
    2462  
    2463                         } else { 
    2464                                 return ( elem[ name ] = value ); 
    2465                         } 
     4489                        return hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ? 
     4490                                ret : 
     4491                                ( elem[ name ] = value ); 
    24664492 
    24674493                } else { 
    2468                         if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) { 
    2469                                 return ret; 
    2470  
    2471                         } else { 
    2472                                 return elem[ name ]; 
    2473                         } 
     4494                        return hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ? 
     4495                                ret : 
     4496                                elem[ name ]; 
    24744497                } 
    24754498        }, 
     
    24804503                                // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set 
    24814504                                // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ 
    2482                                 var attributeNode = elem.getAttributeNode("tabindex"); 
    2483  
    2484                                 return attributeNode && attributeNode.specified ? 
    2485                                         parseInt( attributeNode.value, 10 ) : 
     4505                                // Use proper attribute retrieval(#12072) 
     4506                                var tabindex = jQuery.find.attr( elem, "tabindex" ); 
     4507 
     4508                                return tabindex ? 
     4509                                        parseInt( tabindex, 10 ) : 
    24864510                                        rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ? 
    24874511                                                0 : 
    2488                                                 undefined; 
     4512                                                -1; 
    24894513                        } 
    24904514                } 
     
    24924516}); 
    24934517 
    2494 // Hook for boolean attributes 
     4518// Hooks for boolean attributes 
    24954519boolHook = { 
    2496         get: function( elem, name ) { 
    2497                 var 
    2498                         // Use .prop to determine if this attribute is understood as boolean 
    2499                         prop = jQuery.prop( elem, name ), 
    2500  
    2501                         // Fetch it accordingly 
    2502                         attr = typeof prop === "boolean" && elem.getAttribute( name ), 
    2503                         detail = typeof prop === "boolean" ? 
    2504  
    2505                                 getSetInput && getSetAttribute ? 
    2506                                         attr != null : 
    2507                                         // oldIE fabricates an empty string for missing boolean attributes 
    2508                                         // and conflates checked/selected into attroperties 
    2509                                         ruseDefault.test( name ) ? 
    2510                                                 elem[ jQuery.camelCase( "default-" + name ) ] : 
    2511                                                 !!attr : 
    2512  
    2513                                 // fetch an attribute node for properties not recognized as boolean 
    2514                                 elem.getAttributeNode( name ); 
    2515  
    2516                 return detail && detail.value !== false ? 
    2517                         name.toLowerCase() : 
    2518                         undefined; 
    2519         }, 
    25204520        set: function( elem, value, name ) { 
    25214521                if ( value === false ) { 
     
    25344534        } 
    25354535}; 
    2536  
    2537 // fix oldIE value attroperty 
     4536jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) { 
     4537        var getter = jQuery.expr.attrHandle[ name ] || jQuery.find.attr; 
     4538 
     4539        jQuery.expr.attrHandle[ name ] = getSetInput && getSetAttribute || !ruseDefault.test( name ) ? 
     4540                function( elem, name, isXML ) { 
     4541                        var fn = jQuery.expr.attrHandle[ name ], 
     4542                                ret = isXML ? 
     4543                                        undefined : 
     4544                                        /* jshint eqeqeq: false */ 
     4545                                        (jQuery.expr.attrHandle[ name ] = undefined) != 
     4546                                                getter( elem, name, isXML ) ? 
     4547 
     4548                                                name.toLowerCase() : 
     4549                                                null; 
     4550                        jQuery.expr.attrHandle[ name ] = fn; 
     4551                        return ret; 
     4552                } : 
     4553                function( elem, name, isXML ) { 
     4554                        return isXML ? 
     4555                                undefined : 
     4556                                elem[ jQuery.camelCase( "default-" + name ) ] ? 
     4557                                        name.toLowerCase() : 
     4558                                        null; 
     4559                }; 
     4560}); 
     4561 
     4562// fix oldIE attroperties 
    25384563if ( !getSetInput || !getSetAttribute ) { 
    25394564        jQuery.attrHooks.value = { 
    2540                 get: function( elem, name ) { 
    2541                         var ret = elem.getAttributeNode( name ); 
    2542                         return jQuery.nodeName( elem, "input" ) ? 
    2543  
    2544                                 // Ignore the value *property* by using defaultValue 
    2545                                 elem.defaultValue : 
    2546  
    2547                                 ret && ret.specified ? ret.value : undefined; 
    2548                 }, 
    25494565                set: function( elem, value, name ) { 
    25504566                        if ( jQuery.nodeName( elem, "input" ) ) { 
     
    25644580        // Use this for any attribute in IE6/7 
    25654581        // This fixes almost every IE6/7 issue 
    2566         nodeHook = jQuery.valHooks.button = { 
    2567                 get: function( elem, name ) { 
    2568                         var ret = elem.getAttributeNode( name ); 
    2569                         return ret && ( name === "id" || name === "name" || name === "coords" ? ret.value !== "" : ret.specified ) ? 
    2570                                 ret.value : 
    2571                                 undefined; 
    2572                 }, 
     4582        nodeHook = { 
    25734583                set: function( elem, value, name ) { 
    25744584                        // Set the existing or create a new attribute node 
     
    25884598                } 
    25894599        }; 
     4600        jQuery.expr.attrHandle.id = jQuery.expr.attrHandle.name = jQuery.expr.attrHandle.coords = 
     4601                // Some attributes are constructed with empty-string values when not defined 
     4602                function( elem, name, isXML ) { 
     4603                        var ret; 
     4604                        return isXML ? 
     4605                                undefined : 
     4606                                (ret = elem.getAttributeNode( name )) && ret.value !== "" ? 
     4607                                        ret.value : 
     4608                                        null; 
     4609                }; 
     4610        jQuery.valHooks.button = { 
     4611                get: function( elem, name ) { 
     4612                        var ret = elem.getAttributeNode( name ); 
     4613                        return ret && ret.specified ? 
     4614                                ret.value : 
     4615                                undefined; 
     4616                }, 
     4617                set: nodeHook.set 
     4618        }; 
    25904619 
    25914620        // Set contenteditable to false on removals(#10429) 
    25924621        // Setting to empty string throws an error as an invalid value 
    25934622        jQuery.attrHooks.contenteditable = { 
    2594                 get: nodeHook.get, 
    25954623                set: function( elem, value, name ) { 
    25964624                        nodeHook.set( elem, value === "" ? false : value, name ); 
     
    26014629        // This is for removals 
    26024630        jQuery.each([ "width", "height" ], function( i, name ) { 
    2603                 jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], { 
     4631                jQuery.attrHooks[ name ] = { 
    26044632                        set: function( elem, value ) { 
    26054633                                if ( value === "" ) { 
     
    26084636                                } 
    26094637                        } 
    2610                 }); 
     4638                }; 
    26114639        }); 
    26124640} 
     
    26164644// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx 
    26174645if ( !jQuery.support.hrefNormalized ) { 
    2618         jQuery.each([ "href", "src", "width", "height" ], function( i, name ) { 
    2619                 jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], { 
    2620                         get: function( elem ) { 
    2621                                 var ret = elem.getAttribute( name, 2 ); 
    2622                                 return ret == null ? undefined : ret; 
    2623                         } 
    2624                 }); 
    2625         }); 
    2626  
    26274646        // href/src property should get the full normalized URL (#10299/#12915) 
    26284647        jQuery.each([ "href", "src" ], function( i, name ) { 
     
    26524671// Accessing the parent's selectedIndex property fixes it 
    26534672if ( !jQuery.support.optSelected ) { 
    2654         jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, { 
     4673        jQuery.propHooks.selected = { 
    26554674                get: function( elem ) { 
    26564675                        var parent = elem.parentNode; 
     
    26664685                        return null; 
    26674686                } 
    2668         }); 
     4687        }; 
    26694688} 
     4689 
     4690jQuery.each([ 
     4691        "tabIndex", 
     4692        "readOnly", 
     4693        "maxLength", 
     4694        "cellSpacing", 
     4695        "cellPadding", 
     4696        "rowSpan", 
     4697        "colSpan", 
     4698        "useMap", 
     4699        "frameBorder", 
     4700        "contentEditable" 
     4701], function() { 
     4702        jQuery.propFix[ this.toLowerCase() ] = this; 
     4703}); 
    26704704 
    26714705// IE6/7 call enctype encoding 
     
    26754709 
    26764710// Radios and checkboxes getter/setter 
    2677 if ( !jQuery.support.checkOn ) { 
    2678         jQuery.each([ "radio", "checkbox" ], function() { 
    2679                 jQuery.valHooks[ this ] = { 
    2680                         get: function( elem ) { 
    2681                                 // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified 
    2682                                 return elem.getAttribute("value") === null ? "on" : elem.value; 
    2683                         } 
    2684                 }; 
    2685         }); 
    2686 } 
    26874711jQuery.each([ "radio", "checkbox" ], function() { 
    2688         jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], { 
     4712        jQuery.valHooks[ this ] = { 
    26894713                set: function( elem, value ) { 
    26904714                        if ( jQuery.isArray( value ) ) { 
     
    26924716                        } 
    26934717                } 
    2694         }); 
     4718        }; 
     4719        if ( !jQuery.support.checkOn ) { 
     4720                jQuery.valHooks[ this ].get = function( elem ) { 
     4721                        // Support: Webkit 
     4722                        // "" is returned instead of "on" if a value isn't specified 
     4723                        return elem.getAttribute("value") === null ? "on" : elem.value; 
     4724                }; 
     4725        } 
    26954726}); 
    26964727var rformElems = /^(?:input|select|textarea)$/i, 
     
    27064737function returnFalse() { 
    27074738        return false; 
     4739} 
     4740 
     4741function safeActiveElement() { 
     4742        try { 
     4743                return document.activeElement; 
     4744        } catch ( err ) { } 
    27084745} 
    27094746 
     
    27564793 
    27574794                // Handle multiple events separated by a space 
    2758                 // jQuery(...).bind("mouseover mouseout", fn); 
    27594795                types = ( types || "" ).match( core_rnotwhite ) || [""]; 
    27604796                t = types.length; 
     
    27634799                        type = origType = tmp[1]; 
    27644800                        namespaces = ( tmp[2] || "" ).split( "." ).sort(); 
     4801 
     4802                        // There *must* be a type, no attaching namespace-only handlers 
     4803                        if ( !type ) { 
     4804                                continue; 
     4805                        } 
    27654806 
    27664807                        // If event changes its type, use the special event handlers for the changed type 
     
    29314972                        new jQuery.Event( type, typeof event === "object" && event ); 
    29324973 
    2933                 event.isTrigger = true; 
     4974                // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) 
     4975                event.isTrigger = onlyHandlers ? 2 : 3; 
    29344976                event.namespace = namespaces.join("."); 
    29354977                event.namespace_re = event.namespace ? 
     
    29985040                if ( !onlyHandlers && !event.isDefaultPrevented() ) { 
    29995041 
    3000                         if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) && 
    3001                                 !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) { 
     5042                        if ( (!special._default || special._default.apply( eventPath.pop(), data ) === false) && 
     5043                                jQuery.acceptData( elem ) ) { 
    30025044 
    30035045                                // Call a native DOM method on the target with the same name name as the event. 
     
    31035145                if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) { 
    31045146 
     5147                        /* jshint eqeqeq: false */ 
    31055148                        for ( ; cur != this; cur = cur.parentNode || this ) { 
     5149                                /* jshint eqeqeq: true */ 
    31065150 
    31075151                                // Don't check non-elements (#13208) 
     
    32405284                        noBubble: true 
    32415285                }, 
    3242                 click: { 
    3243                         // For checkbox, fire native event so checked state will be right 
    3244                         trigger: function() { 
    3245                                 if ( jQuery.nodeName( this, "input" ) && this.type === "checkbox" && this.click ) { 
    3246                                         this.click(); 
    3247                                         return false; 
    3248                                 } 
    3249                         } 
    3250                 }, 
    32515286                focus: { 
    32525287                        // Fire native event if possible so blur/focus sequence is correct 
    32535288                        trigger: function() { 
    3254                                 if ( this !== document.activeElement && this.focus ) { 
     5289                                if ( this !== safeActiveElement() && this.focus ) { 
    32555290                                        try { 
    32565291                                                this.focus(); 
     
    32675302                blur: { 
    32685303                        trigger: function() { 
    3269                                 if ( this === document.activeElement && this.blur ) { 
     5304                                if ( this === safeActiveElement() && this.blur ) { 
    32705305                                        this.blur(); 
    32715306                                        return false; 
     
    32735308                        }, 
    32745309                        delegateType: "focusout" 
     5310                }, 
     5311                click: { 
     5312                        // For checkbox, fire native event so checked state will be right 
     5313                        trigger: function() { 
     5314                                if ( jQuery.nodeName( this, "input" ) && this.type === "checkbox" && this.click ) { 
     5315                                        this.click(); 
     5316                                        return false; 
     5317                                } 
     5318                        }, 
     5319 
     5320                        // For cross-browser consistency, don't fire native .click() on links 
     5321                        _default: function( event ) { 
     5322                                return jQuery.nodeName( event.target, "a" ); 
     5323                        } 
    32755324                }, 
    32765325 
     
    32935342                        new jQuery.Event(), 
    32945343                        event, 
    3295                         { type: type, 
     5344                        { 
     5345                                type: type, 
    32965346                                isSimulated: true, 
    32975347                                originalEvent: {} 
     
    36585708        }, 
    36595709 
    3660         bind: function( types, data, fn ) { 
    3661                 return this.on( types, null, data, fn ); 
    3662         }, 
    3663         unbind: function( types, fn ) { 
    3664                 return this.off( types, null, fn ); 
    3665         }, 
    3666  
    3667         delegate: function( selector, types, data, fn ) { 
    3668                 return this.on( types, selector, data, fn ); 
    3669         }, 
    3670         undelegate: function( selector, types, fn ) { 
    3671                 // ( namespace ) or ( selector, types [, fn] ) 
    3672                 return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn ); 
    3673         }, 
    3674  
    36755710        trigger: function( type, data ) { 
    36765711                return this.each(function() { 
     
    36855720        } 
    36865721}); 
    3687 /*! 
    3688  * Sizzle CSS Selector Engine 
    3689  * Copyright 2012 jQuery Foundation and other contributors 
    3690  * Released under the MIT license 
    3691  * http://sizzlejs.com/ 
    3692  */ 
    3693 (function( window, undefined ) { 
    3694  
    3695 var i, 
    3696         cachedruns, 
    3697         Expr, 
    3698         getText, 
    3699         isXML, 
    3700         compile, 
    3701         hasDuplicate, 
    3702         outermostContext, 
    3703  
    3704         // Local document vars 
    3705         setDocument, 
    3706         document, 
    3707         docElem, 
    3708         documentIsXML, 
    3709         rbuggyQSA, 
    3710         rbuggyMatches, 
    3711         matches, 
    3712         contains, 
    3713         sortOrder, 
    3714  
    3715         // Instance-specific data 
    3716         expando = "sizzle" + -(new Date()), 
    3717         preferredDoc = window.document, 
    3718         support = {}, 
    3719         dirruns = 0, 
    3720         done = 0, 
    3721         classCache = createCache(), 
    3722         tokenCache = createCache(), 
    3723         compilerCache = createCache(), 
    3724  
    3725         // General-purpose constants 
    3726         strundefined = typeof undefined, 
    3727         MAX_NEGATIVE = 1 << 31, 
    3728  
    3729         // Array methods 
    3730         arr = [], 
    3731         pop = arr.pop, 
    3732         push = arr.push, 
    3733         slice = arr.slice, 
    3734         // Use a stripped-down indexOf if we can't use a native one 
    3735         indexOf = arr.indexOf || function( elem ) { 
    3736                 var i = 0, 
    3737                         len = this.length; 
    3738                 for ( ; i < len; i++ ) { 
    3739                         if ( this[i] === elem ) { 
    3740                                 return i; 
    3741                         } 
    3742                 } 
    3743                 return -1; 
    3744         }, 
    3745  
    3746  
    3747         // Regular expressions 
    3748  
    3749         // Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace 
    3750         whitespace = "[\\x20\\t\\r\\n\\f]", 
    3751         // http://www.w3.org/TR/css3-syntax/#characters 
    3752         characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+", 
    3753  
    3754         // Loosely modeled on CSS identifier characters 
    3755         // An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors 
    3756         // Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier 
    3757         identifier = characterEncoding.replace( "w", "w#" ), 
    3758  
    3759         // Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors 
    3760         operators = "([*^$|!~]?=)", 
    3761         attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace + 
    3762                 "*(?:" + operators + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]", 
    3763  
    3764         // Prefer arguments quoted, 
    3765         //   then not containing pseudos/brackets, 
    3766         //   then attribute selectors/non-parenthetical expressions, 
    3767         //   then anything else 
    3768         // These preferences are here to reduce the number of selectors 
    3769         //   needing tokenize in the PSEUDO preFilter 
    3770         pseudos = ":(" + characterEncoding + ")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" + attributes.replace( 3, 8 ) + ")*)|.*)\\)|)", 
    3771  
    3772         // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter 
    3773         rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ), 
    3774  
    3775         rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), 
    3776         rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ), 
    3777         rpseudo = new RegExp( pseudos ), 
    3778         ridentifier = new RegExp( "^" + identifier + "$" ), 
    3779  
    3780         matchExpr = { 
    3781                 "ID": new RegExp( "^#(" + characterEncoding + ")" ), 
    3782                 "CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ), 
    3783                 "NAME": new RegExp( "^\\[name=['\"]?(" + characterEncoding + ")['\"]?\\]" ), 
    3784                 "TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ), 
    3785                 "ATTR": new RegExp( "^" + attributes ), 
    3786                 "PSEUDO": new RegExp( "^" + pseudos ), 
    3787                 "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + 
    3788                         "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + 
    3789                         "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), 
    3790                 // For use in libraries implementing .is() 
    3791                 // We use this for POS matching in `select` 
    3792                 "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + 
    3793                         whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) 
    3794         }, 
    3795  
    3796         rsibling = /[\x20\t\r\n\f]*[+~]/, 
    3797  
    3798         rnative = /^[^{]+\{\s*\[native code/, 
    3799  
    3800         // Easily-parseable/retrievable ID or TAG or CLASS selectors 
    3801         rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, 
    3802  
    3803         rinputs = /^(?:input|select|textarea|button)$/i, 
    3804         rheader = /^h\d$/i, 
    3805  
    3806         rescape = /'|\\/g, 
    3807         rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g, 
    3808  
    3809         // CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters 
    3810         runescape = /\\([\da-fA-F]{1,6}[\x20\t\r\n\f]?|.)/g, 
    3811         funescape = function( _, escaped ) { 
    3812                 var high = "0x" + escaped - 0x10000; 
    3813                 // NaN means non-codepoint 
    3814                 return high !== high ? 
    3815                         escaped : 
    3816                         // BMP codepoint 
    3817                         high < 0 ? 
    3818                                 String.fromCharCode( high + 0x10000 ) : 
    3819                                 // Supplemental Plane codepoint (surrogate pair) 
    3820                                 String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); 
    3821         }; 
    3822  
    3823 // Use a stripped-down slice if we can't use a native one 
    3824 try { 
    3825         slice.call( preferredDoc.documentElement.childNodes, 0 )[0].nodeType; 
    3826 } catch ( e ) { 
    3827         slice = function( i ) { 
    3828                 var elem, 
    3829                         results = []; 
    3830                 while ( (elem = this[i++]) ) { 
    3831                         results.push( elem ); 
    3832                 } 
    3833                 return results; 
    3834         }; 
    3835 } 
    3836  
    3837 /** 
    3838  * For feature detection 
    3839  * @param {Function} fn The function to test for native support 
    3840  */ 
    3841 function isNative( fn ) { 
    3842         return rnative.test( fn + "" ); 
    3843 } 
    3844  
    3845 /** 
    3846  * Create key-value caches of limited size 
    3847  * @returns {Function(string, Object)} Returns the Object data after storing it on itself with 
    3848  *      property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) 
    3849  *      deleting the oldest entry 
    3850  */ 
    3851 function createCache() { 
    3852         var cache, 
    3853                 keys = []; 
    3854  
    3855         return (cache = function( key, value ) { 
    3856                 // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) 
    3857                 if ( keys.push( key += " " ) > Expr.cacheLength ) { 
    3858                         // Only keep the most recent entries 
    3859                         delete cache[ keys.shift() ]; 
    3860                 } 
    3861                 return (cache[ key ] = value); 
    3862         }); 
    3863 } 
    3864  
    3865 /** 
    3866  * Mark a function for special use by Sizzle 
    3867  * @param {Function} fn The function to mark 
    3868  */ 
    3869 function markFunction( fn ) { 
    3870         fn[ expando ] = true; 
    3871         return fn; 
    3872 } 
    3873  
    3874 /** 
    3875  * Support testing using an element 
    3876  * @param {Function} fn Passed the created div and expects a boolean result 
    3877  */ 
    3878 function assert( fn ) { 
    3879         var div = document.createElement("div"); 
    3880  
    3881         try { 
    3882                 return fn( div ); 
    3883         } catch (e) { 
    3884                 return false; 
    3885         } finally { 
    3886                 // release memory in IE 
    3887                 div = null; 
    3888         } 
    3889 } 
    3890  
    3891 function Sizzle( selector, context, results, seed ) { 
    3892         var match, elem, m, nodeType, 
    3893                 // QSA vars 
    3894                 i, groups, old, nid, newContext, newSelector; 
    3895  
    3896         if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) { 
    3897                 setDocument( context ); 
    3898         } 
    3899  
    3900         context = context || document; 
    3901         results = results || []; 
    3902  
    3903         if ( !selector || typeof selector !== "string" ) { 
    3904                 return results; 
    3905         } 
    3906  
    3907         if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) { 
    3908                 return []; 
    3909         } 
    3910  
    3911         if ( !documentIsXML && !seed ) { 
    3912  
    3913                 // Shortcuts 
    3914                 if ( (match = rquickExpr.exec( selector )) ) { 
    3915                         // Speed-up: Sizzle("#ID") 
    3916                         if ( (m = match[1]) ) { 
    3917                                 if ( nodeType === 9 ) { 
    3918                                         elem = context.getElementById( m ); 
    3919                                         // Check parentNode to catch when Blackberry 4.6 returns 
    3920                                         // nodes that are no longer in the document #6963 
    3921                                         if ( elem && elem.parentNode ) { 
    3922                                                 // Handle the case where IE, Opera, and Webkit return items 
    3923                                                 // by name instead of ID 
    3924                                                 if ( elem.id === m ) { 
    3925                                                         results.push( elem ); 
    3926                                                         return results; 
    3927                                                 } 
    3928                                         } else { 
    3929                                                 return results; 
    3930                                         } 
    3931                                 } else { 
    3932                                         // Context is not a document 
    3933                                         if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) && 
    3934                                                 contains( context, elem ) && elem.id === m ) { 
    3935                                                 results.push( elem ); 
    3936                                                 return results; 
    3937                                         } 
    3938                                 } 
    3939  
    3940                         // Speed-up: Sizzle("TAG") 
    3941                         } else if ( match[2] ) { 
    3942                                 push.apply( results, slice.call(context.getElementsByTagName( selector ), 0) ); 
    3943                                 return results; 
    3944  
    3945                         // Speed-up: Sizzle(".CLASS") 
    3946                         } else if ( (m = match[3]) && support.getByClassName && context.getElementsByClassName ) { 
    3947                                 push.apply( results, slice.call(context.getElementsByClassName( m ), 0) ); 
    3948                                 return results; 
    3949                         } 
    3950                 } 
    3951  
    3952                 // QSA path 
    3953                 if ( support.qsa && !rbuggyQSA.test(selector) ) { 
    3954                         old = true; 
    3955                         nid = expando; 
    3956                         newContext = context; 
    3957                         newSelector = nodeType === 9 && selector; 
    3958  
    3959                         // qSA works strangely on Element-rooted queries 
    3960                         // We can work around this by specifying an extra ID on the root 
    3961                         // and working up from there (Thanks to Andrew Dupont for the technique) 
    3962                         // IE 8 doesn't work on object elements 
    3963                         if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) { 
    3964                                 groups = tokenize( selector ); 
    3965  
    3966                                 if ( (old = context.getAttribute("id")) ) { 
    3967                                         nid = old.replace( rescape, "\\$&" ); 
    3968                                 } else { 
    3969                                         context.setAttribute( "id", nid ); 
    3970                                 } 
    3971                                 nid = "[id='" + nid + "'] "; 
    3972  
    3973                                 i = groups.length; 
    3974                                 while ( i-- ) { 
    3975                                         groups[i] = nid + toSelector( groups[i] ); 
    3976                                 } 
    3977                                 newContext = rsibling.test( selector ) && context.parentNode || context; 
    3978                                 newSelector = groups.join(","); 
    3979                         } 
    3980  
    3981                         if ( newSelector ) { 
    3982                                 try { 
    3983                                         push.apply( results, slice.call( newContext.querySelectorAll( 
    3984                                                 newSelector 
    3985                                         ), 0 ) ); 
    3986                                         return results; 
    3987                                 } catch(qsaError) { 
    3988                                 } finally { 
    3989                                         if ( !old ) { 
    3990                                                 context.removeAttribute("id"); 
    3991                                         } 
    3992                                 } 
    3993                         } 
    3994                 } 
    3995         } 
    3996  
    3997         // All others 
    3998         return select( selector.replace( rtrim, "$1" ), context, results, seed ); 
    3999 } 
    4000  
    4001 /** 
    4002  * Detect xml 
    4003  * @param {Element|Object} elem An element or a document 
    4004  */ 
    4005 isXML = Sizzle.isXML = function( elem ) { 
    4006         // documentElement is verified for cases where it doesn't yet exist 
    4007         // (such as loading iframes in IE - #4833) 
    4008         var documentElement = elem && (elem.ownerDocument || elem).documentElement; 
    4009         return documentElement ? documentElement.nodeName !== "HTML" : false; 
    4010 }; 
    4011  
    4012 /** 
    4013  * Sets document-related variables once based on the current document 
    4014  * @param {Element|Object} [doc] An element or document object to use to set the document 
    4015  * @returns {Object} Returns the current document 
    4016  */ 
    4017 setDocument = Sizzle.setDocument = function( node ) { 
    4018         var doc = node ? node.ownerDocument || node : preferredDoc; 
    4019  
    4020         // If no document and documentElement is available, return 
    4021         if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) { 
    4022                 return document; 
    4023         } 
    4024  
    4025         // Set our document 
    4026         document = doc; 
    4027         docElem = doc.documentElement; 
    4028  
    4029         // Support tests 
    4030         documentIsXML = isXML( doc ); 
    4031  
    4032         // Check if getElementsByTagName("*") returns only elements 
    4033         support.tagNameNoComments = assert(function( div ) { 
    4034                 div.appendChild( doc.createComment("") ); 
    4035                 return !div.getElementsByTagName("*").length; 
    4036         }); 
    4037  
    4038         // Check if attributes should be retrieved by attribute nodes 
    4039         support.attributes = assert(function( div ) { 
    4040                 div.innerHTML = "<select></select>"; 
    4041                 var type = typeof div.lastChild.getAttribute("multiple"); 
    4042                 // IE8 returns a string for some attributes even when not present 
    4043                 return type !== "boolean" && type !== "string"; 
    4044         }); 
    4045  
    4046         // Check if getElementsByClassName can be trusted 
    4047         support.getByClassName = assert(function( div ) { 
    4048                 // Opera can't find a second classname (in 9.6) 
    4049                 div.innerHTML = "<div class='hidden e'></div><div class='hidden'></div>"; 
    4050                 if ( !div.getElementsByClassName || !div.getElementsByClassName("e").length ) { 
    4051                         return false; 
    4052                 } 
    4053  
    4054                 // Safari 3.2 caches class attributes and doesn't catch changes 
    4055                 div.lastChild.className = "e"; 
    4056                 return div.getElementsByClassName("e").length === 2; 
    4057         }); 
    4058  
    4059         // Check if getElementById returns elements by name 
    4060         // Check if getElementsByName privileges form controls or returns elements by ID 
    4061         support.getByName = assert(function( div ) { 
    4062                 // Inject content 
    4063                 div.id = expando + 0; 
    4064                 div.innerHTML = "<a name='" + expando + "'></a><div name='" + expando + "'></div>"; 
    4065                 docElem.insertBefore( div, docElem.firstChild ); 
    4066  
    4067                 // Test 
    4068                 var pass = doc.getElementsByName && 
    4069                         // buggy browsers will return fewer than the correct 2 
    4070                         doc.getElementsByName( expando ).length === 2 + 
    4071                         // buggy browsers will return more than the correct 0 
    4072                         doc.getElementsByName( expando + 0 ).length; 
    4073                 support.getIdNotName = !doc.getElementById( expando ); 
    4074  
    4075                 // Cleanup 
    4076                 docElem.removeChild( div ); 
    4077  
    4078                 return pass; 
    4079         }); 
    4080  
    4081         // IE6/7 return modified attributes 
    4082         Expr.attrHandle = assert(function( div ) { 
    4083                 div.innerHTML = "<a href='#'></a>"; 
    4084                 return div.firstChild && typeof div.firstChild.getAttribute !== strundefined && 
    4085                         div.firstChild.getAttribute("href") === "#"; 
    4086         }) ? 
    4087                 {} : 
    4088                 { 
    4089                         "href": function( elem ) { 
    4090                                 return elem.getAttribute( "href", 2 ); 
    4091                         }, 
    4092                         "type": function( elem ) { 
    4093                                 return elem.getAttribute("type"); 
    4094                         } 
    4095                 }; 
    4096  
    4097         // ID find and filter 
    4098         if ( support.getIdNotName ) { 
    4099                 Expr.find["ID"] = function( id, context ) { 
    4100                         if ( typeof context.getElementById !== strundefined && !documentIsXML ) { 
    4101                                 var m = context.getElementById( id ); 
    4102                                 // Check parentNode to catch when Blackberry 4.6 returns 
    4103                                 // nodes that are no longer in the document #6963 
    4104                                 return m && m.parentNode ? [m] : []; 
    4105                         } 
    4106                 }; 
    4107                 Expr.filter["ID"] = function( id ) { 
    4108                         var attrId = id.replace( runescape, funescape ); 
    4109                         return function( elem ) { 
    4110                                 return elem.getAttribute("id") === attrId; 
    4111                         }; 
    4112                 }; 
    4113         } else { 
    4114                 Expr.find["ID"] = function( id, context ) { 
    4115                         if ( typeof context.getElementById !== strundefined && !documentIsXML ) { 
    4116                                 var m = context.getElementById( id ); 
    4117  
    4118                                 return m ? 
    4119                                         m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ? 
    4120                                                 [m] : 
    4121                                                 undefined : 
    4122                                         []; 
    4123                         } 
    4124                 }; 
    4125                 Expr.filter["ID"] =  function( id ) { 
    4126                         var attrId = id.replace( runescape, funescape ); 
    4127                         return function( elem ) { 
    4128                                 var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id"); 
    4129                                 return node && node.value === attrId; 
    4130                         }; 
    4131                 }; 
    4132         } 
    4133  
    4134         // Tag 
    4135         Expr.find["TAG"] = support.tagNameNoComments ? 
    4136                 function( tag, context ) { 
    4137                         if ( typeof context.getElementsByTagName !== strundefined ) { 
    4138                                 return context.getElementsByTagName( tag ); 
    4139                         } 
    4140                 } : 
    4141                 function( tag, context ) { 
    4142                         var elem, 
    4143                                 tmp = [], 
    4144                                 i = 0, 
    4145                                 results = context.getElementsByTagName( tag ); 
    4146  
    4147                         // Filter out possible comments 
    4148                         if ( tag === "*" ) { 
    4149                                 while ( (elem = results[i++]) ) { 
    4150                                         if ( elem.nodeType === 1 ) { 
    4151                                                 tmp.push( elem ); 
    4152                                         } 
    4153                                 } 
    4154  
    4155                                 return tmp; 
    4156                         } 
    4157                         return results; 
    4158                 }; 
    4159  
    4160         // Name 
    4161         Expr.find["NAME"] = support.getByName && function( tag, context ) { 
    4162                 if ( typeof context.getElementsByName !== strundefined ) { 
    4163                         return context.getElementsByName( name ); 
    4164                 } 
    4165         }; 
    4166  
    4167         // Class 
    4168         Expr.find["CLASS"] = support.getByClassName && function( className, context ) { 
    4169                 if ( typeof context.getElementsByClassName !== strundefined && !documentIsXML ) { 
    4170                         return context.getElementsByClassName( className ); 
    4171                 } 
    4172         }; 
    4173  
    4174         // QSA and matchesSelector support 
    4175  
    4176         // matchesSelector(:active) reports false when true (IE9/Opera 11.5) 
    4177         rbuggyMatches = []; 
    4178  
    4179         // qSa(:focus) reports false when true (Chrome 21), 
    4180         // no need to also add to buggyMatches since matches checks buggyQSA 
    4181         // A support test would require too much code (would include document ready) 
    4182         rbuggyQSA = [ ":focus" ]; 
    4183  
    4184         if ( (support.qsa = isNative(doc.querySelectorAll)) ) { 
    4185                 // Build QSA regex 
    4186                 // Regex strategy adopted from Diego Perini 
    4187                 assert(function( div ) { 
    4188                         // Select is set to empty string on purpose 
    4189                         // This is to test IE's treatment of not explictly 
    4190                         // setting a boolean content attribute, 
    4191                         // since its presence should be enough 
    4192                         // http://bugs.jquery.com/ticket/12359 
    4193                         div.innerHTML = "<select><option selected=''></option></select>"; 
    4194  
    4195                         // IE8 - Some boolean attributes are not treated correctly 
    4196                         if ( !div.querySelectorAll("[selected]").length ) { 
    4197                                 rbuggyQSA.push( "\\[" + whitespace + "*(?:checked|disabled|ismap|multiple|readonly|selected|value)" ); 
    4198                         } 
    4199  
    4200                         // Webkit/Opera - :checked should return selected option elements 
    4201                         // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked 
    4202                         // IE8 throws error here and will not see later tests 
    4203                         if ( !div.querySelectorAll(":checked").length ) { 
    4204                                 rbuggyQSA.push(":checked"); 
    4205                         } 
    4206                 }); 
    4207  
    4208                 assert(function( div ) { 
    4209  
    4210                         // Opera 10-12/IE8 - ^= $= *= and empty values 
    4211                         // Should not select anything 
    4212                         div.innerHTML = "<input type='hidden' i=''/>"; 
    4213                         if ( div.querySelectorAll("[i^='']").length ) { 
    4214                                 rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:\"\"|'')" ); 
    4215                         } 
    4216  
    4217                         // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) 
    4218                         // IE8 throws error here and will not see later tests 
    4219                         if ( !div.querySelectorAll(":enabled").length ) { 
    4220                                 rbuggyQSA.push( ":enabled", ":disabled" ); 
    4221                         } 
    4222  
    4223                         // Opera 10-11 does not throw on post-comma invalid pseudos 
    4224                         div.querySelectorAll("*,:x"); 
    4225                         rbuggyQSA.push(",.*:"); 
    4226                 }); 
    4227         } 
    4228  
    4229         if ( (support.matchesSelector = isNative( (matches = docElem.matchesSelector || 
    4230                 docElem.mozMatchesSelector || 
    4231                 docElem.webkitMatchesSelector || 
    4232                 docElem.oMatchesSelector || 
    4233                 docElem.msMatchesSelector) )) ) { 
    4234  
    4235                 assert(function( div ) { 
    4236                         // Check to see if it's possible to do matchesSelector 
    4237                         // on a disconnected node (IE 9) 
    4238                         support.disconnectedMatch = matches.call( div, "div" ); 
    4239  
    4240                         // This should fail with an exception 
    4241                         // Gecko does not error, returns false instead 
    4242                         matches.call( div, "[s!='']:x" ); 
    4243                         rbuggyMatches.push( "!=", pseudos ); 
    4244                 }); 
    4245         } 
    4246  
    4247         rbuggyQSA = new RegExp( rbuggyQSA.join("|") ); 
    4248         rbuggyMatches = new RegExp( rbuggyMatches.join("|") ); 
    4249  
    4250         // Element contains another 
    4251         // Purposefully does not implement inclusive descendent 
    4252         // As in, an element does not contain itself 
    4253         contains = isNative(docElem.contains) || docElem.compareDocumentPosition ? 
    4254                 function( a, b ) { 
    4255                         var adown = a.nodeType === 9 ? a.documentElement : a, 
    4256                                 bup = b && b.parentNode; 
    4257                         return a === bup || !!( bup && bup.nodeType === 1 && ( 
    4258                                 adown.contains ? 
    4259                                         adown.contains( bup ) : 
    4260                                         a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 
    4261                         )); 
    4262                 } : 
    4263                 function( a, b ) { 
    4264                         if ( b ) { 
    4265                                 while ( (b = b.parentNode) ) { 
    4266                                         if ( b === a ) { 
    4267                                                 return true; 
    4268                                         } 
    4269                                 } 
    4270                         } 
    4271                         return false; 
    4272                 }; 
    4273  
    4274         // Document order sorting 
    4275         sortOrder = docElem.compareDocumentPosition ? 
    4276         function( a, b ) { 
    4277                 var compare; 
    4278  
    4279                 if ( a === b ) { 
    4280                         hasDuplicate = true; 
    4281                         return 0; 
    4282                 } 
    4283  
    4284                 if ( (compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition( b )) ) { 
    4285                         if ( compare & 1 || a.parentNode && a.parentNode.nodeType === 11 ) { 
    4286                                 if ( a === doc || contains( preferredDoc, a ) ) { 
    4287                                         return -1; 
    4288                                 } 
    4289                                 if ( b === doc || contains( preferredDoc, b ) ) { 
    4290                                         return 1; 
    4291                                 } 
    4292                                 return 0; 
    4293                         } 
    4294                         return compare & 4 ? -1 : 1; 
    4295                 } 
    4296  
    4297                 return a.compareDocumentPosition ? -1 : 1; 
    4298         } : 
    4299         function( a, b ) { 
    4300                 var cur, 
    4301                         i = 0, 
    4302                         aup = a.parentNode, 
    4303                         bup = b.parentNode, 
    4304                         ap = [ a ], 
    4305                         bp = [ b ]; 
    4306  
    4307                 // Exit early if the nodes are identical 
    4308                 if ( a === b ) { 
    4309                         hasDuplicate = true; 
    4310                         return 0; 
    4311  
    4312                 // Parentless nodes are either documents or disconnected 
    4313                 } else if ( !aup || !bup ) { 
    4314                         return a === doc ? -1 : 
    4315                                 b === doc ? 1 : 
    4316                                 aup ? -1 : 
    4317                                 bup ? 1 : 
    4318                                 0; 
    4319  
    4320                 // If the nodes are siblings, we can do a quick check 
    4321                 } else if ( aup === bup ) { 
    4322                         return siblingCheck( a, b ); 
    4323                 } 
    4324  
    4325                 // Otherwise we need full lists of their ancestors for comparison 
    4326                 cur = a; 
    4327                 while ( (cur = cur.parentNode) ) { 
    4328                         ap.unshift( cur ); 
    4329                 } 
    4330                 cur = b; 
    4331                 while ( (cur = cur.parentNode) ) { 
    4332                         bp.unshift( cur ); 
    4333                 } 
    4334  
    4335                 // Walk down the tree looking for a discrepancy 
    4336                 while ( ap[i] === bp[i] ) { 
    4337                         i++; 
    4338                 } 
    4339  
    4340                 return i ? 
    4341                         // Do a sibling check if the nodes have a common ancestor 
    4342                         siblingCheck( ap[i], bp[i] ) : 
    4343  
    4344                         // Otherwise nodes in our document sort first 
    4345                         ap[i] === preferredDoc ? -1 : 
    4346                         bp[i] === preferredDoc ? 1 : 
    4347                         0; 
    4348         }; 
    4349  
    4350         // Always assume the presence of duplicates if sort doesn't 
    4351         // pass them to our comparison function (as in Google Chrome). 
    4352         hasDuplicate = false; 
    4353         [0, 0].sort( sortOrder ); 
    4354         support.detectDuplicates = hasDuplicate; 
    4355  
    4356         return document; 
    4357 }; 
    4358  
    4359 Sizzle.matches = function( expr, elements ) { 
    4360         return Sizzle( expr, null, null, elements ); 
    4361 }; 
    4362  
    4363 Sizzle.matchesSelector = function( elem, expr ) { 
    4364         // Set document vars if needed 
    4365         if ( ( elem.ownerDocument || elem ) !== document ) { 
    4366                 setDocument( elem ); 
    4367         } 
    4368  
    4369         // Make sure that attribute selectors are quoted 
    4370         expr = expr.replace( rattributeQuotes, "='$1']" ); 
    4371  
    4372         // rbuggyQSA always contains :focus, so no need for an existence check 
    4373         if ( support.matchesSelector && !documentIsXML && (!rbuggyMatches || !rbuggyMatches.test(expr)) && !rbuggyQSA.test(expr) ) { 
    4374                 try { 
    4375                         var ret = matches.call( elem, expr ); 
    4376  
    4377                         // IE 9's matchesSelector returns false on disconnected nodes 
    4378                         if ( ret || support.disconnectedMatch || 
    4379                                         // As well, disconnected nodes are said to be in a document 
    4380                                         // fragment in IE 9 
    4381                                         elem.document && elem.document.nodeType !== 11 ) { 
    4382                                 return ret; 
    4383                         } 
    4384                 } catch(e) {} 
    4385         } 
    4386  
    4387         return Sizzle( expr, document, null, [elem] ).length > 0; 
    4388 }; 
    4389  
    4390 Sizzle.contains = function( context, elem ) { 
    4391         // Set document vars if needed 
    4392         if ( ( context.ownerDocument || context ) !== document ) { 
    4393                 setDocument( context ); 
    4394         } 
    4395         return contains( context, elem ); 
    4396 }; 
    4397  
    4398 Sizzle.attr = function( elem, name ) { 
    4399         var val; 
    4400  
    4401         // Set document vars if needed 
    4402         if ( ( elem.ownerDocument || elem ) !== document ) { 
    4403                 setDocument( elem ); 
    4404         } 
    4405  
    4406         if ( !documentIsXML ) { 
    4407                 name = name.toLowerCase(); 
    4408         } 
    4409         if ( (val = Expr.attrHandle[ name ]) ) { 
    4410                 return val( elem ); 
    4411         } 
    4412         if ( documentIsXML || support.attributes ) { 
    4413                 return elem.getAttribute( name ); 
    4414         } 
    4415         return ( (val = elem.getAttributeNode( name )) || elem.getAttribute( name ) ) && elem[ name ] === true ? 
    4416                 name : 
    4417                 val && val.specified ? val.value : null; 
    4418 }; 
    4419  
    4420 Sizzle.error = function( msg ) { 
    4421         throw new Error( "Syntax error, unrecognized expression: " + msg ); 
    4422 }; 
    4423  
    4424 // Document sorting and removing duplicates 
    4425 Sizzle.uniqueSort = function( results ) { 
    4426         var elem, 
    4427                 duplicates = [], 
    4428                 i = 1, 
    4429                 j = 0; 
    4430  
    4431         // Unless we *know* we can detect duplicates, assume their presence 
    4432         hasDuplicate = !support.detectDuplicates; 
    4433         results.sort( sortOrder ); 
    4434  
    4435         if ( hasDuplicate ) { 
    4436                 for ( ; (elem = results[i]); i++ ) { 
    4437                         if ( elem === results[ i - 1 ] ) { 
    4438                                 j = duplicates.push( i ); 
    4439                         } 
    4440                 } 
    4441                 while ( j-- ) { 
    4442                         results.splice( duplicates[ j ], 1 ); 
    4443                 } 
    4444         } 
    4445  
    4446         return results; 
    4447 }; 
    4448  
    4449 function siblingCheck( a, b ) { 
    4450         var cur = b && a, 
    4451                 diff = cur && ( ~b.sourceIndex || MAX_NEGATIVE ) - ( ~a.sourceIndex || MAX_NEGATIVE ); 
    4452  
    4453         // Use IE sourceIndex if available on both nodes 
    4454         if ( diff ) { 
    4455                 return diff; 
    4456         } 
    4457  
    4458         // Check if b follows a 
    4459         if ( cur ) { 
    4460                 while ( (cur = cur.nextSibling) ) { 
    4461                         if ( cur === b ) { 
    4462                                 return -1; 
    4463                         } 
    4464                 } 
    4465         } 
    4466  
    4467         return a ? 1 : -1; 
    4468 } 
    4469  
    4470 // Returns a function to use in pseudos for input types 
    4471 function createInputPseudo( type ) { 
    4472         return function( elem ) { 
    4473                 var name = elem.nodeName.toLowerCase(); 
    4474                 return name === "input" && elem.type === type; 
    4475         }; 
    4476 } 
    4477  
    4478 // Returns a function to use in pseudos for buttons 
    4479 function createButtonPseudo( type ) { 
    4480         return function( elem ) { 
    4481                 var name = elem.nodeName.toLowerCase(); 
    4482                 return (name === "input" || name === "button") && elem.type === type; 
    4483         }; 
    4484 } 
    4485  
    4486 // Returns a function to use in pseudos for positionals 
    4487 function createPositionalPseudo( fn ) { 
    4488         return markFunction(function( argument ) { 
    4489                 argument = +argument; 
    4490                 return markFunction(function( seed, matches ) { 
    4491                         var j, 
    4492                                 matchIndexes = fn( [], seed.length, argument ), 
    4493                                 i = matchIndexes.length; 
    4494  
    4495                         // Match elements found at the specified indexes 
    4496                         while ( i-- ) { 
    4497                                 if ( seed[ (j = matchIndexes[i]) ] ) { 
    4498                                         seed[j] = !(matches[j] = seed[j]); 
    4499                                 } 
    4500                         } 
    4501                 }); 
    4502         }); 
    4503 } 
    4504  
    4505 /** 
    4506  * Utility function for retrieving the text value of an array of DOM nodes 
    4507  * @param {Array|Element} elem 
    4508  */ 
    4509 getText = Sizzle.getText = function( elem ) { 
    4510         var node, 
    4511                 ret = "", 
    4512                 i = 0, 
    4513                 nodeType = elem.nodeType; 
    4514  
    4515         if ( !nodeType ) { 
    4516                 // If no nodeType, this is expected to be an array 
    4517                 for ( ; (node = elem[i]); i++ ) { 
    4518                         // Do not traverse comment nodes 
    4519                         ret += getText( node ); 
    4520                 } 
    4521         } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { 
    4522                 // Use textContent for elements 
    4523                 // innerText usage removed for consistency of new lines (see #11153) 
    4524                 if ( typeof elem.textContent === "string" ) { 
    4525                         return elem.textContent; 
    4526                 } else { 
    4527                         // Traverse its children 
    4528                         for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { 
    4529                                 ret += getText( elem ); 
    4530                         } 
    4531                 } 
    4532         } else if ( nodeType === 3 || nodeType === 4 ) { 
    4533                 return elem.nodeValue; 
    4534         } 
    4535         // Do not include comment or processing instruction nodes 
    4536  
    4537         return ret; 
    4538 }; 
    4539  
    4540 Expr = Sizzle.selectors = { 
    4541  
    4542         // Can be adjusted by the user 
    4543         cacheLength: 50, 
    4544  
    4545         createPseudo: markFunction, 
    4546  
    4547         match: matchExpr, 
    4548  
    4549         find: {}, 
    4550  
    4551         relative: { 
    4552                 ">": { dir: "parentNode", first: true }, 
    4553                 " ": { dir: "parentNode" }, 
    4554                 "+": { dir: "previousSibling", first: true }, 
    4555                 "~": { dir: "previousSibling" } 
    4556         }, 
    4557  
    4558         preFilter: { 
    4559                 "ATTR": function( match ) { 
    4560                         match[1] = match[1].replace( runescape, funescape ); 
    4561  
    4562                         // Move the given value to match[3] whether quoted or unquoted 
    4563                         match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape ); 
    4564  
    4565                         if ( match[2] === "~=" ) { 
    4566                                 match[3] = " " + match[3] + " "; 
    4567                         } 
    4568  
    4569                         return match.slice( 0, 4 ); 
    4570                 }, 
    4571  
    4572                 "CHILD": function( match ) { 
    4573                         /* matches from matchExpr["CHILD"] 
    4574                                 1 type (only|nth|...) 
    4575                                 2 what (child|of-type) 
    4576                                 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 
    4577                                 4 xn-component of xn+y argument ([+-]?\d*n|) 
    4578                                 5 sign of xn-component 
    4579                                 6 x of xn-component 
    4580                                 7 sign of y-component 
    4581                                 8 y of y-component 
    4582                         */ 
    4583                         match[1] = match[1].toLowerCase(); 
    4584  
    4585                         if ( match[1].slice( 0, 3 ) === "nth" ) { 
    4586                                 // nth-* requires argument 
    4587                                 if ( !match[3] ) { 
    4588                                         Sizzle.error( match[0] ); 
    4589                                 } 
    4590  
    4591                                 // numeric x and y parameters for Expr.filter.CHILD 
    4592                                 // remember that false/true cast respectively to 0/1 
    4593                                 match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) ); 
    4594                                 match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" ); 
    4595  
    4596                         // other types prohibit arguments 
    4597                         } else if ( match[3] ) { 
    4598                                 Sizzle.error( match[0] ); 
    4599                         } 
    4600  
    4601                         return match; 
    4602                 }, 
    4603  
    4604                 "PSEUDO": function( match ) { 
    4605                         var excess, 
    4606                                 unquoted = !match[5] && match[2]; 
    4607  
    4608                         if ( matchExpr["CHILD"].test( match[0] ) ) { 
    4609                                 return null; 
    4610                         } 
    4611  
    4612                         // Accept quoted arguments as-is 
    4613                         if ( match[4] ) { 
    4614                                 match[2] = match[4]; 
    4615  
    4616                         // Strip excess characters from unquoted arguments 
    4617                         } else if ( unquoted && rpseudo.test( unquoted ) && 
    4618                                 // Get excess from tokenize (recursively) 
    4619                                 (excess = tokenize( unquoted, true )) && 
    4620                                 // advance to the next closing parenthesis 
    4621                                 (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) { 
    4622  
    4623                                 // excess is a negative index 
    4624                                 match[0] = match[0].slice( 0, excess ); 
    4625                                 match[2] = unquoted.slice( 0, excess ); 
    4626                         } 
    4627  
    4628                         // Return only captures needed by the pseudo filter method (type and argument) 
    4629                         return match.slice( 0, 3 ); 
    4630                 } 
    4631         }, 
    4632  
    4633         filter: { 
    4634  
    4635                 "TAG": function( nodeName ) { 
    4636                         if ( nodeName === "*" ) { 
    4637                                 return function() { return true; }; 
    4638                         } 
    4639  
    4640                         nodeName = nodeName.replace( runescape, funescape ).toLowerCase(); 
    4641                         return function( elem ) { 
    4642                                 return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; 
    4643                         }; 
    4644                 }, 
    4645  
    4646                 "CLASS": function( className ) { 
    4647                         var pattern = classCache[ className + " " ]; 
    4648  
    4649                         return pattern || 
    4650                                 (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) && 
    4651                                 classCache( className, function( elem ) { 
    4652                                         return pattern.test( elem.className || (typeof elem.getAttribute !== strundefined && elem.getAttribute("class")) || "" ); 
    4653                                 }); 
    4654                 }, 
    4655  
    4656                 "ATTR": function( name, operator, check ) { 
    4657                         return function( elem ) { 
    4658                                 var result = Sizzle.attr( elem, name ); 
    4659  
    4660                                 if ( result == null ) { 
    4661                                         return operator === "!="; 
    4662                                 } 
    4663                                 if ( !operator ) { 
    4664                                         return true; 
    4665                                 } 
    4666  
    4667                                 result += ""; 
    4668  
    4669                                 return operator === "=" ? result === check : 
    4670                                         operator === "!=" ? result !== check : 
    4671                                         operator === "^=" ? check && result.indexOf( check ) === 0 : 
    4672                                         operator === "*=" ? check && result.indexOf( check ) > -1 : 
    4673                                         operator === "$=" ? check && result.slice( -check.length ) === check : 
    4674                                         operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 : 
    4675                                         operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" : 
    4676                                         false; 
    4677                         }; 
    4678                 }, 
    4679  
    4680                 "CHILD": function( type, what, argument, first, last ) { 
    4681                         var simple = type.slice( 0, 3 ) !== "nth", 
    4682                                 forward = type.slice( -4 ) !== "last", 
    4683                                 ofType = what === "of-type"; 
    4684  
    4685                         return first === 1 && last === 0 ? 
    4686  
    4687                                 // Shortcut for :nth-*(n) 
    4688                                 function( elem ) { 
    4689                                         return !!elem.parentNode; 
    4690                                 } : 
    4691  
    4692                                 function( elem, context, xml ) { 
    4693                                         var cache, outerCache, node, diff, nodeIndex, start, 
    4694                                                 dir = simple !== forward ? "nextSibling" : "previousSibling", 
    4695                                                 parent = elem.parentNode, 
    4696                                                 name = ofType && elem.nodeName.toLowerCase(), 
    4697                                                 useCache = !xml && !ofType; 
    4698  
    4699                                         if ( parent ) { 
    4700  
    4701                                                 // :(first|last|only)-(child|of-type) 
    4702                                                 if ( simple ) { 
    4703                                                         while ( dir ) { 
    4704                                                                 node = elem; 
    4705                                                                 while ( (node = node[ dir ]) ) { 
    4706                                                                         if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) { 
    4707                                                                                 return false; 
    4708                                                                         } 
    4709                                                                 } 
    4710                                                                 // Reverse direction for :only-* (if we haven't yet done so) 
    4711                                                                 start = dir = type === "only" && !start && "nextSibling"; 
    4712                                                         } 
    4713                                                         return true; 
    4714                                                 } 
    4715  
    4716                                                 start = [ forward ? parent.firstChild : parent.lastChild ]; 
    4717  
    4718                                                 // non-xml :nth-child(...) stores cache data on `parent` 
    4719                                                 if ( forward && useCache ) { 
    4720                                                         // Seek `elem` from a previously-cached index 
    4721                                                         outerCache = parent[ expando ] || (parent[ expando ] = {}); 
    4722                                                         cache = outerCache[ type ] || []; 
    4723                                                         nodeIndex = cache[0] === dirruns && cache[1]; 
    4724                                                         diff = cache[0] === dirruns && cache[2]; 
    4725                                                         node = nodeIndex && parent.childNodes[ nodeIndex ]; 
    4726  
    4727                                                         while ( (node = ++nodeIndex && node && node[ dir ] || 
    4728  
    4729                                                                 // Fallback to seeking `elem` from the start 
    4730                                                                 (diff = nodeIndex = 0) || start.pop()) ) { 
    4731  
    4732                                                                 // When found, cache indexes on `parent` and break 
    4733                                                                 if ( node.nodeType === 1 && ++diff && node === elem ) { 
    4734                                                                         outerCache[ type ] = [ dirruns, nodeIndex, diff ]; 
    4735                                                                         break; 
    4736                                                                 } 
    4737                                                         } 
    4738  
    4739                                                 // Use previously-cached element index if available 
    4740                                                 } else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) { 
    4741                                                         diff = cache[1]; 
    4742  
    4743                                                 // xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...) 
    4744                                                 } else { 
    4745                                                         // Use the same loop as above to seek `elem` from the start 
    4746                                                         while ( (node = ++nodeIndex && node && node[ dir ] || 
    4747                                                                 (diff = nodeIndex = 0) || start.pop()) ) { 
    4748  
    4749                                                                 if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) { 
    4750                                                                         // Cache the index of each encountered element 
    4751                                                                         if ( useCache ) { 
    4752                                                                                 (node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ]; 
    4753                                                                         } 
    4754  
    4755                                                                         if ( node === elem ) { 
    4756                                                                                 break; 
    4757                                                                         } 
    4758                                                                 } 
    4759                                                         } 
    4760                                                 } 
    4761  
    4762                                                 // Incorporate the offset, then check against cycle size 
    4763                                                 diff -= last; 
    4764                                                 return diff === first || ( diff % first === 0 && diff / first >= 0 ); 
    4765                                         } 
    4766                                 }; 
    4767                 }, 
    4768  
    4769                 "PSEUDO": function( pseudo, argument ) { 
    4770                         // pseudo-class names are case-insensitive 
    4771                         // http://www.w3.org/TR/selectors/#pseudo-classes 
    4772                         // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters 
    4773                         // Remember that setFilters inherits from pseudos 
    4774                         var args, 
    4775                                 fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || 
    4776                                         Sizzle.error( "unsupported pseudo: " + pseudo ); 
    4777  
    4778                         // The user may use createPseudo to indicate that 
    4779                         // arguments are needed to create the filter function 
    4780                         // just as Sizzle does 
    4781                         if ( fn[ expando ] ) { 
    4782                                 return fn( argument ); 
    4783                         } 
    4784  
    4785                         // But maintain support for old signatures 
    4786                         if ( fn.length > 1 ) { 
    4787                                 args = [ pseudo, pseudo, "", argument ]; 
    4788                                 return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? 
    4789                                         markFunction(function( seed, matches ) { 
    4790                                                 var idx, 
    4791                                                         matched = fn( seed, argument ), 
    4792                                                         i = matched.length; 
    4793                                                 while ( i-- ) { 
    4794                                                         idx = indexOf.call( seed, matched[i] ); 
    4795                                                         seed[ idx ] = !( matches[ idx ] = matched[i] ); 
    4796                                                 } 
    4797                                         }) : 
    4798                                         function( elem ) { 
    4799                                                 return fn( elem, 0, args ); 
    4800                                         }; 
    4801                         } 
    4802  
    4803                         return fn; 
    4804                 } 
    4805         }, 
    4806  
    4807         pseudos: { 
    4808                 // Potentially complex pseudos 
    4809                 "not": markFunction(function( selector ) { 
    4810                         // Trim the selector passed to compile 
    4811                         // to avoid treating leading and trailing 
    4812                         // spaces as combinators 
    4813                         var input = [], 
    4814                                 results = [], 
    4815                                 matcher = compile( selector.replace( rtrim, "$1" ) ); 
    4816  
    4817                         return matcher[ expando ] ? 
    4818                                 markFunction(function( seed, matches, context, xml ) { 
    4819                                         var elem, 
    4820                                                 unmatched = matcher( seed, null, xml, [] ), 
    4821                                                 i = seed.length; 
    4822  
    4823                                         // Match elements unmatched by `matcher` 
    4824                                         while ( i-- ) { 
    4825                                                 if ( (elem = unmatched[i]) ) { 
    4826                                                         seed[i] = !(matches[i] = elem); 
    4827                                                 } 
    4828                                         } 
    4829                                 }) : 
    4830                                 function( elem, context, xml ) { 
    4831                                         input[0] = elem; 
    4832                                         matcher( input, null, xml, results ); 
    4833                                         return !results.pop(); 
    4834                                 }; 
    4835                 }), 
    4836  
    4837                 "has": markFunction(function( selector ) { 
    4838                         return function( elem ) { 
    4839                                 return Sizzle( selector, elem ).length > 0; 
    4840                         }; 
    4841                 }), 
    4842  
    4843                 "contains": markFunction(function( text ) { 
    4844                         return function( elem ) { 
    4845                                 return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1; 
    4846                         }; 
    4847                 }), 
    4848  
    4849                 // "Whether an element is represented by a :lang() selector 
    4850                 // is based solely on the element's language value 
    4851                 // being equal to the identifier C, 
    4852                 // or beginning with the identifier C immediately followed by "-". 
    4853                 // The matching of C against the element's language value is performed case-insensitively. 
    4854                 // The identifier C does not have to be a valid language name." 
    4855                 // http://www.w3.org/TR/selectors/#lang-pseudo 
    4856                 "lang": markFunction( function( lang ) { 
    4857                         // lang value must be a valid identifider 
    4858                         if ( !ridentifier.test(lang || "") ) { 
    4859                                 Sizzle.error( "unsupported lang: " + lang ); 
    4860                         } 
    4861                         lang = lang.replace( runescape, funescape ).toLowerCase(); 
    4862                         return function( elem ) { 
    4863                                 var elemLang; 
    4864                                 do { 
    4865                                         if ( (elemLang = documentIsXML ? 
    4866                                                 elem.getAttribute("xml:lang") || elem.getAttribute("lang") : 
    4867                                                 elem.lang) ) { 
    4868  
    4869                                                 elemLang = elemLang.toLowerCase(); 
    4870                                                 return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; 
    4871                                         } 
    4872                                 } while ( (elem = elem.parentNode) && elem.nodeType === 1 ); 
    4873                                 return false; 
    4874                         }; 
    4875                 }), 
    4876  
    4877                 // Miscellaneous 
    4878                 "target": function( elem ) { 
    4879                         var hash = window.location && window.location.hash; 
    4880                         return hash && hash.slice( 1 ) === elem.id; 
    4881                 }, 
    4882  
    4883                 "root": function( elem ) { 
    4884                         return elem === docElem; 
    4885                 }, 
    4886  
    4887                 "focus": function( elem ) { 
    4888                         return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex); 
    4889                 }, 
    4890  
    4891                 // Boolean properties 
    4892                 "enabled": function( elem ) { 
    4893                         return elem.disabled === false; 
    4894                 }, 
    4895  
    4896                 "disabled": function( elem ) { 
    4897                         return elem.disabled === true; 
    4898                 }, 
    4899  
    4900                 "checked": function( elem ) { 
    4901                         // In CSS3, :checked should return both checked and selected elements 
    4902                         // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked 
    4903                         var nodeName = elem.nodeName.toLowerCase(); 
    4904                         return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected); 
    4905                 }, 
    4906  
    4907                 "selected": function( elem ) { 
    4908                         // Accessing this property makes selected-by-default 
    4909                         // options in Safari work properly 
    4910                         if ( elem.parentNode ) { 
    4911                                 elem.parentNode.selectedIndex; 
    4912                         } 
    4913  
    4914                         return elem.selected === true; 
    4915                 }, 
    4916  
    4917                 // Contents 
    4918                 "empty": function( elem ) { 
    4919                         // http://www.w3.org/TR/selectors/#empty-pseudo 
    4920                         // :empty is only affected by element nodes and content nodes(including text(3), cdata(4)), 
    4921                         //   not comment, processing instructions, or others 
    4922                         // Thanks to Diego Perini for the nodeName shortcut 
    4923                         //   Greater than "@" means alpha characters (specifically not starting with "#" or "?") 
    4924                         for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { 
    4925                                 if ( elem.nodeName > "@" || elem.nodeType === 3 || elem.nodeType === 4 ) { 
    4926                                         return false; 
    4927                                 } 
    4928                         } 
    4929                         return true; 
    4930                 }, 
    4931  
    4932                 "parent": function( elem ) { 
    4933                         return !Expr.pseudos["empty"]( elem ); 
    4934                 }, 
    4935  
    4936                 // Element/input types 
    4937                 "header": function( elem ) { 
    4938                         return rheader.test( elem.nodeName ); 
    4939                 }, 
    4940  
    4941                 "input": function( elem ) { 
    4942                         return rinputs.test( elem.nodeName ); 
    4943                 }, 
    4944  
    4945                 "button": function( elem ) { 
    4946                         var name = elem.nodeName.toLowerCase(); 
    4947                         return name === "input" && elem.type === "button" || name === "button"; 
    4948                 }, 
    4949  
    4950                 "text": function( elem ) { 
    4951                         var attr; 
    4952                         // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc) 
    4953                         // use getAttribute instead to test this case 
    4954                         return elem.nodeName.toLowerCase() === "input" && 
    4955                                 elem.type === "text" && 
    4956                                 ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === elem.type ); 
    4957                 }, 
    4958  
    4959                 // Position-in-collection 
    4960                 "first": createPositionalPseudo(function() { 
    4961                         return [ 0 ]; 
    4962                 }), 
    4963  
    4964                 "last": createPositionalPseudo(function( matchIndexes, length ) { 
    4965                         return [ length - 1 ]; 
    4966                 }), 
    4967  
    4968                 "eq": createPositionalPseudo(function( matchIndexes, length, argument ) { 
    4969                         return [ argument < 0 ? argument + length : argument ]; 
    4970                 }), 
    4971  
    4972                 "even": createPositionalPseudo(function( matchIndexes, length ) { 
    4973                         var i = 0; 
    4974                         for ( ; i < length; i += 2 ) { 
    4975                                 matchIndexes.push( i ); 
    4976                         } 
    4977                         return matchIndexes; 
    4978                 }), 
    4979  
    4980                 "odd": createPositionalPseudo(function( matchIndexes, length ) { 
    4981                         var i = 1; 
    4982                         for ( ; i < length; i += 2 ) { 
    4983                                 matchIndexes.push( i ); 
    4984                         } 
    4985                         return matchIndexes; 
    4986                 }), 
    4987  
    4988                 "lt": createPositionalPseudo(function( matchIndexes, length, argument ) { 
    4989                         var i = argument < 0 ? argument + length : argument; 
    4990                         for ( ; --i >= 0; ) { 
    4991                                 matchIndexes.push( i ); 
    4992                         } 
    4993                         return matchIndexes; 
    4994                 }), 
    4995  
    4996                 "gt": createPositionalPseudo(function( matchIndexes, length, argument ) { 
    4997                         var i = argument < 0 ? argument + length : argument; 
    4998                         for ( ; ++i < length; ) { 
    4999                                 matchIndexes.push( i ); 
    5000                         } 
    5001                         return matchIndexes; 
    5002                 }) 
    5003         } 
    5004 }; 
    5005  
    5006 // Add button/input type pseudos 
    5007 for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { 
    5008         Expr.pseudos[ i ] = createInputPseudo( i ); 
    5009 } 
    5010 for ( i in { submit: true, reset: true } ) { 
    5011         Expr.pseudos[ i ] = createButtonPseudo( i ); 
    5012 } 
    5013  
    5014 function tokenize( selector, parseOnly ) { 
    5015         var matched, match, tokens, type, 
    5016                 soFar, groups, preFilters, 
    5017                 cached = tokenCache[ selector + " " ]; 
    5018  
    5019         if ( cached ) { 
    5020                 return parseOnly ? 0 : cached.slice( 0 ); 
    5021         } 
    5022  
    5023         soFar = selector; 
    5024         groups = []; 
    5025         preFilters = Expr.preFilter; 
    5026  
    5027         while ( soFar ) { 
    5028  
    5029                 // Comma and first run 
    5030                 if ( !matched || (match = rcomma.exec( soFar )) ) { 
    5031                         if ( match ) { 
    5032                                 // Don't consume trailing commas as valid 
    5033                                 soFar = soFar.slice( match[0].length ) || soFar; 
    5034                         } 
    5035                         groups.push( tokens = [] ); 
    5036                 } 
    5037  
    5038                 matched = false; 
    5039  
    5040                 // Combinators 
    5041                 if ( (match = rcombinators.exec( soFar )) ) { 
    5042                         matched = match.shift(); 
    5043                         tokens.push( { 
    5044                                 value: matched, 
    5045                                 // Cast descendant combinators to space 
    5046                                 type: match[0].replace( rtrim, " " ) 
    5047                         } ); 
    5048                         soFar = soFar.slice( matched.length ); 
    5049                 } 
    5050  
    5051                 // Filters 
    5052                 for ( type in Expr.filter ) { 
    5053                         if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] || 
    5054                                 (match = preFilters[ type ]( match ))) ) { 
    5055                                 matched = match.shift(); 
    5056                                 tokens.push( { 
    5057                                         value: matched, 
    5058                                         type: type, 
    5059                                         matches: match 
    5060                                 } ); 
    5061                                 soFar = soFar.slice( matched.length ); 
    5062                         } 
    5063                 } 
    5064  
    5065                 if ( !matched ) { 
    5066                         break; 
    5067                 } 
    5068         } 
    5069  
    5070         // Return the length of the invalid excess 
    5071         // if we're just parsing 
    5072         // Otherwise, throw an error or return tokens 
    5073         return parseOnly ? 
    5074                 soFar.length : 
    5075                 soFar ? 
    5076                         Sizzle.error( selector ) : 
    5077                         // Cache the tokens 
    5078                         tokenCache( selector, groups ).slice( 0 ); 
    5079 } 
    5080  
    5081 function toSelector( tokens ) { 
    5082         var i = 0, 
    5083                 len = tokens.length, 
    5084                 selector = ""; 
    5085         for ( ; i < len; i++ ) { 
    5086                 selector += tokens[i].value; 
    5087         } 
    5088         return selector; 
    5089 } 
    5090  
    5091 function addCombinator( matcher, combinator, base ) { 
    5092         var dir = combinator.dir, 
    5093                 checkNonElements = base && dir === "parentNode", 
    5094                 doneName = done++; 
    5095  
    5096         return combinator.first ? 
    5097                 // Check against closest ancestor/preceding element 
    5098                 function( elem, context, xml ) { 
    5099                         while ( (elem = elem[ dir ]) ) { 
    5100                                 if ( elem.nodeType === 1 || checkNonElements ) { 
    5101                                         return matcher( elem, context, xml ); 
    5102                                 } 
    5103                         } 
    5104                 } : 
    5105  
    5106                 // Check against all ancestor/preceding elements 
    5107                 function( elem, context, xml ) { 
    5108                         var data, cache, outerCache, 
    5109                                 dirkey = dirruns + " " + doneName; 
    5110  
    5111                         // We can't set arbitrary data on XML nodes, so they don't benefit from dir caching 
    5112                         if ( xml ) { 
    5113                                 while ( (elem = elem[ dir ]) ) { 
    5114                                         if ( elem.nodeType === 1 || checkNonElements ) { 
    5115                                                 if ( matcher( elem, context, xml ) ) { 
    5116                                                         return true; 
    5117                                                 } 
    5118                                         } 
    5119                                 } 
    5120                         } else { 
    5121                                 while ( (elem = elem[ dir ]) ) { 
    5122                                         if ( elem.nodeType === 1 || checkNonElements ) { 
    5123                                                 outerCache = elem[ expando ] || (elem[ expando ] = {}); 
    5124                                                 if ( (cache = outerCache[ dir ]) && cache[0] === dirkey ) { 
    5125                                                         if ( (data = cache[1]) === true || data === cachedruns ) { 
    5126                                                                 return data === true; 
    5127                                                         } 
    5128                                                 } else { 
    5129                                                         cache = outerCache[ dir ] = [ dirkey ]; 
    5130                                                         cache[1] = matcher( elem, context, xml ) || cachedruns; 
    5131                                                         if ( cache[1] === true ) { 
    5132                                                                 return true; 
    5133                                                         } 
    5134                                                 } 
    5135                                         } 
    5136                                 } 
    5137                         } 
    5138                 }; 
    5139 } 
    5140  
    5141 function elementMatcher( matchers ) { 
    5142         return matchers.length > 1 ? 
    5143                 function( elem, context, xml ) { 
    5144                         var i = matchers.length; 
    5145                         while ( i-- ) { 
    5146                                 if ( !matchers[i]( elem, context, xml ) ) { 
    5147                                         return false; 
    5148                                 } 
    5149                         } 
    5150                         return true; 
    5151                 } : 
    5152                 matchers[0]; 
    5153 } 
    5154  
    5155 function condense( unmatched, map, filter, context, xml ) { 
    5156         var elem, 
    5157                 newUnmatched = [], 
    5158                 i = 0, 
    5159                 len = unmatched.length, 
    5160                 mapped = map != null; 
    5161  
    5162         for ( ; i < len; i++ ) { 
    5163                 if ( (elem = unmatched[i]) ) { 
    5164                         if ( !filter || filter( elem, context, xml ) ) { 
    5165                                 newUnmatched.push( elem ); 
    5166                                 if ( mapped ) { 
    5167                                         map.push( i ); 
    5168                                 } 
    5169                         } 
    5170                 } 
    5171         } 
    5172  
    5173         return newUnmatched; 
    5174 } 
    5175  
    5176 function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { 
    5177         if ( postFilter && !postFilter[ expando ] ) { 
    5178                 postFilter = setMatcher( postFilter ); 
    5179         } 
    5180         if ( postFinder && !postFinder[ expando ] ) { 
    5181                 postFinder = setMatcher( postFinder, postSelector ); 
    5182         } 
    5183         return markFunction(function( seed, results, context, xml ) { 
    5184                 var temp, i, elem, 
    5185                         preMap = [], 
    5186                         postMap = [], 
    5187                         preexisting = results.length, 
    5188  
    5189                         // Get initial elements from seed or context 
    5190                         elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ), 
    5191  
    5192                         // Prefilter to get matcher input, preserving a map for seed-results synchronization 
    5193                         matcherIn = preFilter && ( seed || !selector ) ? 
    5194                                 condense( elems, preMap, preFilter, context, xml ) : 
    5195                                 elems, 
    5196  
    5197                         matcherOut = matcher ? 
    5198                                 // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, 
    5199                                 postFinder || ( seed ? preFilter : preexisting || postFilter ) ? 
    5200  
    5201                                         // ...intermediate processing is necessary 
    5202                                         [] : 
    5203  
    5204                                         // ...otherwise use results directly 
    5205                                         results : 
    5206                                 matcherIn; 
    5207  
    5208                 // Find primary matches 
    5209                 if ( matcher ) { 
    5210                         matcher( matcherIn, matcherOut, context, xml ); 
    5211                 } 
    5212  
    5213                 // Apply postFilter 
    5214                 if ( postFilter ) { 
    5215                         temp = condense( matcherOut, postMap ); 
    5216                         postFilter( temp, [], context, xml ); 
    5217  
    5218                         // Un-match failing elements by moving them back to matcherIn 
    5219                         i = temp.length; 
    5220                         while ( i-- ) { 
    5221                                 if ( (elem = temp[i]) ) { 
    5222                                         matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem); 
    5223                                 } 
    5224                         } 
    5225                 } 
    5226  
    5227                 if ( seed ) { 
    5228                         if ( postFinder || preFilter ) { 
    5229                                 if ( postFinder ) { 
    5230                                         // Get the final matcherOut by condensing this intermediate into postFinder contexts 
    5231                                         temp = []; 
    5232                                         i = matcherOut.length; 
    5233                                         while ( i-- ) { 
    5234                                                 if ( (elem = matcherOut[i]) ) { 
    5235                                                         // Restore matcherIn since elem is not yet a final match 
    5236                                                         temp.push( (matcherIn[i] = elem) ); 
    5237                                                 } 
    5238                                         } 
    5239                                         postFinder( null, (matcherOut = []), temp, xml ); 
    5240                                 } 
    5241  
    5242                                 // Move matched elements from seed to results to keep them synchronized 
    5243                                 i = matcherOut.length; 
    5244                                 while ( i-- ) { 
    5245                                         if ( (elem = matcherOut[i]) && 
    5246                                                 (temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) { 
    5247  
    5248                                                 seed[temp] = !(results[temp] = elem); 
    5249                                         } 
    5250                                 } 
    5251                         } 
    5252  
    5253                 // Add elements to results, through postFinder if defined 
    5254                 } else { 
    5255                         matcherOut = condense( 
    5256                                 matcherOut === results ? 
    5257                                         matcherOut.splice( preexisting, matcherOut.length ) : 
    5258                                         matcherOut 
    5259                         ); 
    5260                         if ( postFinder ) { 
    5261                                 postFinder( null, results, matcherOut, xml ); 
    5262                         } else { 
    5263                                 push.apply( results, matcherOut ); 
    5264                         } 
    5265                 } 
    5266         }); 
    5267 } 
    5268  
    5269 function matcherFromTokens( tokens ) { 
    5270         var checkContext, matcher, j, 
    5271                 len = tokens.length, 
    5272                 leadingRelative = Expr.relative[ tokens[0].type ], 
    5273                 implicitRelative = leadingRelative || Expr.relative[" "], 
    5274                 i = leadingRelative ? 1 : 0, 
    5275  
    5276                 // The foundational matcher ensures that elements are reachable from top-level context(s) 
    5277                 matchContext = addCombinator( function( elem ) { 
    5278                         return elem === checkContext; 
    5279                 }, implicitRelative, true ), 
    5280                 matchAnyContext = addCombinator( function( elem ) { 
    5281                         return indexOf.call( checkContext, elem ) > -1; 
    5282                 }, implicitRelative, true ), 
    5283                 matchers = [ function( elem, context, xml ) { 
    5284                         return ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( 
    5285                                 (checkContext = context).nodeType ? 
    5286                                         matchContext( elem, context, xml ) : 
    5287                                         matchAnyContext( elem, context, xml ) ); 
    5288                 } ]; 
    5289  
    5290         for ( ; i < len; i++ ) { 
    5291                 if ( (matcher = Expr.relative[ tokens[i].type ]) ) { 
    5292                         matchers = [ addCombinator(elementMatcher( matchers ), matcher) ]; 
    5293                 } else { 
    5294                         matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches ); 
    5295  
    5296                         // Return special upon seeing a positional matcher 
    5297                         if ( matcher[ expando ] ) { 
    5298                                 // Find the next relative operator (if any) for proper handling 
    5299                                 j = ++i; 
    5300                                 for ( ; j < len; j++ ) { 
    5301                                         if ( Expr.relative[ tokens[j].type ] ) { 
    5302                                                 break; 
    5303                                         } 
    5304                                 } 
    5305                                 return setMatcher( 
    5306                                         i > 1 && elementMatcher( matchers ), 
    5307                                         i > 1 && toSelector( tokens.slice( 0, i - 1 ) ).replace( rtrim, "$1" ), 
    5308                                         matcher, 
    5309                                         i < j && matcherFromTokens( tokens.slice( i, j ) ), 
    5310                                         j < len && matcherFromTokens( (tokens = tokens.slice( j )) ), 
    5311                                         j < len && toSelector( tokens ) 
    5312                                 ); 
    5313                         } 
    5314                         matchers.push( matcher ); 
    5315                 } 
    5316         } 
    5317  
    5318         return elementMatcher( matchers ); 
    5319 } 
    5320  
    5321 function matcherFromGroupMatchers( elementMatchers, setMatchers ) { 
    5322         // A counter to specify which element is currently being matched 
    5323         var matcherCachedRuns = 0, 
    5324                 bySet = setMatchers.length > 0, 
    5325                 byElement = elementMatchers.length > 0, 
    5326                 superMatcher = function( seed, context, xml, results, expandContext ) { 
    5327                         var elem, j, matcher, 
    5328                                 setMatched = [], 
    5329                                 matchedCount = 0, 
    5330                                 i = "0", 
    5331                                 unmatched = seed && [], 
    5332                                 outermost = expandContext != null, 
    5333                                 contextBackup = outermostContext, 
    5334                                 // We must always have either seed elements or context 
    5335                                 elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ), 
    5336                                 // Use integer dirruns iff this is the outermost matcher 
    5337                                 dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1); 
    5338  
    5339                         if ( outermost ) { 
    5340                                 outermostContext = context !== document && context; 
    5341                                 cachedruns = matcherCachedRuns; 
    5342                         } 
    5343  
    5344                         // Add elements passing elementMatchers directly to results 
    5345                         // Keep `i` a string if there are no elements so `matchedCount` will be "00" below 
    5346                         for ( ; (elem = elems[i]) != null; i++ ) { 
    5347                                 if ( byElement && elem ) { 
    5348                                         j = 0; 
    5349                                         while ( (matcher = elementMatchers[j++]) ) { 
    5350                                                 if ( matcher( elem, context, xml ) ) { 
    5351                                                         results.push( elem ); 
    5352                                                         break; 
    5353                                                 } 
    5354                                         } 
    5355                                         if ( outermost ) { 
    5356                                                 dirruns = dirrunsUnique; 
    5357                                                 cachedruns = ++matcherCachedRuns; 
    5358                                         } 
    5359                                 } 
    5360  
    5361                                 // Track unmatched elements for set filters 
    5362                                 if ( bySet ) { 
    5363                                         // They will have gone through all possible matchers 
    5364                                         if ( (elem = !matcher && elem) ) { 
    5365                                                 matchedCount--; 
    5366                                         } 
    5367  
    5368                                         // Lengthen the array for every element, matched or not 
    5369                                         if ( seed ) { 
    5370                                                 unmatched.push( elem ); 
    5371                                         } 
    5372                                 } 
    5373                         } 
    5374  
    5375                         // Apply set filters to unmatched elements 
    5376                         matchedCount += i; 
    5377                         if ( bySet && i !== matchedCount ) { 
    5378                                 j = 0; 
    5379                                 while ( (matcher = setMatchers[j++]) ) { 
    5380                                         matcher( unmatched, setMatched, context, xml ); 
    5381                                 } 
    5382  
    5383                                 if ( seed ) { 
    5384                                         // Reintegrate element matches to eliminate the need for sorting 
    5385                                         if ( matchedCount > 0 ) { 
    5386                                                 while ( i-- ) { 
    5387                                                         if ( !(unmatched[i] || setMatched[i]) ) { 
    5388                                                                 setMatched[i] = pop.call( results ); 
    5389                                                         } 
    5390                                                 } 
    5391                                         } 
    5392  
    5393                                         // Discard index placeholder values to get only actual matches 
    5394                                         setMatched = condense( setMatched ); 
    5395                                 } 
    5396  
    5397                                 // Add matches to results 
    5398                                 push.apply( results, setMatched ); 
    5399  
    5400                                 // Seedless set matches succeeding multiple successful matchers stipulate sorting 
    5401                                 if ( outermost && !seed && setMatched.length > 0 && 
    5402                                         ( matchedCount + setMatchers.length ) > 1 ) { 
    5403  
    5404                                         Sizzle.uniqueSort( results ); 
    5405                                 } 
    5406                         } 
    5407  
    5408                         // Override manipulation of globals by nested matchers 
    5409                         if ( outermost ) { 
    5410                                 dirruns = dirrunsUnique; 
    5411                                 outermostContext = contextBackup; 
    5412                         } 
    5413  
    5414                         return unmatched; 
    5415                 }; 
    5416  
    5417         return bySet ? 
    5418                 markFunction( superMatcher ) : 
    5419                 superMatcher; 
    5420 } 
    5421  
    5422 compile = Sizzle.compile = function( selector, group /* Internal Use Only */ ) { 
    5423         var i, 
    5424                 setMatchers = [], 
    5425                 elementMatchers = [], 
    5426                 cached = compilerCache[ selector + " " ]; 
    5427  
    5428         if ( !cached ) { 
    5429                 // Generate a function of recursive functions that can be used to check each element 
    5430                 if ( !group ) { 
    5431                         group = tokenize( selector ); 
    5432                 } 
    5433                 i = group.length; 
    5434                 while ( i-- ) { 
    5435                         cached = matcherFromTokens( group[i] ); 
    5436                         if ( cached[ expando ] ) { 
    5437                                 setMatchers.push( cached ); 
    5438                         } else { 
    5439                                 elementMatchers.push( cached ); 
    5440                         } 
    5441                 } 
    5442  
    5443                 // Cache the compiled function 
    5444                 cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) ); 
    5445         } 
    5446         return cached; 
    5447 }; 
    5448  
    5449 function multipleContexts( selector, contexts, results ) { 
    5450         var i = 0, 
    5451                 len = contexts.length; 
    5452         for ( ; i < len; i++ ) { 
    5453                 Sizzle( selector, contexts[i], results ); 
    5454         } 
    5455         return results; 
    5456 } 
    5457  
    5458 function select( selector, context, results, seed ) { 
    5459         var i, tokens, token, type, find, 
    5460                 match = tokenize( selector ); 
    5461  
    5462         if ( !seed ) { 
    5463                 // Try to minimize operations if there is only one group 
    5464                 if ( match.length === 1 ) { 
    5465  
    5466                         // Take a shortcut and set the context if the root selector is an ID 
    5467                         tokens = match[0] = match[0].slice( 0 ); 
    5468                         if ( tokens.length > 2 && (token = tokens[0]).type === "ID" && 
    5469                                         context.nodeType === 9 && !documentIsXML && 
    5470                                         Expr.relative[ tokens[1].type ] ) { 
    5471  
    5472                                 context = Expr.find["ID"]( token.matches[0].replace( runescape, funescape ), context )[0]; 
    5473                                 if ( !context ) { 
    5474                                         return results; 
    5475                                 } 
    5476  
    5477                                 selector = selector.slice( tokens.shift().value.length ); 
    5478                         } 
    5479  
    5480                         // Fetch a seed set for right-to-left matching 
    5481                         i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length; 
    5482                         while ( i-- ) { 
    5483                                 token = tokens[i]; 
    5484  
    5485                                 // Abort if we hit a combinator 
    5486                                 if ( Expr.relative[ (type = token.type) ] ) { 
    5487                                         break; 
    5488                                 } 
    5489                                 if ( (find = Expr.find[ type ]) ) { 
    5490                                         // Search, expanding context for leading sibling combinators 
    5491                                         if ( (seed = find( 
    5492                                                 token.matches[0].replace( runescape, funescape ), 
    5493                                                 rsibling.test( tokens[0].type ) && context.parentNode || context 
    5494                                         )) ) { 
    5495  
    5496                                                 // If seed is empty or no tokens remain, we can return early 
    5497                                                 tokens.splice( i, 1 ); 
    5498                                                 selector = seed.length && toSelector( tokens ); 
    5499                                                 if ( !selector ) { 
    5500                                                         push.apply( results, slice.call( seed, 0 ) ); 
    5501                                                         return results; 
    5502                                                 } 
    5503  
    5504                                                 break; 
    5505                                         } 
    5506                                 } 
    5507                         } 
    5508                 } 
    5509         } 
    5510  
    5511         // Compile and execute a filtering function 
    5512         // Provide `match` to avoid retokenization if we modified the selector above 
    5513         compile( selector, match )( 
    5514                 seed, 
    5515                 context, 
    5516                 documentIsXML, 
    5517                 results, 
    5518                 rsibling.test( selector ) 
    5519         ); 
    5520         return results; 
    5521 } 
    5522  
    5523 // Deprecated 
    5524 Expr.pseudos["nth"] = Expr.pseudos["eq"]; 
    5525  
    5526 // Easy API for creating new setFilters 
    5527 function setFilters() {} 
    5528 Expr.filters = setFilters.prototype = Expr.pseudos; 
    5529 Expr.setFilters = new setFilters(); 
    5530  
    5531 // Initialize with the default document 
    5532 setDocument(); 
    5533  
    5534 // Override sizzle attribute retrieval 
    5535 Sizzle.attr = jQuery.attr; 
    5536 jQuery.find = Sizzle; 
    5537 jQuery.expr = Sizzle.selectors; 
    5538 jQuery.expr[":"] = jQuery.expr.pseudos; 
    5539 jQuery.unique = Sizzle.uniqueSort; 
    5540 jQuery.text = Sizzle.getText; 
    5541 jQuery.isXMLDoc = Sizzle.isXML; 
    5542 jQuery.contains = Sizzle.contains; 
    5543  
    5544  
    5545 })( window ); 
    5546 var runtil = /Until$/, 
     5722var isSimple = /^.[^:#\[\.,]*$/, 
    55475723        rparentsprev = /^(?:parents|prev(?:Until|All))/, 
    5548         isSimple = /^.[^:#\[\.,]*$/, 
    55495724        rneedsContext = jQuery.expr.match.needsContext, 
    55505725        // methods guaranteed to produce a unique set when starting from a unique set 
     
    55585733jQuery.fn.extend({ 
    55595734        find: function( selector ) { 
    5560                 var i, ret, self, 
    5561                         len = this.length; 
     5735                var i, 
     5736                        ret = [], 
     5737                        self = this, 
     5738                        len = self.length; 
    55625739 
    55635740                if ( typeof selector !== "string" ) { 
    5564                         self = this; 
    55655741                        return this.pushStack( jQuery( selector ).filter(function() { 
    55665742                                for ( i = 0; i < len; i++ ) { 
     
    55725748                } 
    55735749 
    5574                 ret = []; 
    55755750                for ( i = 0; i < len; i++ ) { 
    5576                         jQuery.find( selector, this[ i ], ret ); 
     5751                        jQuery.find( selector, self[ i ], ret ); 
    55775752                } 
    55785753 
    55795754                // Needed because $( selector, context ) becomes $( context ).find( selector ) 
    55805755                ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret ); 
    5581                 ret.selector = ( this.selector ? this.selector + " " : "" ) + selector; 
     5756                ret.selector = this.selector ? this.selector + " " + selector : selector; 
    55825757                return ret; 
    55835758        }, 
     
    55985773 
    55995774        not: function( selector ) { 
    5600                 return this.pushStack( winnow(this, selector, false) ); 
     5775                return this.pushStack( winnow(this, selector || [], true) ); 
    56015776        }, 
    56025777 
    56035778        filter: function( selector ) { 
    5604                 return this.pushStack( winnow(this, selector, true) ); 
     5779                return this.pushStack( winnow(this, selector || [], false) ); 
    56055780        }, 
    56065781 
    56075782        is: function( selector ) { 
    5608                 return !!selector && ( 
    5609                         typeof selector === "string" ? 
    5610                                 // If this is a positional/relative selector, check membership in the returned set 
    5611                                 // so $("p:first").is("p:last") won't return true for a doc with two "p". 
    5612                                 rneedsContext.test( selector ) ? 
    5613                                         jQuery( selector, this.context ).index( this[0] ) >= 0 : 
    5614                                         jQuery.filter( selector, this ).length > 0 : 
    5615                                 this.filter( selector ).length > 0 ); 
     5783                return !!winnow( 
     5784                        this, 
     5785 
     5786                        // If this is a positional/relative selector, check membership in the returned set 
     5787                        // so $("p:first").is("p:last") won't return true for a doc with two "p". 
     5788                        typeof selector === "string" && rneedsContext.test( selector ) ? 
     5789                                jQuery( selector ) : 
     5790                                selector || [], 
     5791                        false 
     5792                ).length; 
    56165793        }, 
    56175794 
     
    56265803 
    56275804                for ( ; i < l; i++ ) { 
    5628                         cur = this[i]; 
    5629  
    5630                         while ( cur && cur.ownerDocument && cur !== context && cur.nodeType !== 11 ) { 
    5631                                 if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) { 
    5632                                         ret.push( cur ); 
     5805                        for ( cur = this[i]; cur && cur !== context; cur = cur.parentNode ) { 
     5806                                // Always skip document fragments 
     5807                                if ( cur.nodeType < 11 && (pos ? 
     5808                                        pos.index(cur) > -1 : 
     5809 
     5810                                        // Don't pass non-elements to Sizzle 
     5811                                        cur.nodeType === 1 && 
     5812                                                jQuery.find.matchesSelector(cur, selectors)) ) { 
     5813 
     5814                                        cur = ret.push( cur ); 
    56335815                                        break; 
    56345816                                } 
    5635                                 cur = cur.parentNode; 
    56365817                        } 
    56375818                } 
     
    56765857}); 
    56775858 
    5678 jQuery.fn.andSelf = jQuery.fn.addBack; 
    5679  
    56805859function sibling( cur, dir ) { 
    56815860        do { 
     
    57305909                var ret = jQuery.map( this, fn, until ); 
    57315910 
    5732                 if ( !runtil.test( name ) ) { 
     5911                if ( name.slice( -5 ) !== "Until" ) { 
    57335912                        selector = until; 
    57345913                } 
     
    57385917                } 
    57395918