Tests: revert concurrency group change

[jquery.git] / src / selector.js

import { jQuery } from "./core.js";
import { nodeName } from "./core/nodeName.js";
import { document as preferredDoc } from "./var/document.js";
import { indexOf } from "./var/indexOf.js";
import { pop } from "./var/pop.js";
import { push } from "./var/push.js";
import { whitespace } from "./var/whitespace.js";
import { rbuggyQSA } from "./selector/rbuggyQSA.js";
import { rtrimCSS } from "./var/rtrimCSS.js";
import { isIE } from "./var/isIE.js";
import { identifier } from "./selector/var/identifier.js";
import { rleadingCombinator } from "./selector/var/rleadingCombinator.js";
import { rdescend } from "./selector/var/rdescend.js";
import { rsibling } from "./selector/var/rsibling.js";
import { matches } from "./selector/var/matches.js";
import { createCache } from "./selector/createCache.js";
import { testContext } from "./selector/testContext.js";
import { filterMatchExpr } from "./selector/filterMatchExpr.js";
import { preFilter } from "./selector/preFilter.js";
import { selectorError } from "./selector/selectorError.js";
import { unescapeSelector } from "./selector/unescapeSelector.js";
import { tokenize } from "./selector/tokenize.js";
import { toSelector } from "./selector/toSelector.js";

// The following utils are attached directly to the jQuery object.
import "./attributes/attr.js"; // jQuery.attr
import "./selector/escapeSelector.js";
import "./selector/uniqueSort.js";

var i,
        outermostContext,

        // Local document vars
        document,
        documentElement,
        documentIsHTML,

        // Instance-specific data
        dirruns = 0,
        done = 0,
        classCache = createCache(),
        compilerCache = createCache(),
        nonnativeSelectorCache = createCache(),

        // Regular expressions

        // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
        rwhitespace = new RegExp( whitespace + "+", "g" ),

        ridentifier = new RegExp( "^" + identifier + "$" ),

        matchExpr = jQuery.extend( {

                // 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" )
        }, filterMatchExpr ),

        rinputs = /^(?:input|select|textarea|button)$/i,
        rheader = /^h\d$/i,

        // Easily-parseable/retrievable ID or TAG or CLASS selectors
        rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,

        // Used for iframes; see `setDocument`.
        // Support: IE 9 - 11+
        // Removing the function wrapper causes a "Permission Denied"
        // error in IE.
        unloadHandler = function() {
                setDocument();
        },

        inDisabledFieldset = addCombinator(
                function( elem ) {
                        return elem.disabled === true && nodeName( elem, "fieldset" );
                },
                { dir: "parentNode", next: "legend" }
        );

function find( selector, context, results, seed ) {
        var m, i, elem, nid, match, groups, newSelector,
                newContext = context && context.ownerDocument,

                // nodeType defaults to 9, since context defaults to document
                nodeType = context ? context.nodeType : 9;

        results = results || [];

        // Return early from calls with invalid selector or context
        if ( typeof selector !== "string" || !selector ||
                nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {

                return results;
        }

        // Try to shortcut find operations (as opposed to filters) in HTML documents
        if ( !seed ) {
                setDocument( context );
                context = context || document;

                if ( documentIsHTML ) {

                        // If the selector is sufficiently simple, try using a "get*By*" DOM method
                        // (excepting DocumentFragment context, where the methods don't exist)
                        if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {

                                // ID selector
                                if ( ( m = match[ 1 ] ) ) {

                                        // Document context
                                        if ( nodeType === 9 ) {
                                                if ( ( elem = context.getElementById( m ) ) ) {
                                                        push.call( results, elem );
                                                }
                                                return results;

                                        // Element context
                                        } else {
                                                if ( newContext && ( elem = newContext.getElementById( m ) ) &&
                                                        jQuery.contains( context, elem ) ) {

                                                        push.call( results, elem );
                                                        return results;
                                                }
                                        }

                                // Type selector
                                } else if ( match[ 2 ] ) {
                                        push.apply( results, context.getElementsByTagName( selector ) );
                                        return results;

                                // Class selector
                                } else if ( ( m = match[ 3 ] ) && context.getElementsByClassName ) {
                                        push.apply( results, context.getElementsByClassName( m ) );
                                        return results;
                                }
                        }

                        // Take advantage of querySelectorAll
                        if ( !nonnativeSelectorCache[ selector + " " ] &&
                                ( !rbuggyQSA || !rbuggyQSA.test( selector ) ) ) {

                                newSelector = selector;
                                newContext = context;

                                // qSA considers elements outside a scoping root when evaluating child or
                                // descendant combinators, which is not what we want.
                                // In such cases, we work around the behavior by prefixing every selector in the
                                // list with an ID selector referencing the scope context.
                                // The technique has to be used as well when a leading combinator is used
                                // as such selectors are not recognized by querySelectorAll.
                                // Thanks to Andrew Dupont for this technique.
                                if ( nodeType === 1 &&
                                        ( rdescend.test( selector ) || rleadingCombinator.test( selector ) ) ) {

                                        // Expand context for sibling selectors
                                        newContext = rsibling.test( selector ) &&
                                                testContext( context.parentNode ) ||
                                                context;

                                        // Outside of IE, if we're not changing the context we can
                                        // use :scope instead of an ID.
                                        // Support: IE 11+
                                        // IE sometimes throws a "Permission denied" error when strict-comparing
                                        // two documents; shallow comparisons work.
                                        // eslint-disable-next-line eqeqeq
                                        if ( newContext != context || isIE ) {

                                                // Capture the context ID, setting it first if necessary
                                                if ( ( nid = context.getAttribute( "id" ) ) ) {
                                                        nid = jQuery.escapeSelector( nid );
                                                } else {
                                                        context.setAttribute( "id", ( nid = jQuery.expando ) );
                                                }
                                        }

                                        // Prefix every selector in the list
                                        groups = tokenize( selector );
                                        i = groups.length;
                                        while ( i-- ) {
                                                groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
                                                        toSelector( groups[ i ] );
                                        }
                                        newSelector = groups.join( "," );
                                }

                                try {
                                        push.apply( results,
                                                newContext.querySelectorAll( newSelector )
                                        );
                                        return results;
                                } catch ( qsaError ) {
                                        nonnativeSelectorCache( selector, true );
                                } finally {
                                        if ( nid === jQuery.expando ) {
                                                context.removeAttribute( "id" );
                                        }
                                }
                        }
                }
        }

        // All others
        return select( selector.replace( rtrimCSS, "$1" ), context, results, seed );
}

/**
 * Mark a function for special use by jQuery selector module
 * @param {Function} fn The function to mark
 */
function markFunction( fn ) {
        fn[ jQuery.expando ] = true;
        return fn;
}

/**
 * Returns a function to use in pseudos for input types
 * @param {String} type
 */
function createInputPseudo( type ) {
        return function( elem ) {
                return nodeName( elem, "input" ) && elem.type === type;
        };
}

/**
 * Returns a function to use in pseudos for buttons
 * @param {String} type
 */
function createButtonPseudo( type ) {
        return function( elem ) {
                return ( nodeName( elem, "input" ) || nodeName( elem, "button" ) ) &&
                        elem.type === type;
        };
}

/**
 * Returns a function to use in pseudos for :enabled/:disabled
 * @param {Boolean} disabled true for :disabled; false for :enabled
 */
function createDisabledPseudo( disabled ) {

        // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
        return function( elem ) {

                // Only certain elements can match :enabled or :disabled
                // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
                // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
                if ( "form" in elem ) {

                        // Check for inherited disabledness on relevant non-disabled elements:
                        // * listed form-associated elements in a disabled fieldset
                        //   https://html.spec.whatwg.org/multipage/forms.html#category-listed
                        //   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
                        // * option elements in a disabled optgroup
                        //   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
                        // All such elements have a "form" property.
                        if ( elem.parentNode && elem.disabled === false ) {

                                // Option elements defer to a parent optgroup if present
                                if ( "label" in elem ) {
                                        if ( "label" in elem.parentNode ) {
                                                return elem.parentNode.disabled === disabled;
                                        } else {
                                                return elem.disabled === disabled;
                                        }
                                }

                                // Support: IE 6 - 11+
                                // Use the isDisabled shortcut property to check for disabled fieldset ancestors
                                return elem.isDisabled === disabled ||

                                        // Where there is no isDisabled, check manually
                                        elem.isDisabled !== !disabled &&
                                                inDisabledFieldset( elem ) === disabled;
                        }

                        return elem.disabled === disabled;

                // Try to winnow out elements that can't be disabled before trusting the disabled property.
                // Some victims get caught in our net (label, legend, menu, track), but it shouldn't
                // even exist on them, let alone have a boolean value.
                } else if ( "label" in elem ) {
                        return elem.disabled === disabled;
                }

                // Remaining elements are neither :enabled nor :disabled
                return false;
        };
}

/**
 * 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 ] );
                                }
                        }
                } );
        } );
}

/**
 * Sets document-related variables once based on the current document
 * @param {Element|Object} [node] An element or document object to use to set the document
 */
function setDocument( node ) {
        var subWindow,
                doc = node ? node.ownerDocument || node : preferredDoc;

        // Return early if doc is invalid or already selected
        // Support: IE 11+
        // IE sometimes throws a "Permission denied" error when strict-comparing
        // two documents; shallow comparisons work.
        // eslint-disable-next-line eqeqeq
        if ( doc == document || doc.nodeType !== 9 ) {
                return;
        }

        // Update global variables
        document = doc;
        documentElement = document.documentElement;
        documentIsHTML = !jQuery.isXMLDoc( document );

        // Support: IE 9 - 11+
        // Accessing iframe documents after unload throws "permission denied" errors (see trac-13936)
        // Support: IE 11+
        // IE sometimes throws a "Permission denied" error when strict-comparing
        // two documents; shallow comparisons work.
        // eslint-disable-next-line eqeqeq
        if ( isIE && preferredDoc != document &&
                ( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
                subWindow.addEventListener( "unload", unloadHandler );
        }
}

find.matches = function( expr, elements ) {
        return find( expr, null, null, elements );
};

find.matchesSelector = function( elem, expr ) {
        setDocument( elem );

        if ( documentIsHTML &&
                !nonnativeSelectorCache[ expr + " " ] &&
                ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {

                try {
                        return matches.call( elem, expr );
                } catch ( e ) {
                        nonnativeSelectorCache( expr, true );
                }
        }

        return find( expr, document, null, [ elem ] ).length > 0;
};

jQuery.expr = {

        // Can be adjusted by the user
        cacheLength: 50,

        createPseudo: markFunction,

        match: matchExpr,

        find: {
                ID: function( id, context ) {
                        if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
                                var elem = context.getElementById( id );
                                return elem ? [ elem ] : [];
                        }
                },

                TAG: function( tag, context ) {
                        if ( typeof context.getElementsByTagName !== "undefined" ) {
                                return context.getElementsByTagName( tag );

                                // DocumentFragment nodes don't have gEBTN
                        } else {
                                return context.querySelectorAll( tag );
                        }
                },

                CLASS: function( className, context ) {
                        if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
                                return context.getElementsByClassName( className );
                        }
                }
        },

        relative: {
                ">": { dir: "parentNode", first: true },
                " ": { dir: "parentNode" },
                "+": { dir: "previousSibling", first: true },
                "~": { dir: "previousSibling" }
        },

        preFilter: preFilter,

        filter: {
                ID: function( id ) {
                        var attrId = unescapeSelector( id );
                        return function( elem ) {
                                return elem.getAttribute( "id" ) === attrId;
                        };
                },

                TAG: function( nodeNameSelector ) {
                        var expectedNodeName = unescapeSelector( nodeNameSelector ).toLowerCase();
                        return nodeNameSelector === "*" ?

                                function() {
                                        return true;
                                } :

                                function( elem ) {
                                        return nodeName( elem, expectedNodeName );
                                };
                },

                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 !== "undefined" &&
                                                                elem.getAttribute( "class" ) ||
                                                        ""
                                        );
                                } );
                },

                ATTR: function( name, operator, check ) {
                        return function( elem ) {
                                var result = jQuery.attr( elem, name );

                                if ( result == null ) {
                                        return operator === "!=";
                                }
                                if ( !operator ) {
                                        return true;
                                }

                                result += "";

                                if ( operator === "=" ) {
                                        return result === check;
                                }
                                if ( operator === "!=" ) {
                                        return result !== check;
                                }
                                if ( operator === "^=" ) {
                                        return check && result.indexOf( check ) === 0;
                                }
                                if ( operator === "*=" ) {
                                        return check && result.indexOf( check ) > -1;
                                }
                                if ( operator === "$=" ) {
                                        return check && result.slice( -check.length ) === check;
                                }
                                if ( operator === "~=" ) {
                                        return ( " " + result.replace( rwhitespace, " " ) + " " )
                                                .indexOf( check ) > -1;
                                }
                                if ( operator === "|=" ) {
                                        return result === check || result.slice( 0, check.length + 1 ) === check + "-";
                                }

                                return 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, nodeIndex, start,
                                                dir = simple !== forward ? "nextSibling" : "previousSibling",
                                                parent = elem.parentNode,
                                                name = ofType && elem.nodeName.toLowerCase(),
                                                useCache = !xml && !ofType,
                                                diff = false;

                                        if ( parent ) {

                                                // :(first|last|only)-(child|of-type)
                                                if ( simple ) {
                                                        while ( dir ) {
                                                                node = elem;
                                                                while ( ( node = node[ dir ] ) ) {
                                                                        if ( ofType ?
                                                                                nodeName( node, 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[ jQuery.expando ] ||
                                                                ( parent[ jQuery.expando ] = {} );
                                                        cache = outerCache[ type ] || [];
                                                        nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
                                                        diff = nodeIndex && 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;
                                                                }
                                                        }

                                                } else {

                                                        // Use previously-cached element index if available
                                                        if ( useCache ) {
                                                                outerCache = elem[ jQuery.expando ] ||
                                                                        ( elem[ jQuery.expando ] = {} );
                                                                cache = outerCache[ type ] || [];
                                                                nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
                                                                diff = nodeIndex;
                                                        }

                                                        // xml :nth-child(...)
                                                        // or :nth-last-child(...) or :nth(-last)?-of-type(...)
                                                        if ( diff === false ) {

                                                                // 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 ?
                                                                                nodeName( node, name ) :
                                                                                node.nodeType === 1 ) &&
                                                                                ++diff ) {

                                                                                // Cache the index of each encountered element
                                                                                if ( useCache ) {
                                                                                        outerCache = node[ jQuery.expando ] ||
                                                                                                ( node[ jQuery.expando ] = {} );
                                                                                        outerCache[ 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
                        // https://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 fn = jQuery.expr.pseudos[ pseudo ] ||
                                jQuery.expr.setFilters[ pseudo.toLowerCase() ] ||
                                selectorError( "unsupported pseudo: " + pseudo );

                        // The user may use createPseudo to indicate that
                        // arguments are needed to create the filter function
                        // just as jQuery does
                        if ( fn[ jQuery.expando ] ) {
                                return fn( argument );
                        }

                        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( rtrimCSS, "$1" ) );

                        return matcher[ jQuery.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 );

                                        // Don't keep the element
                                        // (see https://github.com/jquery/sizzle/issues/299)
                                        input[ 0 ] = null;
                                        return !results.pop();
                                };
                } ),

                has: markFunction( function( selector ) {
                        return function( elem ) {
                                return find( selector, elem ).length > 0;
                        };
                } ),

                contains: markFunction( function( text ) {
                        text = unescapeSelector( text );
                        return function( elem ) {
                                return ( elem.textContent || jQuery.text( 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."
                // https://www.w3.org/TR/selectors/#lang-pseudo
                lang: markFunction( function( lang ) {

                        // lang value must be a valid identifier
                        if ( !ridentifier.test( lang || "" ) ) {
                                selectorError( "unsupported lang: " + lang );
                        }
                        lang = unescapeSelector( lang ).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 === documentElement;
                },

                focus: function( elem ) {
                        return elem === document.activeElement &&
                                document.hasFocus() &&
                                !!( elem.type || elem.href || ~elem.tabIndex );
                },

                // Boolean properties
                enabled: createDisabledPseudo( false ),
                disabled: createDisabledPseudo( true ),

                checked: function( elem ) {

                        // In CSS3, :checked should return both checked and selected elements
                        // https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
                        return ( nodeName( elem, "input" ) && !!elem.checked ) ||
                                ( nodeName( elem, "option" ) && !!elem.selected );
                },

                selected: function( elem ) {

                        // Support: IE <=11+
                        // Accessing the selectedIndex property
                        // forces the browser to treat the default option as
                        // selected when in an optgroup.
                        if ( isIE && elem.parentNode ) {
                                // eslint-disable-next-line no-unused-expressions
                                elem.parentNode.selectedIndex;
                        }

                        return elem.selected === true;
                },

                // Contents
                empty: function( elem ) {

                        // https://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 !jQuery.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 ) {
                        return nodeName( elem, "input" ) && elem.type === "button" ||
                                nodeName( elem, "button" );
                },

                text: function( elem ) {
                        return nodeName( elem, "input" ) && elem.type === "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;

                        if ( argument < 0 ) {
                                i = argument + length;
                        } else if ( argument > length ) {
                                i = length;
                        } else {
                                i = 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;
                } )
        }
};

jQuery.expr.pseudos.nth = jQuery.expr.pseudos.eq;

// Add button/input type pseudos
for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
        jQuery.expr.pseudos[ i ] = createInputPseudo( i );
}
for ( i in { submit: true, reset: true } ) {
        jQuery.expr.pseudos[ i ] = createButtonPseudo( i );
}

// Easy API for creating new setFilters
function setFilters() {}
setFilters.prototype = jQuery.expr.filters = jQuery.expr.pseudos;
jQuery.expr.setFilters = new setFilters();

function addCombinator( matcher, combinator, base ) {
        var dir = combinator.dir,
                skip = combinator.next,
                key = skip || dir,
                checkNonElements = base && key === "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 );
                                }
                        }
                        return false;
                } :

                // 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 combinator 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[ jQuery.expando ] || ( elem[ jQuery.expando ] = {} );

                                                if ( skip && nodeName( elem, skip ) ) {
                                                        elem = elem[ dir ] || elem;
                                                } else if ( ( oldCache = outerCache[ key ] ) &&
                                                        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[ key ] = newCache;

                                                        // A match means we're done; a fail means we have to keep checking
                                                        if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {
                                                                return true;
                                                        }
                                                }
                                        }
                                }
                        }
                        return false;
                };
}

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 multipleContexts( selector, contexts, results ) {
        var i = 0,
                len = contexts.length;
        for ( ; i < len; i++ ) {
                find( selector, contexts[ i ], results );
        }
        return results;
}

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[ jQuery.expando ] ) {
                postFilter = setMatcher( postFilter );
        }
        if ( postFinder && !postFinder[ jQuery.expando ] ) {
                postFinder = setMatcher( postFinder, postSelector );
        }
        return markFunction( function( seed, results, context, xml ) {
                var temp, i, elem, matcherOut,
                        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;

                if ( matcher ) {

                        // If we have a postFinder, or filtered seed, or non-seed postFilter
                        // or preexisting results,
                        matcherOut = postFinder || ( seed ? preFilter : preexisting || postFilter ) ?

                                // ...intermediate processing is necessary
                                [] :

                                // ...otherwise use results directly
                                results;

                        // Find primary matches
                        matcher( matcherIn, matcherOut, context, xml );
                } else {
                        matcherOut = matcherIn;
                }

                // 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 = jQuery.expr.relative[ tokens[ 0 ].type ],
                implicitRelative = leadingRelative || jQuery.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 ) {

                        // Support: IE 11+
                        // IE sometimes throws a "Permission denied" error when strict-comparing
                        // two documents; shallow comparisons work.
                        // eslint-disable-next-line eqeqeq
                        var ret = ( !leadingRelative && ( xml || context != outermostContext ) ) || (
                                ( checkContext = context ).nodeType ?
                                        matchContext( elem, context, xml ) :
                                        matchAnyContext( elem, context, xml ) );

                        // Avoid hanging onto element
                        // (see https://github.com/jquery/sizzle/issues/299)
                        checkContext = null;
                        return ret;
                } ];

        for ( ; i < len; i++ ) {
                if ( ( matcher = jQuery.expr.relative[ tokens[ i ].type ] ) ) {
                        matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
                } else {
                        matcher = jQuery.expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );

                        // Return special upon seeing a positional matcher
                        if ( matcher[ jQuery.expando ] ) {

                                // Find the next relative operator (if any) for proper handling
                                j = ++i;
                                for ( ; j < len; j++ ) {
                                        if ( jQuery.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( rtrimCSS, "$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 && jQuery.expr.find.TAG( "*", outermost ),

                                // Use integer dirruns iff this is the outermost matcher
                                dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 );

                        if ( outermost ) {

                                // Support: IE 11+
                                // IE sometimes throws a "Permission denied" error when strict-comparing
                                // two documents; shallow comparisons work.
                                // eslint-disable-next-line eqeqeq
                                outermostContext = context == document || context || outermost;
                        }

                        // Add elements passing elementMatchers directly to results
                        for ( ; ( elem = elems[ i ] ) != null; i++ ) {
                                if ( byElement && elem ) {
                                        j = 0;

                                        // Support: IE 11+
                                        // IE sometimes throws a "Permission denied" error when strict-comparing
                                        // two documents; shallow comparisons work.
                                        // eslint-disable-next-line eqeqeq
                                        if ( !context && elem.ownerDocument != document ) {
                                                setDocument( elem );
                                                xml = !documentIsHTML;
                                        }
                                        while ( ( matcher = elementMatchers[ j++ ] ) ) {
                                                if ( matcher( elem, context || document, xml ) ) {
                                                        push.call( results, 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 );
                                        }
                                }
                        }

                        // `i` is now the count of elements visited above, and adding it to `matchedCount`
                        // makes the latter nonnegative.
                        matchedCount += i;

                        // Apply set filters to unmatched elements
                        // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
                        // equals `i`), unless we didn't visit _any_ elements in the above loop because we have
                        // no element matchers and no seed.
                        // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
                        // case, which will result in a "00" `matchedCount` that differs from `i` but is also
                        // numerically zero.
                        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 ) {

                                        jQuery.uniqueSort( results );
                                }
                        }

                        // Override manipulation of globals by nested matchers
                        if ( outermost ) {
                                dirruns = dirrunsUnique;
                                outermostContext = contextBackup;
                        }

                        return unmatched;
                };

        return bySet ?
                markFunction( superMatcher ) :
                superMatcher;
}

function compile( selector, match /* 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 ( !match ) {
                        match = tokenize( selector );
                }
                i = match.length;
                while ( i-- ) {
                        cached = matcherFromTokens( match[ i ] );
                        if ( cached[ jQuery.expando ] ) {
                                setMatchers.push( cached );
                        } else {
                                elementMatchers.push( cached );
                        }
                }

                // Cache the compiled function
                cached = compilerCache( selector,
                        matcherFromGroupMatchers( elementMatchers, setMatchers ) );

                // Save selector and tokenization
                cached.selector = selector;
        }
        return cached;
}

/**
 * A low-level selection function that works with jQuery's compiled
 *  selector functions
 * @param {String|Function} selector A selector or a pre-compiled
 *  selector function built with jQuery selector compile
 * @param {Element} context
 * @param {Array} [results]
 * @param {Array} [seed] A set of elements to match against
 */
function select( selector, context, results, seed ) {
        var i, tokens, token, type, find,
                compiled = typeof selector === "function" && selector,
                match = !seed && tokenize( ( selector = compiled.selector || selector ) );

        results = results || [];

        // Try to minimize operations if there is only one selector in the list and no seed
        // (the latter of which guarantees us context)
        if ( match.length === 1 ) {

                // Reduce context if the leading compound selector is an ID
                tokens = match[ 0 ] = match[ 0 ].slice( 0 );
                if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
                                context.nodeType === 9 && documentIsHTML &&
                                jQuery.expr.relative[ tokens[ 1 ].type ] ) {

                        context = ( jQuery.expr.find.ID(
                                unescapeSelector( token.matches[ 0 ] ),
                                context
                        ) || [] )[ 0 ];
                        if ( !context ) {
                                return results;

                        // Precompiled matchers will still verify ancestry, so step up a level
                        } else if ( compiled ) {
                                context = context.parentNode;
                        }

                        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 ( jQuery.expr.relative[ ( type = token.type ) ] ) {
                                break;
                        }
                        if ( ( find = jQuery.expr.find[ type ] ) ) {

                                // Search, expanding context for leading sibling combinators
                                if ( ( seed = find(
                                        unescapeSelector( token.matches[ 0 ] ),
                                        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 if one is not provided
        // Provide `match` to avoid retokenization if we modified the selector above
        ( compiled || compile( selector, match ) )(
                seed,
                context,
                !documentIsHTML,
                results,
                !context || rsibling.test( selector ) && testContext( context.parentNode ) || context
        );
        return results;
}

// Initialize against the default document
setDocument();

jQuery.find = find;

// These have always been private, but they used to be documented as part of
// Sizzle so let's maintain them for now for backwards compatibility purposes.
find.compile = compile;
find.select = select;
find.setDocument = setDocument;
find.tokenize = tokenize;

export { jQuery, jQuery as $ };