| /*! |
| * Sizzle CSS Selector Engine v1.10.17-pre |
| * http://sizzlejs.com/ |
| * |
| * Copyright 2013 jQuery Foundation, Inc. and other contributors |
| * Released under the MIT license |
| * http://jquery.org/license |
| * |
| * Date: 2014-01-13 |
| */ |
| (function( window ) { |
| |
| var i, |
| support, |
| Expr, |
| getText, |
| isXML, |
| compile, |
| outermostContext, |
| sortInput, |
| hasDuplicate, |
| |
| // Local document vars |
| setDocument, |
| document, |
| docElem, |
| documentIsHTML, |
| rbuggyQSA, |
| rbuggyMatches, |
| matches, |
| contains, |
| |
| // Instance-specific data |
| expando = "sizzle" + -(new Date()), |
| preferredDoc = window.document, |
| dirruns = 0, |
| done = 0, |
| classCache = createCache(), |
| tokenCache = createCache(), |
| compilerCache = createCache(), |
| sortOrder = function( a, b ) { |
| if ( a === b ) { |
| hasDuplicate = true; |
| } |
| return 0; |
| }, |
| |
| // General-purpose constants |
| strundefined = typeof undefined, |
| MAX_NEGATIVE = 1 << 31, |
| |
| // Instance methods |
| hasOwn = ({}).hasOwnProperty, |
| arr = [], |
| pop = arr.pop, |
| push_native = arr.push, |
| push = arr.push, |
| slice = arr.slice, |
| // Use a stripped-down indexOf if we can't use a native one |
| indexOf = arr.indexOf || function( elem ) { |
| var i = 0, |
| len = this.length; |
| for ( ; i < len; i++ ) { |
| if ( this[i] === elem ) { |
| return i; |
| } |
| } |
| return -1; |
| }, |
| |
| booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", |
| |
| // Regular expressions |
| |
| // Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace |
| whitespace = "[\\x20\\t\\r\\n\\f]", |
| // http://www.w3.org/TR/css3-syntax/#characters |
| characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+", |
| |
| // Loosely modeled on CSS identifier characters |
| // An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors |
| // Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier |
| identifier = characterEncoding.replace( "w", "w#" ), |
| |
| // Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors |
| attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace + |
| "*(?:([*^$|!~]?=)" + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]", |
| |
| // Prefer arguments quoted, |
| // then not containing pseudos/brackets, |
| // then attribute selectors/non-parenthetical expressions, |
| // then anything else |
| // These preferences are here to reduce the number of selectors |
| // needing tokenize in the PSEUDO preFilter |
| pseudos = ":(" + characterEncoding + ")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" + attributes.replace( 3, 8 ) + ")*)|.*)\\)|)", |
| |
| // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter |
| rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ), |
| |
| rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), |
| rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ), |
| |
| rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ), |
| |
| rpseudo = new RegExp( pseudos ), |
| ridentifier = new RegExp( "^" + identifier + "$" ), |
| |
| matchExpr = { |
| "ID": new RegExp( "^#(" + characterEncoding + ")" ), |
| "CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ), |
| "TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ), |
| "ATTR": new RegExp( "^" + attributes ), |
| "PSEUDO": new RegExp( "^" + pseudos ), |
| "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + |
| "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + |
| "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), |
| "bool": new RegExp( "^(?:" + booleans + ")$", "i" ), |
| // For use in libraries implementing .is() |
| // We use this for POS matching in `select` |
| "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + |
| whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) |
| }, |
| |
| rinputs = /^(?:input|select|textarea|button)$/i, |
| rheader = /^h\d$/i, |
| |
| rnative = /^[^{]+\{\s*\[native \w/, |
| |
| // Easily-parseable/retrievable ID or TAG or CLASS selectors |
| rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, |
| |
| rsibling = /[+~]/, |
| rescape = /'|\\/g, |
| |
| // CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters |
| runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ), |
| funescape = function( _, escaped, escapedWhitespace ) { |
| var high = "0x" + escaped - 0x10000; |
| // NaN means non-codepoint |
| // Support: Firefox |
| // Workaround erroneous numeric interpretation of +"0x" |
| return high !== high || escapedWhitespace ? |
| escaped : |
| high < 0 ? |
| // BMP codepoint |
| String.fromCharCode( high + 0x10000 ) : |
| // Supplemental Plane codepoint (surrogate pair) |
| String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); |
| }; |
| |
| // Optimize for push.apply( _, NodeList ) |
| try { |
| push.apply( |
| (arr = slice.call( preferredDoc.childNodes )), |
| preferredDoc.childNodes |
| ); |
| // Support: Android<4.0 |
| // Detect silently failing push.apply |
| arr[ preferredDoc.childNodes.length ].nodeType; |
| } catch ( e ) { |
| push = { apply: arr.length ? |
| |
| // Leverage slice if possible |
| function( target, els ) { |
| push_native.apply( target, slice.call(els) ); |
| } : |
| |
| // Support: IE<9 |
| // Otherwise append directly |
| function( target, els ) { |
| var j = target.length, |
| i = 0; |
| // Can't trust NodeList.length |
| while ( (target[j++] = els[i++]) ) {} |
| target.length = j - 1; |
| } |
| }; |
| } |
| |
| function Sizzle( selector, context, results, seed ) { |
| var match, elem, m, nodeType, |
| // QSA vars |
| i, groups, old, nid, newContext, newSelector; |
| |
| if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) { |
| setDocument( context ); |
| } |
| |
| context = context || document; |
| results = results || []; |
| |
| if ( !selector || typeof selector !== "string" ) { |
| return results; |
| } |
| |
| if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) { |
| return []; |
| } |
| |
| if ( documentIsHTML && !seed ) { |
| |
| // Shortcuts |
| if ( (match = rquickExpr.exec( selector )) ) { |
| // Speed-up: Sizzle("#ID") |
| if ( (m = match[1]) ) { |
| if ( nodeType === 9 ) { |
| elem = context.getElementById( m ); |
| // Check parentNode to catch when Blackberry 4.6 returns |
| // nodes that are no longer in the document (jQuery #6963) |
| if ( elem && elem.parentNode ) { |
| // Handle the case where IE, Opera, and Webkit return items |
| // by name instead of ID |
| if ( elem.id === m ) { |
| results.push( elem ); |
| return results; |
| } |
| } else { |
| return results; |
| } |
| } else { |
| // Context is not a document |
| if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) && |
| contains( context, elem ) && elem.id === m ) { |
| results.push( elem ); |
| return results; |
| } |
| } |
| |
| // Speed-up: Sizzle("TAG") |
| } else if ( match[2] ) { |
| push.apply( results, context.getElementsByTagName( selector ) ); |
| return results; |
| |
| // Speed-up: Sizzle(".CLASS") |
| } else if ( (m = match[3]) && support.getElementsByClassName && context.getElementsByClassName ) { |
| push.apply( results, context.getElementsByClassName( m ) ); |
| return results; |
| } |
| } |
| |
| // QSA path |
| if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) { |
| nid = old = expando; |
| newContext = context; |
| newSelector = nodeType === 9 && selector; |
| |
| // qSA works strangely on Element-rooted queries |
| // We can work around this by specifying an extra ID on the root |
| // and working up from there (Thanks to Andrew Dupont for the technique) |
| // IE 8 doesn't work on object elements |
| if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) { |
| groups = tokenize( selector ); |
| |
| if ( (old = context.getAttribute("id")) ) { |
| nid = old.replace( rescape, "\\$&" ); |
| } else { |
| context.setAttribute( "id", nid ); |
| } |
| nid = "[id='" + nid + "'] "; |
| |
| i = groups.length; |
| while ( i-- ) { |
| groups[i] = nid + toSelector( groups[i] ); |
| } |
| newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context; |
| newSelector = groups.join(","); |
| } |
| |
| if ( newSelector ) { |
| try { |
| push.apply( results, |
| newContext.querySelectorAll( newSelector ) |
| ); |
| return results; |
| } catch(qsaError) { |
| } finally { |
| if ( !old ) { |
| context.removeAttribute("id"); |
| } |
| } |
| } |
| } |
| } |
| |
| // All others |
| return select( selector.replace( rtrim, "$1" ), context, results, seed ); |
| } |
| |
| /** |
| * Create key-value caches of limited size |
| * @returns {Function(string, Object)} Returns the Object data after storing it on itself with |
| * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) |
| * deleting the oldest entry |
| */ |
| function createCache() { |
| var keys = []; |
| |
| function cache( key, value ) { |
| // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) |
| if ( keys.push( key + " " ) > Expr.cacheLength ) { |
| // Only keep the most recent entries |
| delete cache[ keys.shift() ]; |
| } |
| return (cache[ key + " " ] = value); |
| } |
| return cache; |
| } |
| |
| /** |
| * Mark a function for special use by Sizzle |
| * @param {Function} fn The function to mark |
| */ |
| function markFunction( fn ) { |
| fn[ expando ] = true; |
| return fn; |
| } |
| |
| /** |
| * Support testing using an element |
| * @param {Function} fn Passed the created div and expects a boolean result |
| */ |
| function assert( fn ) { |
| var div = document.createElement("div"); |
| |
| try { |
| return !!fn( div ); |
| } catch (e) { |
| return false; |
| } finally { |
| // Remove from its parent by default |
| if ( div.parentNode ) { |
| div.parentNode.removeChild( div ); |
| } |
| // release memory in IE |
| div = null; |
| } |
| } |
| |
| /** |
| * Adds the same handler for all of the specified attrs |
| * @param {String} attrs Pipe-separated list of attributes |
| * @param {Function} handler The method that will be applied |
| */ |
| function addHandle( attrs, handler ) { |
| var arr = attrs.split("|"), |
| i = attrs.length; |
| |
| while ( i-- ) { |
| Expr.attrHandle[ arr[i] ] = handler; |
| } |
| } |
| |
| /** |
| * Checks document order of two siblings |
| * @param {Element} a |
| * @param {Element} b |
| * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b |
| */ |
| function siblingCheck( a, b ) { |
| var cur = b && a, |
| diff = cur && a.nodeType === 1 && b.nodeType === 1 && |
| ( ~b.sourceIndex || MAX_NEGATIVE ) - |
| ( ~a.sourceIndex || MAX_NEGATIVE ); |
| |
| // Use IE sourceIndex if available on both nodes |
| if ( diff ) { |
| return diff; |
| } |
| |
| // Check if b follows a |
| if ( cur ) { |
| while ( (cur = cur.nextSibling) ) { |
| if ( cur === b ) { |
| return -1; |
| } |
| } |
| } |
| |
| return a ? 1 : -1; |
| } |
| |
| /** |
| * Returns a function to use in pseudos for input types |
| * @param {String} type |
| */ |
| function createInputPseudo( type ) { |
| return function( elem ) { |
| var name = elem.nodeName.toLowerCase(); |
| return name === "input" && elem.type === type; |
| }; |
| } |
| |
| /** |
| * Returns a function to use in pseudos for buttons |
| * @param {String} type |
| */ |
| function createButtonPseudo( type ) { |
| return function( elem ) { |
| var name = elem.nodeName.toLowerCase(); |
| return (name === "input" || name === "button") && elem.type === type; |
| }; |
| } |
| |
| /** |
| * Returns a function to use in pseudos for positionals |
| * @param {Function} fn |
| */ |
| function createPositionalPseudo( fn ) { |
| return markFunction(function( argument ) { |
| argument = +argument; |
| return markFunction(function( seed, matches ) { |
| var j, |
| matchIndexes = fn( [], seed.length, argument ), |
| i = matchIndexes.length; |
| |
| // Match elements found at the specified indexes |
| while ( i-- ) { |
| if ( seed[ (j = matchIndexes[i]) ] ) { |
| seed[j] = !(matches[j] = seed[j]); |
| } |
| } |
| }); |
| }); |
| } |
| |
| /** |
| * Checks a node for validity as a Sizzle context |
| * @param {Element|Object=} context |
| * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value |
| */ |
| function testContext( context ) { |
| return context && typeof context.getElementsByTagName !== strundefined && context; |
| } |
| |
| // Expose support vars for convenience |
| support = Sizzle.support = {}; |
| |
| /** |
| * Detects XML nodes |
| * @param {Element|Object} elem An element or a document |
| * @returns {Boolean} True iff elem is a non-HTML XML node |
| */ |
| isXML = Sizzle.isXML = function( elem ) { |
| // documentElement is verified for cases where it doesn't yet exist |
| // (such as loading iframes in IE - #4833) |
| var documentElement = elem && (elem.ownerDocument || elem).documentElement; |
| return documentElement ? documentElement.nodeName !== "HTML" : false; |
| }; |
| |
| /** |
| * Sets document-related variables once based on the current document |
| * @param {Element|Object} [doc] An element or document object to use to set the document |
| * @returns {Object} Returns the current document |
| */ |
| setDocument = Sizzle.setDocument = function( node ) { |
| var hasCompare, |
| doc = node ? node.ownerDocument || node : preferredDoc, |
| parent = doc.defaultView; |
| |
| // If no document and documentElement is available, return |
| if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) { |
| return document; |
| } |
| |
| // Set our document |
| document = doc; |
| docElem = doc.documentElement; |
| |
| // Support tests |
| documentIsHTML = !isXML( doc ); |
| |
| // Support: IE>8 |
| // If iframe document is assigned to "document" variable and if iframe has been reloaded, |
| // IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936 |
| // IE6-8 do not support the defaultView property so parent will be undefined |
| if ( parent && parent !== parent.top ) { |
| // IE11 does not have attachEvent, so all must suffer |
| if ( parent.addEventListener ) { |
| parent.addEventListener( "unload", function() { |
| setDocument(); |
| }, false ); |
| } else if ( parent.attachEvent ) { |
| parent.attachEvent( "onunload", function() { |
| setDocument(); |
| }); |
| } |
| } |
| |
| /* Attributes |
| ---------------------------------------------------------------------- */ |
| |
| // Support: IE<8 |
| // Verify that getAttribute really returns attributes and not properties (excepting IE8 booleans) |
| support.attributes = assert(function( div ) { |
| div.className = "i"; |
| return !div.getAttribute("className"); |
| }); |
| |
| /* getElement(s)By* |
| ---------------------------------------------------------------------- */ |
| |
| // Check if getElementsByTagName("*") returns only elements |
| support.getElementsByTagName = assert(function( div ) { |
| div.appendChild( doc.createComment("") ); |
| return !div.getElementsByTagName("*").length; |
| }); |
| |
| // Check if getElementsByClassName can be trusted |
| support.getElementsByClassName = rnative.test( doc.getElementsByClassName ) && assert(function( div ) { |
| div.innerHTML = "<div class='a'></div><div class='a i'></div>"; |
| |
| // Support: Safari<4 |
| // Catch class over-caching |
| div.firstChild.className = "i"; |
| // Support: Opera<10 |
| // Catch gEBCN failure to find non-leading classes |
| return div.getElementsByClassName("i").length === 2; |
| }); |
| |
| // Support: IE<10 |
| // Check if getElementById returns elements by name |
| // The broken getElementById methods don't pick up programatically-set names, |
| // so use a roundabout getElementsByName test |
| support.getById = assert(function( div ) { |
| docElem.appendChild( div ).id = expando; |
| return !doc.getElementsByName || !doc.getElementsByName( expando ).length; |
| }); |
| |
| // ID find and filter |
| if ( support.getById ) { |
| Expr.find["ID"] = function( id, context ) { |
| if ( typeof context.getElementById !== strundefined && documentIsHTML ) { |
| var m = context.getElementById( id ); |
| // Check parentNode to catch when Blackberry 4.6 returns |
| // nodes that are no longer in the document #6963 |
| return m && m.parentNode ? [m] : []; |
| } |
| }; |
| Expr.filter["ID"] = function( id ) { |
| var attrId = id.replace( runescape, funescape ); |
| return function( elem ) { |
| return elem.getAttribute("id") === attrId; |
| }; |
| }; |
| } else { |
| // Support: IE6/7 |
| // getElementById is not reliable as a find shortcut |
| delete Expr.find["ID"]; |
| |
| Expr.filter["ID"] = function( id ) { |
| var attrId = id.replace( runescape, funescape ); |
| return function( elem ) { |
| var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id"); |
| return node && node.value === attrId; |
| }; |
| }; |
| } |
| |
| // Tag |
| Expr.find["TAG"] = support.getElementsByTagName ? |
| function( tag, context ) { |
| if ( typeof context.getElementsByTagName !== strundefined ) { |
| return context.getElementsByTagName( tag ); |
| } |
| } : |
| function( tag, context ) { |
| var elem, |
| tmp = [], |
| i = 0, |
| results = context.getElementsByTagName( tag ); |
| |
| // Filter out possible comments |
| if ( tag === "*" ) { |
| while ( (elem = results[i++]) ) { |
| if ( elem.nodeType === 1 ) { |
| tmp.push( elem ); |
| } |
| } |
| |
| return tmp; |
| } |
| return results; |
| }; |
| |
| // Class |
| Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) { |
| if ( typeof context.getElementsByClassName !== strundefined && documentIsHTML ) { |
| return context.getElementsByClassName( className ); |
| } |
| }; |
| |
| /* QSA/matchesSelector |
| ---------------------------------------------------------------------- */ |
| |
| // QSA and matchesSelector support |
| |
| // matchesSelector(:active) reports false when true (IE9/Opera 11.5) |
| rbuggyMatches = []; |
| |
| // qSa(:focus) reports false when true (Chrome 21) |
| // We allow this because of a bug in IE8/9 that throws an error |
| // whenever `document.activeElement` is accessed on an iframe |
| // So, we allow :focus to pass through QSA all the time to avoid the IE error |
| // See http://bugs.jquery.com/ticket/13378 |
| rbuggyQSA = []; |
| |
| if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) { |
| // Build QSA regex |
| // Regex strategy adopted from Diego Perini |
| assert(function( div ) { |
| // Select is set to empty string on purpose |
| // This is to test IE's treatment of not explicitly |
| // setting a boolean content attribute, |
| // since its presence should be enough |
| // http://bugs.jquery.com/ticket/12359 |
| div.innerHTML = "<select t=''><option selected=''></option></select>"; |
| |
| // Support: IE8, Opera 10-12 |
| // Nothing should be selected when empty strings follow ^= or $= or *= |
| if ( div.querySelectorAll("[t^='']").length ) { |
| rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" ); |
| } |
| |
| // Support: IE8 |
| // Boolean attributes and "value" are not treated correctly |
| if ( !div.querySelectorAll("[selected]").length ) { |
| rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); |
| } |
| |
| // Webkit/Opera - :checked should return selected option elements |
| // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked |
| // IE8 throws error here and will not see later tests |
| if ( !div.querySelectorAll(":checked").length ) { |
| rbuggyQSA.push(":checked"); |
| } |
| }); |
| |
| assert(function( div ) { |
| // Support: Windows 8 Native Apps |
| // The type and name attributes are restricted during .innerHTML assignment |
| var input = doc.createElement("input"); |
| input.setAttribute( "type", "hidden" ); |
| div.appendChild( input ).setAttribute( "name", "D" ); |
| |
| // Support: IE8 |
| // Enforce case-sensitivity of name attribute |
| if ( div.querySelectorAll("[name=d]").length ) { |
| rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" ); |
| } |
| |
| // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) |
| // IE8 throws error here and will not see later tests |
| if ( !div.querySelectorAll(":enabled").length ) { |
| rbuggyQSA.push( ":enabled", ":disabled" ); |
| } |
| |
| // Opera 10-11 does not throw on post-comma invalid pseudos |
| div.querySelectorAll("*,:x"); |
| rbuggyQSA.push(",.*:"); |
| }); |
| } |
| |
| if ( (support.matchesSelector = rnative.test( (matches = docElem.webkitMatchesSelector || |
| docElem.mozMatchesSelector || |
| docElem.oMatchesSelector || |
| docElem.msMatchesSelector) )) ) { |
| |
| assert(function( div ) { |
| // Check to see if it's possible to do matchesSelector |
| // on a disconnected node (IE 9) |
| support.disconnectedMatch = matches.call( div, "div" ); |
| |
| // This should fail with an exception |
| // Gecko does not error, returns false instead |
| matches.call( div, "[s!='']:x" ); |
| rbuggyMatches.push( "!=", pseudos ); |
| }); |
| } |
| |
| rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") ); |
| rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") ); |
| |
| /* Contains |
| ---------------------------------------------------------------------- */ |
| hasCompare = rnative.test( docElem.compareDocumentPosition ); |
| |
| // Element contains another |
| // Purposefully does not implement inclusive descendent |
| // As in, an element does not contain itself |
| contains = hasCompare || rnative.test( docElem.contains ) ? |
| function( a, b ) { |
| var adown = a.nodeType === 9 ? a.documentElement : a, |
| bup = b && b.parentNode; |
| return a === bup || !!( bup && bup.nodeType === 1 && ( |
| adown.contains ? |
| adown.contains( bup ) : |
| a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 |
| )); |
| } : |
| function( a, b ) { |
| if ( b ) { |
| while ( (b = b.parentNode) ) { |
| if ( b === a ) { |
| return true; |
| } |
| } |
| } |
| return false; |
| }; |
| |
| /* Sorting |
| ---------------------------------------------------------------------- */ |
| |
| // Document order sorting |
| sortOrder = hasCompare ? |
| function( a, b ) { |
| |
| // Flag for duplicate removal |
| if ( a === b ) { |
| hasDuplicate = true; |
| return 0; |
| } |
| |
| // Sort on method existence if only one input has compareDocumentPosition |
| var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; |
| if ( compare ) { |
| return compare; |
| } |
| |
| // Calculate position if both inputs belong to the same document |
| compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ? |
| a.compareDocumentPosition( b ) : |
| |
| // Otherwise we know they are disconnected |
| 1; |
| |
| // Disconnected nodes |
| if ( compare & 1 || |
| (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) { |
| |
| // Choose the first element that is related to our preferred document |
| if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) { |
| return -1; |
| } |
| if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) { |
| return 1; |
| } |
| |
| // Maintain original order |
| return sortInput ? |
| ( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) : |
| 0; |
| } |
| |
| return compare & 4 ? -1 : 1; |
| } : |
| function( a, b ) { |
| // Exit early if the nodes are identical |
| if ( a === b ) { |
| hasDuplicate = true; |
| return 0; |
| } |
| |
| var cur, |
| i = 0, |
| aup = a.parentNode, |
| bup = b.parentNode, |
| ap = [ a ], |
| bp = [ b ]; |
| |
| // Parentless nodes are either documents or disconnected |
| if ( !aup || !bup ) { |
| return a === doc ? -1 : |
| b === doc ? 1 : |
| aup ? -1 : |
| bup ? 1 : |
| sortInput ? |
| ( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) : |
| 0; |
| |
| // If the nodes are siblings, we can do a quick check |
| } else if ( aup === bup ) { |
| return siblingCheck( a, b ); |
| } |
| |
| // Otherwise we need full lists of their ancestors for comparison |
| cur = a; |
| while ( (cur = cur.parentNode) ) { |
| ap.unshift( cur ); |
| } |
| cur = b; |
| while ( (cur = cur.parentNode) ) { |
| bp.unshift( cur ); |
| } |
| |
| // Walk down the tree looking for a discrepancy |
| while ( ap[i] === bp[i] ) { |
| i++; |
| } |
| |
| return i ? |
| // Do a sibling check if the nodes have a common ancestor |
| siblingCheck( ap[i], bp[i] ) : |
| |
| // Otherwise nodes in our document sort first |
| ap[i] === preferredDoc ? -1 : |
| bp[i] === preferredDoc ? 1 : |
| 0; |
| }; |
| |
| return doc; |
| }; |
| |
| Sizzle.matches = function( expr, elements ) { |
| return Sizzle( expr, null, null, elements ); |
| }; |
| |
| Sizzle.matchesSelector = function( elem, expr ) { |
| // Set document vars if needed |
| if ( ( elem.ownerDocument || elem ) !== document ) { |
| setDocument( elem ); |
| } |
| |
| // Make sure that attribute selectors are quoted |
| expr = expr.replace( rattributeQuotes, "='$1']" ); |
| |
| if ( support.matchesSelector && documentIsHTML && |
| ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) && |
| ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { |
| |
| try { |
| var ret = matches.call( elem, expr ); |
| |
| // IE 9's matchesSelector returns false on disconnected nodes |
| if ( ret || support.disconnectedMatch || |
| // As well, disconnected nodes are said to be in a document |
| // fragment in IE 9 |
| elem.document && elem.document.nodeType !== 11 ) { |
| return ret; |
| } |
| } catch(e) {} |
| } |
| |
| return Sizzle( expr, document, null, [elem] ).length > 0; |
| }; |
| |
| Sizzle.contains = function( context, elem ) { |
| // Set document vars if needed |
| if ( ( context.ownerDocument || context ) !== document ) { |
| setDocument( context ); |
| } |
| return contains( context, elem ); |
| }; |
| |
| Sizzle.attr = function( elem, name ) { |
| // Set document vars if needed |
| if ( ( elem.ownerDocument || elem ) !== document ) { |
| setDocument( elem ); |
| } |
| |
| var fn = Expr.attrHandle[ name.toLowerCase() ], |
| // Don't get fooled by Object.prototype properties (jQuery #13807) |
| val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? |
| fn( elem, name, !documentIsHTML ) : |
| undefined; |
| |
| return val !== undefined ? |
| val : |
| support.attributes || !documentIsHTML ? |
| elem.getAttribute( name ) : |
| (val = elem.getAttributeNode(name)) && val.specified ? |
| val.value : |
| null; |
| }; |
| |
| Sizzle.error = function( msg ) { |
| throw new Error( "Syntax error, unrecognized expression: " + msg ); |
| }; |
| |
| /** |
| * Document sorting and removing duplicates |
| * @param {ArrayLike} results |
| */ |
| Sizzle.uniqueSort = function( results ) { |
| var elem, |
| duplicates = [], |
| j = 0, |
| i = 0; |
| |
| // Unless we *know* we can detect duplicates, assume their presence |
| hasDuplicate = !support.detectDuplicates; |
| sortInput = !support.sortStable && results.slice( 0 ); |
| results.sort( sortOrder ); |
| |
| if ( hasDuplicate ) { |
| while ( (elem = results[i++]) ) { |
| if ( elem === results[ i ] ) { |
| j = duplicates.push( i ); |
| } |
| } |
| while ( j-- ) { |
| results.splice( duplicates[ j ], 1 ); |
| } |
| } |
| |
| // Clear input after sorting to release objects |
| // See https://github.com/jquery/sizzle/pull/225 |
| sortInput = null; |
| |
| return results; |
| }; |
| |
| /** |
| * Utility function for retrieving the text value of an array of DOM nodes |
| * @param {Array|Element} elem |
| */ |
| getText = Sizzle.getText = function( elem ) { |
| var node, |
| ret = "", |
| i = 0, |
| nodeType = elem.nodeType; |
| |
| if ( !nodeType ) { |
| // If no nodeType, this is expected to be an array |
| while ( (node = elem[i++]) ) { |
| // Do not traverse comment nodes |
| ret += getText( node ); |
| } |
| } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { |
| // Use textContent for elements |
| // innerText usage removed for consistency of new lines (jQuery #11153) |
| if ( typeof elem.textContent === "string" ) { |
| return elem.textContent; |
| } else { |
| // Traverse its children |
| for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { |
| ret += getText( elem ); |
| } |
| } |
| } else if ( nodeType === 3 || nodeType === 4 ) { |
| return elem.nodeValue; |
| } |
| // Do not include comment or processing instruction nodes |
| |
| return ret; |
| }; |
| |
| Expr = Sizzle.selectors = { |
| |
| // Can be adjusted by the user |
| cacheLength: 50, |
| |
| createPseudo: markFunction, |
| |
| match: matchExpr, |
| |
| attrHandle: {}, |
| |
| find: {}, |
| |
| relative: { |
| ">": { dir: "parentNode", first: true }, |
| " ": { dir: "parentNode" }, |
| "+": { dir: "previousSibling", first: true }, |
| "~": { dir: "previousSibling" } |
| }, |
| |
| preFilter: { |
| "ATTR": function( match ) { |
| match[1] = match[1].replace( runescape, funescape ); |
| |
| // Move the given value to match[3] whether quoted or unquoted |
| match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape ); |
| |
| if ( match[2] === "~=" ) { |
| match[3] = " " + match[3] + " "; |
| } |
| |
| return match.slice( 0, 4 ); |
| }, |
| |
| "CHILD": function( match ) { |
| /* matches from matchExpr["CHILD"] |
| 1 type (only|nth|...) |
| 2 what (child|of-type) |
| 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) |
| 4 xn-component of xn+y argument ([+-]?\d*n|) |
| 5 sign of xn-component |
| 6 x of xn-component |
| 7 sign of y-component |
| 8 y of y-component |
| */ |
| match[1] = match[1].toLowerCase(); |
| |
| if ( match[1].slice( 0, 3 ) === "nth" ) { |
| // nth-* requires argument |
| if ( !match[3] ) { |
| Sizzle.error( match[0] ); |
| } |
| |
| // numeric x and y parameters for Expr.filter.CHILD |
| // remember that false/true cast respectively to 0/1 |
| match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) ); |
| match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" ); |
| |
| // other types prohibit arguments |
| } else if ( match[3] ) { |
| Sizzle.error( match[0] ); |
| } |
| |
| return match; |
| }, |
| |
| "PSEUDO": function( match ) { |
| var excess, |
| unquoted = !match[5] && match[2]; |
| |
| if ( matchExpr["CHILD"].test( match[0] ) ) { |
| return null; |
| } |
| |
| // Accept quoted arguments as-is |
| if ( match[3] && match[4] !== undefined ) { |
| match[2] = match[4]; |
| |
| // Strip excess characters from unquoted arguments |
| } else if ( unquoted && rpseudo.test( unquoted ) && |
| // Get excess from tokenize (recursively) |
| (excess = tokenize( unquoted, true )) && |
| // advance to the next closing parenthesis |
| (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) { |
| |
| // excess is a negative index |
| match[0] = match[0].slice( 0, excess ); |
| match[2] = unquoted.slice( 0, excess ); |
| } |
| |
| // Return only captures needed by the pseudo filter method (type and argument) |
| return match.slice( 0, 3 ); |
| } |
| }, |
| |
| filter: { |
| |
| "TAG": function( nodeNameSelector ) { |
| var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); |
| return nodeNameSelector === "*" ? |
| function() { return true; } : |
| function( elem ) { |
| return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; |
| }; |
| }, |
| |
| "CLASS": function( className ) { |
| var pattern = classCache[ className + " " ]; |
| |
| return pattern || |
| (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) && |
| classCache( className, function( elem ) { |
| return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute("class") || "" ); |
| }); |
| }, |
| |
| "ATTR": function( name, operator, check ) { |
| return function( elem ) { |
| var result = Sizzle.attr( elem, name ); |
| |
| if ( result == null ) { |
| return operator === "!="; |
| } |
| if ( !operator ) { |
| return true; |
| } |
| |
| result += ""; |
| |
| return operator === "=" ? result === check : |
| operator === "!=" ? result !== check : |
| operator === "^=" ? check && result.indexOf( check ) === 0 : |
| operator === "*=" ? check && result.indexOf( check ) > -1 : |
| operator === "$=" ? check && result.slice( -check.length ) === check : |
| operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 : |
| operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" : |
| false; |
| }; |
| }, |
| |
| "CHILD": function( type, what, argument, first, last ) { |
| var simple = type.slice( 0, 3 ) !== "nth", |
| forward = type.slice( -4 ) !== "last", |
| ofType = what === "of-type"; |
| |
| return first === 1 && last === 0 ? |
| |
| // Shortcut for :nth-*(n) |
| function( elem ) { |
| return !!elem.parentNode; |
| } : |
| |
| function( elem, context, xml ) { |
| var cache, outerCache, node, diff, nodeIndex, start, |
| dir = simple !== forward ? "nextSibling" : "previousSibling", |
| parent = elem.parentNode, |
| name = ofType && elem.nodeName.toLowerCase(), |
| useCache = !xml && !ofType; |
| |
| if ( parent ) { |
| |
| // :(first|last|only)-(child|of-type) |
| if ( simple ) { |
| while ( dir ) { |
| node = elem; |
| while ( (node = node[ dir ]) ) { |
| if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) { |
| return false; |
| } |
| } |
| // Reverse direction for :only-* (if we haven't yet done so) |
| start = dir = type === "only" && !start && "nextSibling"; |
| } |
| return true; |
| } |
| |
| start = [ forward ? parent.firstChild : parent.lastChild ]; |
| |
| // non-xml :nth-child(...) stores cache data on `parent` |
| if ( forward && useCache ) { |
| // Seek `elem` from a previously-cached index |
| outerCache = parent[ expando ] || (parent[ expando ] = {}); |
| cache = outerCache[ type ] || []; |
| nodeIndex = cache[0] === dirruns && cache[1]; |
| diff = cache[0] === dirruns && cache[2]; |
| node = nodeIndex && parent.childNodes[ nodeIndex ]; |
| |
| while ( (node = ++nodeIndex && node && node[ dir ] || |
| |
| // Fallback to seeking `elem` from the start |
| (diff = nodeIndex = 0) || start.pop()) ) { |
| |
| // When found, cache indexes on `parent` and break |
| if ( node.nodeType === 1 && ++diff && node === elem ) { |
| outerCache[ type ] = [ dirruns, nodeIndex, diff ]; |
| break; |
| } |
| } |
| |
| // Use previously-cached element index if available |
| } else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) { |
| diff = cache[1]; |
| |
| // xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...) |
| } else { |
| // Use the same loop as above to seek `elem` from the start |
| while ( (node = ++nodeIndex && node && node[ dir ] || |
| (diff = nodeIndex = 0) || start.pop()) ) { |
| |
| if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) { |
| // Cache the index of each encountered element |
| if ( useCache ) { |
| (node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ]; |
| } |
| |
| if ( node === elem ) { |
| break; |
| } |
| } |
| } |
| } |
| |
| // Incorporate the offset, then check against cycle size |
| diff -= last; |
| return diff === first || ( diff % first === 0 && diff / first >= 0 ); |
| } |
| }; |
| }, |
| |
| "PSEUDO": function( pseudo, argument ) { |
| // pseudo-class names are case-insensitive |
| // http://www.w3.org/TR/selectors/#pseudo-classes |
| // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters |
| // Remember that setFilters inherits from pseudos |
| var args, |
| fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || |
| Sizzle.error( "unsupported pseudo: " + pseudo ); |
| |
| // The user may use createPseudo to indicate that |
| // arguments are needed to create the filter function |
| // just as Sizzle does |
| if ( fn[ expando ] ) { |
| return fn( argument ); |
| } |
| |
| // But maintain support for old signatures |
| if ( fn.length > 1 ) { |
| args = [ pseudo, pseudo, "", argument ]; |
| return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? |
| markFunction(function( seed, matches ) { |
| var idx, |
| matched = fn( seed, argument ), |
| i = matched.length; |
| while ( i-- ) { |
| idx = indexOf.call( seed, matched[i] ); |
| seed[ idx ] = !( matches[ idx ] = matched[i] ); |
| } |
| }) : |
| function( elem ) { |
| return fn( elem, 0, args ); |
| }; |
| } |
| |
| return fn; |
| } |
| }, |
| |
| pseudos: { |
| // Potentially complex pseudos |
| "not": markFunction(function( selector ) { |
| // Trim the selector passed to compile |
| // to avoid treating leading and trailing |
| // spaces as combinators |
| var input = [], |
| results = [], |
| matcher = compile( selector.replace( rtrim, "$1" ) ); |
| |
| return matcher[ expando ] ? |
| markFunction(function( seed, matches, context, xml ) { |
| var elem, |
| unmatched = matcher( seed, null, xml, [] ), |
| i = seed.length; |
| |
| // Match elements unmatched by `matcher` |
| while ( i-- ) { |
| if ( (elem = unmatched[i]) ) { |
| seed[i] = !(matches[i] = elem); |
| } |
| } |
| }) : |
| function( elem, context, xml ) { |
| input[0] = elem; |
| matcher( input, null, xml, results ); |
| return !results.pop(); |
| }; |
| }), |
| |
| "has": markFunction(function( selector ) { |
| return function( elem ) { |
| return Sizzle( selector, elem ).length > 0; |
| }; |
| }), |
| |
| "contains": markFunction(function( text ) { |
| return function( elem ) { |
| return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1; |
| }; |
| }), |
| |
| // "Whether an element is represented by a :lang() selector |
| // is based solely on the element's language value |
| // being equal to the identifier C, |
| // or beginning with the identifier C immediately followed by "-". |
| // The matching of C against the element's language value is performed case-insensitively. |
| // The identifier C does not have to be a valid language name." |
| // http://www.w3.org/TR/selectors/#lang-pseudo |
| "lang": markFunction( function( lang ) { |
| // lang value must be a valid identifier |
| if ( !ridentifier.test(lang || "") ) { |
| Sizzle.error( "unsupported lang: " + lang ); |
| } |
| lang = lang.replace( runescape, funescape ).toLowerCase(); |
| return function( elem ) { |
| var elemLang; |
| do { |
| if ( (elemLang = documentIsHTML ? |
| elem.lang : |
| elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) { |
| |
| elemLang = elemLang.toLowerCase(); |
| return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; |
| } |
| } while ( (elem = elem.parentNode) && elem.nodeType === 1 ); |
| return false; |
| }; |
| }), |
| |
| // Miscellaneous |
| "target": function( elem ) { |
| var hash = window.location && window.location.hash; |
| return hash && hash.slice( 1 ) === elem.id; |
| }, |
| |
| "root": function( elem ) { |
| return elem === docElem; |
| }, |
| |
| "focus": function( elem ) { |
| return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex); |
| }, |
| |
| // Boolean properties |
| "enabled": function( elem ) { |
| return elem.disabled === false; |
| }, |
| |
| "disabled": function( elem ) { |
| return elem.disabled === true; |
| }, |
| |
| "checked": function( elem ) { |
| // In CSS3, :checked should return both checked and selected elements |
| // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked |
| var nodeName = elem.nodeName.toLowerCase(); |
| return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected); |
| }, |
| |
| "selected": function( elem ) { |
| // Accessing this property makes selected-by-default |
| // options in Safari work properly |
| if ( elem.parentNode ) { |
| elem.parentNode.selectedIndex; |
| } |
| |
| return elem.selected === true; |
| }, |
| |
| // Contents |
| "empty": function( elem ) { |
| // http://www.w3.org/TR/selectors/#empty-pseudo |
| // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), |
| // but not by others (comment: 8; processing instruction: 7; etc.) |
| // nodeType < 6 works because attributes (2) do not appear as children |
| for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { |
| if ( elem.nodeType < 6 ) { |
| return false; |
| } |
| } |
| return true; |
| }, |
| |
| "parent": function( elem ) { |
| return !Expr.pseudos["empty"]( elem ); |
| }, |
| |
| // Element/input types |
| "header": function( elem ) { |
| return rheader.test( elem.nodeName ); |
| }, |
| |
| "input": function( elem ) { |
| return rinputs.test( elem.nodeName ); |
| }, |
| |
| "button": function( elem ) { |
| var name = elem.nodeName.toLowerCase(); |
| return name === "input" && elem.type === "button" || name === "button"; |
| }, |
| |
| "text": function( elem ) { |
| var attr; |
| return elem.nodeName.toLowerCase() === "input" && |
| elem.type === "text" && |
| |
| // Support: IE<8 |
| // New HTML5 attribute values (e.g., "search") appear with elem.type === "text" |
| ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" ); |
| }, |
| |
| // Position-in-collection |
| "first": createPositionalPseudo(function() { |
| return [ 0 ]; |
| }), |
| |
| "last": createPositionalPseudo(function( matchIndexes, length ) { |
| return [ length - 1 ]; |
| }), |
| |
| "eq": createPositionalPseudo(function( matchIndexes, length, argument ) { |
| return [ argument < 0 ? argument + length : argument ]; |
| }), |
| |
| "even": createPositionalPseudo(function( matchIndexes, length ) { |
| var i = 0; |
| for ( ; i < length; i += 2 ) { |
| matchIndexes.push( i ); |
| } |
| return matchIndexes; |
| }), |
| |
| "odd": createPositionalPseudo(function( matchIndexes, length ) { |
| var i = 1; |
| for ( ; i < length; i += 2 ) { |
| matchIndexes.push( i ); |
| } |
| return matchIndexes; |
| }), |
| |
| "lt": createPositionalPseudo(function( matchIndexes, length, argument ) { |
| var i = argument < 0 ? argument + length : argument; |
| for ( ; --i >= 0; ) { |
| matchIndexes.push( i ); |
| } |
| return matchIndexes; |
| }), |
| |
| "gt": createPositionalPseudo(function( matchIndexes, length, argument ) { |
| var i = argument < 0 ? argument + length : argument; |
| for ( ; ++i < length; ) { |
| matchIndexes.push( i ); |
| } |
| return matchIndexes; |
| }) |
| } |
| }; |
| |
| Expr.pseudos["nth"] = Expr.pseudos["eq"]; |
| |
| // Add button/input type pseudos |
| for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { |
| Expr.pseudos[ i ] = createInputPseudo( i ); |
| } |
| for ( i in { submit: true, reset: true } ) { |
| Expr.pseudos[ i ] = createButtonPseudo( i ); |
| } |
| |
| // Easy API for creating new setFilters |
| function setFilters() {} |
| setFilters.prototype = Expr.filters = Expr.pseudos; |
| Expr.setFilters = new setFilters(); |
| |
| function tokenize( selector, parseOnly ) { |
| var matched, match, tokens, type, |
| soFar, groups, preFilters, |
| cached = tokenCache[ selector + " " ]; |
| |
| if ( cached ) { |
| return parseOnly ? 0 : cached.slice( 0 ); |
| } |
| |
| soFar = selector; |
| groups = []; |
| preFilters = Expr.preFilter; |
| |
| while ( soFar ) { |
| |
| // Comma and first run |
| if ( !matched || (match = rcomma.exec( soFar )) ) { |
| if ( match ) { |
| // Don't consume trailing commas as valid |
| soFar = soFar.slice( match[0].length ) || soFar; |
| } |
| groups.push( (tokens = []) ); |
| } |
| |
| matched = false; |
| |
| // Combinators |
| if ( (match = rcombinators.exec( soFar )) ) { |
| matched = match.shift(); |
| tokens.push({ |
| value: matched, |
| // Cast descendant combinators to space |
| type: match[0].replace( rtrim, " " ) |
| }); |
| soFar = soFar.slice( matched.length ); |
| } |
| |
| // Filters |
| for ( type in Expr.filter ) { |
| if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] || |
| (match = preFilters[ type ]( match ))) ) { |
| matched = match.shift(); |
| tokens.push({ |
| value: matched, |
| type: type, |
| matches: match |
| }); |
| soFar = soFar.slice( matched.length ); |
| } |
| } |
| |
| if ( !matched ) { |
| break; |
| } |
| } |
| |
| // Return the length of the invalid excess |
| // if we're just parsing |
| // Otherwise, throw an error or return tokens |
| return parseOnly ? |
| soFar.length : |
| soFar ? |
| Sizzle.error( selector ) : |
| // Cache the tokens |
| tokenCache( selector, groups ).slice( 0 ); |
| } |
| |
| function toSelector( tokens ) { |
| var i = 0, |
| len = tokens.length, |
| selector = ""; |
| for ( ; i < len; i++ ) { |
| selector += tokens[i].value; |
| } |
| return selector; |
| } |
| |
| function addCombinator( matcher, combinator, base ) { |
| var dir = combinator.dir, |
| checkNonElements = base && dir === "parentNode", |
| doneName = done++; |
| |
| return combinator.first ? |
| // Check against closest ancestor/preceding element |
| function( elem, context, xml ) { |
| while ( (elem = elem[ dir ]) ) { |
| if ( elem.nodeType === 1 || checkNonElements ) { |
| return matcher( elem, context, xml ); |
| } |
| } |
| } : |
| |
| // Check against all ancestor/preceding elements |
| function( elem, context, xml ) { |
| var oldCache, outerCache, |
| newCache = [ dirruns, doneName ]; |
| |
| // We can't set arbitrary data on XML nodes, so they don't benefit from dir caching |
| if ( xml ) { |
| while ( (elem = elem[ dir ]) ) { |
| if ( elem.nodeType === 1 || checkNonElements ) { |
| if ( matcher( elem, context, xml ) ) { |
| return true; |
| } |
| } |
| } |
| } else { |
| while ( (elem = elem[ dir ]) ) { |
| if ( elem.nodeType === 1 || checkNonElements ) { |
| outerCache = elem[ expando ] || (elem[ expando ] = {}); |
| if ( (oldCache = outerCache[ dir ]) && |
| oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { |
| |
| // Assign to newCache so results back-propagate to previous elements |
| return (newCache[ 2 ] = oldCache[ 2 ]); |
| } else { |
| // Reuse newcache so results back-propagate to previous elements |
| outerCache[ dir ] = newCache; |
| |
| // A match means we're done; a fail means we have to keep checking |
| if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) { |
| return true; |
| } |
| } |
| } |
| } |
| } |
| }; |
| } |
| |
| function elementMatcher( matchers ) { |
| return matchers.length > 1 ? |
| function( elem, context, xml ) { |
| var i = matchers.length; |
| while ( i-- ) { |
| if ( !matchers[i]( elem, context, xml ) ) { |
| return false; |
| } |
| } |
| return true; |
| } : |
| matchers[0]; |
| } |
| |
| function condense( unmatched, map, filter, context, xml ) { |
| var elem, |
| newUnmatched = [], |
| i = 0, |
| len = unmatched.length, |
| mapped = map != null; |
| |
| for ( ; i < len; i++ ) { |
| if ( (elem = unmatched[i]) ) { |
| if ( !filter || filter( elem, context, xml ) ) { |
| newUnmatched.push( elem ); |
| if ( mapped ) { |
| map.push( i ); |
| } |
| } |
| } |
| } |
| |
| return newUnmatched; |
| } |
| |
| function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { |
| if ( postFilter && !postFilter[ expando ] ) { |
| postFilter = setMatcher( postFilter ); |
| } |
| if ( postFinder && !postFinder[ expando ] ) { |
| postFinder = setMatcher( postFinder, postSelector ); |
| } |
| return markFunction(function( seed, results, context, xml ) { |
| var temp, i, elem, |
| preMap = [], |
| postMap = [], |
| preexisting = results.length, |
| |
| // Get initial elements from seed or context |
| elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ), |
| |
| // Prefilter to get matcher input, preserving a map for seed-results synchronization |
| matcherIn = preFilter && ( seed || !selector ) ? |
| condense( elems, preMap, preFilter, context, xml ) : |
| elems, |
| |
| matcherOut = matcher ? |
| // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, |
| postFinder || ( seed ? preFilter : preexisting || postFilter ) ? |
| |
| // ...intermediate processing is necessary |
| [] : |
| |
| // ...otherwise use results directly |
| results : |
| matcherIn; |
| |
| // Find primary matches |
| if ( matcher ) { |
| matcher( matcherIn, matcherOut, context, xml ); |
| } |
| |
| // Apply postFilter |
| if ( postFilter ) { |
| temp = condense( matcherOut, postMap ); |
| postFilter( temp, [], context, xml ); |
| |
| // Un-match failing elements by moving them back to matcherIn |
| i = temp.length; |
| while ( i-- ) { |
| if ( (elem = temp[i]) ) { |
| matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem); |
| } |
| } |
| } |
| |
| if ( seed ) { |
| if ( postFinder || preFilter ) { |
| if ( postFinder ) { |
| // Get the final matcherOut by condensing this intermediate into postFinder contexts |
| temp = []; |
| i = matcherOut.length; |
| while ( i-- ) { |
| if ( (elem = matcherOut[i]) ) { |
| // Restore matcherIn since elem is not yet a final match |
| temp.push( (matcherIn[i] = elem) ); |
| } |
| } |
| postFinder( null, (matcherOut = []), temp, xml ); |
| } |
| |
| // Move matched elements from seed to results to keep them synchronized |
| i = matcherOut.length; |
| while ( i-- ) { |
| if ( (elem = matcherOut[i]) && |
| (temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) { |
| |
| seed[temp] = !(results[temp] = elem); |
| } |
| } |
| } |
| |
| // Add elements to results, through postFinder if defined |
| } else { |
| matcherOut = condense( |
| matcherOut === results ? |
| matcherOut.splice( preexisting, matcherOut.length ) : |
| matcherOut |
| ); |
| if ( postFinder ) { |
| postFinder( null, results, matcherOut, xml ); |
| } else { |
| push.apply( results, matcherOut ); |
| } |
| } |
| }); |
| } |
| |
| function matcherFromTokens( tokens ) { |
| var checkContext, matcher, j, |
| len = tokens.length, |
| leadingRelative = Expr.relative[ tokens[0].type ], |
| implicitRelative = leadingRelative || Expr.relative[" "], |
| i = leadingRelative ? 1 : 0, |
| |
| // The foundational matcher ensures that elements are reachable from top-level context(s) |
| matchContext = addCombinator( function( elem ) { |
| return elem === checkContext; |
| }, implicitRelative, true ), |
| matchAnyContext = addCombinator( function( elem ) { |
| return indexOf.call( checkContext, elem ) > -1; |
| }, implicitRelative, true ), |
| matchers = [ function( elem, context, xml ) { |
| return ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( |
| (checkContext = context).nodeType ? |
| matchContext( elem, context, xml ) : |
| matchAnyContext( elem, context, xml ) ); |
| } ]; |
| |
| for ( ; i < len; i++ ) { |
| if ( (matcher = Expr.relative[ tokens[i].type ]) ) { |
| matchers = [ addCombinator(elementMatcher( matchers ), matcher) ]; |
| } else { |
| matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches ); |
| |
| // Return special upon seeing a positional matcher |
| if ( matcher[ expando ] ) { |
| // Find the next relative operator (if any) for proper handling |
| j = ++i; |
| for ( ; j < len; j++ ) { |
| if ( Expr.relative[ tokens[j].type ] ) { |
| break; |
| } |
| } |
| return setMatcher( |
| i > 1 && elementMatcher( matchers ), |
| i > 1 && toSelector( |
| // If the preceding token was a descendant combinator, insert an implicit any-element `*` |
| tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" }) |
| ).replace( rtrim, "$1" ), |
| matcher, |
| i < j && matcherFromTokens( tokens.slice( i, j ) ), |
| j < len && matcherFromTokens( (tokens = tokens.slice( j )) ), |
| j < len && toSelector( tokens ) |
| ); |
| } |
| matchers.push( matcher ); |
| } |
| } |
| |
| return elementMatcher( matchers ); |
| } |
| |
| function matcherFromGroupMatchers( elementMatchers, setMatchers ) { |
| var bySet = setMatchers.length > 0, |
| byElement = elementMatchers.length > 0, |
| superMatcher = function( seed, context, xml, results, outermost ) { |
| var elem, j, matcher, |
| matchedCount = 0, |
| i = "0", |
| unmatched = seed && [], |
| setMatched = [], |
| contextBackup = outermostContext, |
| // We must always have either seed elements or outermost context |
| elems = seed || byElement && Expr.find["TAG"]( "*", outermost ), |
| // Use integer dirruns iff this is the outermost matcher |
| dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1), |
| len = elems.length; |
| |
| if ( outermost ) { |
| outermostContext = context !== document && context; |
| } |
| |
| // Add elements passing elementMatchers directly to results |
| // Keep `i` a string if there are no elements so `matchedCount` will be "00" below |
| // Support: IE<9, Safari |
| // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id |
| for ( ; i !== len && (elem = elems[i]) != null; i++ ) { |
| if ( byElement && elem ) { |
| j = 0; |
| while ( (matcher = elementMatchers[j++]) ) { |
| if ( matcher( elem, context, xml ) ) { |
| results.push( elem ); |
| break; |
| } |
| } |
| if ( outermost ) { |
| dirruns = dirrunsUnique; |
| } |
| } |
| |
| // Track unmatched elements for set filters |
| if ( bySet ) { |
| // They will have gone through all possible matchers |
| if ( (elem = !matcher && elem) ) { |
| matchedCount--; |
| } |
| |
| // Lengthen the array for every element, matched or not |
| if ( seed ) { |
| unmatched.push( elem ); |
| } |
| } |
| } |
| |
| // Apply set filters to unmatched elements |
| matchedCount += i; |
| if ( bySet && i !== matchedCount ) { |
| j = 0; |
| while ( (matcher = setMatchers[j++]) ) { |
| matcher( unmatched, setMatched, context, xml ); |
| } |
| |
| if ( seed ) { |
| // Reintegrate element matches to eliminate the need for sorting |
| if ( matchedCount > 0 ) { |
| while ( i-- ) { |
| if ( !(unmatched[i] || setMatched[i]) ) { |
| setMatched[i] = pop.call( results ); |
| } |
| } |
| } |
| |
| // Discard index placeholder values to get only actual matches |
| setMatched = condense( setMatched ); |
| } |
| |
| // Add matches to results |
| push.apply( results, setMatched ); |
| |
| // Seedless set matches succeeding multiple successful matchers stipulate sorting |
| if ( outermost && !seed && setMatched.length > 0 && |
| ( matchedCount + setMatchers.length ) > 1 ) { |
| |
| Sizzle.uniqueSort( results ); |
| } |
| } |
| |
| // Override manipulation of globals by nested matchers |
| if ( outermost ) { |
| dirruns = dirrunsUnique; |
| outermostContext = contextBackup; |
| } |
| |
| return unmatched; |
| }; |
| |
| return bySet ? |
| markFunction( superMatcher ) : |
| superMatcher; |
| } |
| |
| compile = Sizzle.compile = function( selector, group /* Internal Use Only */ ) { |
| var i, |
| setMatchers = [], |
| elementMatchers = [], |
| cached = compilerCache[ selector + " " ]; |
| |
| if ( !cached ) { |
| // Generate a function of recursive functions that can be used to check each element |
| if ( !group ) { |
| group = tokenize( selector ); |
| } |
| i = group.length; |
| while ( i-- ) { |
| cached = matcherFromTokens( group[i] ); |
| if ( cached[ expando ] ) { |
| setMatchers.push( cached ); |
| } else { |
| elementMatchers.push( cached ); |
| } |
| } |
| |
| // Cache the compiled function |
| cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) ); |
| } |
| return cached; |
| }; |
| |
| function multipleContexts( selector, contexts, results ) { |
| var i = 0, |
| len = contexts.length; |
| for ( ; i < len; i++ ) { |
| Sizzle( selector, contexts[i], results ); |
| } |
| return results; |
| } |
| |
| function select( selector, context, results, seed ) { |
| var i, tokens, token, type, find, |
| match = tokenize( selector ); |
| |
| if ( !seed ) { |
| // Try to minimize operations if there is only one group |
| if ( match.length === 1 ) { |
| |
| // Take a shortcut and set the context if the root selector is an ID |
| tokens = match[0] = match[0].slice( 0 ); |
| if ( tokens.length > 2 && (token = tokens[0]).type === "ID" && |
| support.getById && context.nodeType === 9 && documentIsHTML && |
| Expr.relative[ tokens[1].type ] ) { |
| |
| context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0]; |
| if ( !context ) { |
| return results; |
| } |
| selector = selector.slice( tokens.shift().value.length ); |
| } |
| |
| // Fetch a seed set for right-to-left matching |
| i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length; |
| while ( i-- ) { |
| token = tokens[i]; |
| |
| // Abort if we hit a combinator |
| if ( Expr.relative[ (type = token.type) ] ) { |
| break; |
| } |
| if ( (find = Expr.find[ type ]) ) { |
| // Search, expanding context for leading sibling combinators |
| if ( (seed = find( |
| token.matches[0].replace( runescape, funescape ), |
| rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context |
| )) ) { |
| |
| // If seed is empty or no tokens remain, we can return early |
| tokens.splice( i, 1 ); |
| selector = seed.length && toSelector( tokens ); |
| if ( !selector ) { |
| push.apply( results, seed ); |
| return results; |
| } |
| |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| // Compile and execute a filtering function |
| // Provide `match` to avoid retokenization if we modified the selector above |
| compile( selector, match )( |
| seed, |
| context, |
| !documentIsHTML, |
| results, |
| rsibling.test( selector ) && testContext( context.parentNode ) || context |
| ); |
| return results; |
| } |
| |
| // One-time assignments |
| |
| // Sort stability |
| support.sortStable = expando.split("").sort( sortOrder ).join("") === expando; |
| |
| // Support: Chrome<14 |
| // Always assume duplicates if they aren't passed to the comparison function |
| support.detectDuplicates = !!hasDuplicate; |
| |
| // Initialize against the default document |
| setDocument(); |
| |
| // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27) |
| // Detached nodes confoundingly follow *each other* |
| support.sortDetached = assert(function( div1 ) { |
| // Should return 1, but returns 4 (following) |
| return div1.compareDocumentPosition( document.createElement("div") ) & 1; |
| }); |
| |
| // Support: IE<8 |
| // Prevent attribute/property "interpolation" |
| // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx |
| if ( !assert(function( div ) { |
| div.innerHTML = "<a href='#'></a>"; |
| return div.firstChild.getAttribute("href") === "#" ; |
| }) ) { |
| addHandle( "type|href|height|width", function( elem, name, isXML ) { |
| if ( !isXML ) { |
| return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 ); |
| } |
| }); |
| } |
| |
| // Support: IE<9 |
| // Use defaultValue in place of getAttribute("value") |
| if ( !support.attributes || !assert(function( div ) { |
| div.innerHTML = "<input/>"; |
| div.firstChild.setAttribute( "value", "" ); |
| return div.firstChild.getAttribute( "value" ) === ""; |
| }) ) { |
| addHandle( "value", function( elem, name, isXML ) { |
| if ( !isXML && elem.nodeName.toLowerCase() === "input" ) { |
| return elem.defaultValue; |
| } |
| }); |
| } |
| |
| // Support: IE<9 |
| // Use getAttributeNode to fetch booleans when getAttribute lies |
| if ( !assert(function( div ) { |
| return div.getAttribute("disabled") == null; |
| }) ) { |
| addHandle( booleans, function( elem, name, isXML ) { |
| var val; |
| if ( !isXML ) { |
| return elem[ name ] === true ? name.toLowerCase() : |
| (val = elem.getAttributeNode( name )) && val.specified ? |
| val.value : |
| null; |
| } |
| }); |
| } |
| |
| // EXPOSE |
| if ( typeof define === "function" && define.amd ) { |
| define(function() { return Sizzle; }); |
| // Sizzle requires that there be a global window in Common-JS like environments |
| } else if ( typeof module !== "undefined" && module.exports ) { |
| module.exports = Sizzle; |
| } else { |
| window.Sizzle = Sizzle; |
| } |
| // EXPOSE |
| |
| })( window ); |