https://wonderplace.co.kr/ind-script/optimizer.php?filename=vVnLdu…9c7a0ddf2d9aaa4fb74bd3b297fc1c&t=1789949639

416ict mode should be common
417// enough that all such attempts are guarded in a try block.
418    "use strict";
419
420    var arr = [];
421
422    var getProto = Object.getPrototypeOf;
423
424    var slice = arr.slice;
425
426    var flat = arr.flat ? function( array ) {
427        return arr.flat.call( array );
428    } : function( array ) {
429        return arr.concat.apply( [], array );
430    };
431
432
433    var push = arr.push;
434
435    var indexOf = arr.indexOf;
436
437    var class2type = {};
438
439    var toString = class2type.toString;
440
441    var hasOwn = class2type.hasOwnProperty;
442
443    var fnToString = hasOwn.toString;
444
445    var ObjectFunctionString = fnToString.call( Object );
446
447    var support = {};
448
449    var isFunction = function isFunction( obj ) {
450
451        // Support: Chrome <=57, Firefox <=52
452        // In some browsers, typeof returns "function" for HTML <object> elements
453        // (i.e., `typeof document.createElement( "object" ) === "function"`).
454        // We don't want to classify *any* DOM node as a function.
455        // Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5
456        // Plus for old WebKit, typeof returns "function" for HTML collections
457        // (e.g., `typeof document.getElementsByTagName("div") === "function"`). (gh-4756)
458        return typeof obj === "function" && typeof obj.nodeType !== "number" &&
459            typeof obj.item !== "function";
460    };
461
462
463    var isWindow = function isWindow( obj ) {
464        return obj != null && obj === obj.window;
465    };
466
467
468    var document = window.document;
469
470
471
472    var preservedScriptAttributes = {
473        type: true,
474        src: true,
475        nonce: true,
476        noModule: true
477    };
478
479    function DOMEval( code, node, doc ) {
480        doc = doc || document;
481
482        var i, val,
483            script = doc.createElement( "script" );
484
485        script.text = code;
486        if ( node ) {
487            for ( i in preservedScriptAttributes ) {
488
489                // Support: Firefox 64+, Edge 18+
490                // Some browsers don't support the "nonce" property on scripts.
491                // On the other hand, just using `getAttribute` is not enough as
492                // the `nonce` attribute is reset to an empty string whenever it
493                // becomes browsing-context connected.
494                // See https://github.com/whatwg/html/issues/2369
495                // See https://html.spec.whatwg.org/#nonce-attributes
496                // The `node.getAttribute` check was added for the sake of
497                // `jQuery.globalEval` so that it can fake a nonce-containing node
498                // via an object.
499                val = node[ i ] || node.getAttribute && node.getAttribute( i );
500                if ( val ) {
501                    script.setAttribute( i, val );
502                }
503            }
504        }
505        doc.head.appendChild( script ).parentNode.removeChild( script );
506    }
507
508
509    function toType( obj ) {
510        if ( obj == null ) {
511            return obj + "";
512        }
513
514        // Support: Android <=2.3 only (functionish RegExp)
515        return typeof obj === "object" || typeof obj === "function" ?
516            class2type[ toString.call( obj ) ] || "object" :
517            typeof obj;
518    }
519    /* global Symbol */
520// Defining this global in .eslintrc.json would create a danger of using the global
521// unguarded in another place, it seems safer to define global only for this module
522
523
524
525    var
526        version = "3.6.0",
527
528        // Define a local copy of jQuery
529        jQuery = function( selector, context ) {
530
531            // The jQuery object is actually just the init constructor 'enhanced'
532            // Need init if jQuery is called (just allow error to be thrown if not included)
533            return new jQuery.fn.init( selector, context );
534        };
535
536    jQuery.fn = jQuery.prototype = {
537
538        // The current version of jQuery being used
539        jquery: version,
540
541        constructor: jQuery,
542
543        // The default length of a jQuery object is 0
544        length: 0,
545
546        toArray: function() {
547            return slice.call( this );
548        },
549
550        // Get the Nth element in the matched element set OR
551        // Get the whole matched element set as a clean array
552        get: function( num ) {
553
554            // Return all the elements in a clean array
555            if ( num == null ) {
556                return slice.call( this );
557            }
558
559            // Return just the one element from the set
560            return num < 0 ? this[ num + this.length ] : this[ num ];
561        },
562
563        // Take an array of elements and push it onto the stack
564        // (returning the new matched element set)
565        pushStack: function( elems ) {
566
567            // Build a new jQuery matched element set
568            var ret = jQuery.merge( this.constructor(), elems );
569
570            // Add the old object onto the stack (as a reference)

571            ret.prevObject = this;
572
573            // Return the newly-formed element set
574            return ret;
575        },
576
577        // Execute a callback for every element in the matched set.
578        each: function( callback ) {
579            return jQuery.each( this, callback );
580        },
581
582        map: function( callback ) {
583            return this.pushStack( jQuery.map( this, function( elem, i ) {
584                return callback.call( elem, i, elem );
585            } ) );
586        },
587
588        slice: function() {
589            return this.pushStack( slice.apply( this, arguments ) );
590        },
591
592        first: function() {
593            return this.eq( 0 );
594        },
595
596        last: function() {
597            return this.eq( -1 );
598        },
599
600        even: function() {
601            return this.pushStack( jQuery.grep( this, function( _elem, i ) {
602                return ( i + 1 ) % 2;
603            } ) );
604        },
605
606        odd: function() {
607            return this.pushStack( jQuery.grep( this, function( _elem, i ) {
608                return i % 2;
609            } ) );
610        },
611
612        eq: function( i ) {
613            var len = this.length,
614                j = +i + ( i < 0 ? len : 0 );
615            return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
616        },
617
618        end: function() {
619            return this.prevObject || this.constructor();
620        },
621
622        // For internal use only.
623        // Behaves like an Array's method, not like a jQuery method.
624        push: push,
625        sort: arr.sort,
626        splice: arr.splice
627    };
628
629    jQuery.extend = jQuery.fn.extend = function() {
630        var options, name, src, copy, copyIsArray, clone,
631            target = arguments[ 0 ] || {},
632            i = 1,
633            length = arguments.length,
634            deep = false;
635
636        // Handle a deep copy situation
637        if ( typeof target === "boolean" ) {
638            deep = target;
639
640            // Skip the boolean and the target
641            target = arguments[ i ] || {};
642            i++;
643        }
644
645        // Handle case when target is a string or something (possible in deep copy)
646        if ( typeof target !== "object" && !isFunction( target ) ) {
647            target = {};
648        }
649
650        // Extend jQuery itself if only one argument is passed
651        if ( i === length ) {
652            target = this;
653            i--;
654        }
655
656        for ( ; i < length; i++ ) {
657
658            // Only deal with non-null/undefined values
659            if ( ( options = arguments[ i ] ) != null ) {
660
661                // Extend the base object
662                for ( name in options ) {
663                    copy = options[ name ];
664
665                    // Prevent Object.prototype pollution
666                    // Prevent never-ending loop
667                    if ( name === "__proto__" || target === copy ) {
668                        continue;
669                    }
670
671                    // Recurse if we're merging plain objects or arrays
672                    if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
673                        ( copyIsArray = Array.isArray( copy ) ) ) ) {
674                        src = target[ name ];
675
676                        // Ensure proper type for the source value
677                        if ( copyIsArray && !Array.isArray( src ) ) {
678                            clone = [];
679                        } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
680                            clone = {};
681                        } else {
682                            clone = src;
683                        }
684                        copyIsArray = false;
685
686                        // Never move original objects, clone them
687                        target[ name ] = jQuery.extend( deep, clone, copy );
688
689                        // Don't bring in undefined values
690                    } else if ( copy !== undefined ) {
691                        target[ name ] = copy;
692                    }
693                }
694            }
695        }
696
697        // Return the modified object
698        return target;
699    };
700
701    jQuery.extend( {
702
703        // Unique for each copy of jQuery on the page
704        expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
705
706        // Assume jQuery is ready without the ready module
707        isReady: true,
708
709        error: function( msg ) {
710            throw new Error( msg );
711        },
712
713        noop: function() {},
714
715        isPlainObject: function( obj ) {
716            var key;
717
718            // Detect obvious negatives
719            // Use toString instead of jQuery.type to catch host objects
720            if ( !obj || toString.call( obj ) !== "[object Object]" ) {
721                return false;

722            }
723
724            // Not own constructor property must be Object
725            if ( obj.constructor &&
726                !hasOwn.call( obj, "constructor" ) &&
727                !hasOwn.call( obj.constructor.prototype || {}, "isPrototypeOf" ) ) {
728                return false;
729            }
730
731            // Own properties are enumerated firstly, so to speed up,
732            // if last one is own, then all properties are own
733            for ( key in obj ) {}
734
735            return key === undefined || hasOwn.call( obj, key );
736        },
737
738        isEmptyObject: function( obj ) {
739            var name;
740
741            for ( name in obj ) {
742                return false;
743            }
744            return true;
745        },
746
747        // Evaluates a script in a provided context; falls back to the global one
748        // if not specified.
749        globalEval: function( code, options, doc ) {
750            DOMEval( code, { nonce: options && options.nonce }, doc );
751        },
752
753        each: function( obj, callback ) {
754            var length, i = 0;
755
756            if ( isArrayLike( obj ) ) {
757                length = obj.length;
758                for ( ; i < length; i++ ) {
759                    if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
760                        break;
761                    }
762                }
763            } else {
764                for ( i in obj ) {
765                    if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
766                        break;
767                    }
768                }
769            }
770
771            return obj;
772        },
773
774        // results is for internal usage only
775        makeArray: function( arr, results ) {
776            var ret = results || [];
777
778            if ( arr != null ) {
779                if ( isArrayLike( Object( arr ) ) ) {
780                    jQuery.merge( ret,
781                        typeof arr === "string" ?
782                            [ arr ] : arr
783                    );
784                } else {
785                    push.call( ret, arr );
786                }
787            }
788
789            return ret;
790        },
791
792        inArray: function( elem, arr, i ) {
793            return arr == null ? -1 : indexOf.call( arr, elem, i );
794        },
795
796        // Support: Android <=4.0 only, PhantomJS 1 only
797        // push.apply(_, arraylike) throws on ancient WebKit
798        merge: function( first, second ) {
799            var len = +second.length,
800                j = 0,
801                i = first.length;
802
803            for ( ; j < len; j++ ) {
804                first[ i++ ] = second[ j ];
805            }
806
807            first.length = i;
808
809            return first;
810        },
811
812        grep: function( elems, callback, invert ) {
813            var callbackInverse,
814                matches = [],
815                i = 0,
816                length = elems.length,
817                callbackExpect = !invert;
818
819            // Go through the array, only saving the items
820            // that pass the validator function
821            for ( ; i < length; i++ ) {
822                callbackInverse = !callback( elems[ i ], i );
823                if ( callbackInverse !== callbackExpect ) {
824                    matches.push( elems[ i ] );
825                }
826            }
827
828            return matches;
829        },
830
831        // arg is for internal usage only
832        map: function( elems, callback, arg ) {
833            var length, value,
834                i = 0,
835                ret = [];
836
837            // Go through the array, translating each of the items to their new values
838            if ( isArrayLike( elems ) ) {
839                length = elems.length;
840                for ( ; i < length; i++ ) {
841                    value = callback( elems[ i ], i, arg );
842
843                    if ( value != null ) {
844                        ret.push( value );
845                    }
846                }
847
848                // Go through every key on the object,
849            } else {
850                for ( i in elems ) {
851                    value = callback( elems[ i ], i, arg );
852
853                    if ( value != null ) {
854                        ret.push( value );
855                    }
856                }
857            }
858
859            // Flatten any nested arrays
860            return flat( ret );
861        },
862
863        // A global GUID counter for objects
864        guid: 1,
865
866        // jQuery.support is not used in Core but other projects attach their
867        // properties to it so it needs to exist.
868        support: support
869    } );
870
871    if ( typeof Symbol === "function" ) {
872        jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
873    }
874
875// Populate the class2type map
876    jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
877        function( _i, name ) {
878            class2type[ "[object " + name + "]" ] = name.toLowerCase();
879        } );
880
881    function isArrayLike( obj ) {
882

883        // Support: real iOS 8.2 only (not reproducible in simulator)
884        // `in` check used to prevent JIT error (gh-2145)
885        // hasOwn isn't used here due to false negatives
886        // regarding Nodelist length in IE
887        var length = !!obj && "length" in obj && obj.length,
888            type = toType( obj );
889
890        if ( isFunction( obj ) || isWindow( obj ) ) {
891            return false;
892        }
893
894        return type === "array" || length === 0 ||
895            typeof length === "number" && length > 0 && ( length - 1 ) in obj;
896    }
897    var Sizzle =
898        /*!
899 * Sizzle CSS Selector Engine v2.3.6
900 * https://sizzlejs.com/
901 *
902 * Copyright JS Foundation and other contributors
903 * Released under the MIT license
904 * https://js.foundation/
905 *
906 * Date: 2021-02-16
907 */
908        ( function( window ) {
909            var i,
910                support,
911                Expr,
912                getText,
913                isXML,
914                tokenize,
915                compile,
916                select,
917                outermostContext,
918                sortInput,
919                hasDuplicate,
920
921                // Local document vars
922                setDocument,
923                document,
924                docElem,
925                documentIsHTML,
926                rbuggyQSA,
927                rbuggyMatches,
928                matches,
929                contains,
930
931                // Instance-specific data
932                expando = "sizzle" + 1 * new Date(),
933                preferredDoc = window.document,
934                dirruns = 0,
935                done = 0,
936                classCache = createCache(),
937                tokenCache = createCache(),
938                compilerCache = createCache(),
939                nonnativeSelectorCache = createCache(),
940                sortOrder = function( a, b ) {
941                    if ( a === b ) {
942                        hasDuplicate = true;
943                    }
944                    return 0;
945                },
946
947                // Instance methods
948                hasOwn = ( {} ).hasOwnProperty,
949                arr = [],
950                pop = arr.pop,
951                pushNative = arr.push,
952                push = arr.push,
953                slice = arr.slice,
954
955                // Use a stripped-down indexOf as it's faster than native
956                // https://jsperf.com/thor-indexof-vs-for/5
957                indexOf = function( list, elem ) {
958                    var i = 0,
959                        len = list.length;
960                    for ( ; i < len; i++ ) {
961                        if ( list[ i ] === elem ) {
962                            return i;
963                        }
964                    }
965                    return -1;
966                },
967
968                booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" +
969                    "ismap|loop|multiple|open|readonly|required|scoped",
970
971                // Regular expressions
972
973                // http://www.w3.org/TR/css3-selectors/#whitespace
974                whitespace = "[\\x20\\t\\r\\n\\f]",
975
976                // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
977                identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
978                    "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
979
980                // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
981                attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
982
983                    // Operator (capture 2)
984                    "*([*^$|!~]?=)" + whitespace +
985
986                    // "Attribute values must be CSS identifiers [capture 5]
987                    // or strings [capture 3 or capture 4]"
988                    "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
989                    whitespace + "*\\]",
990
991                pseudos = ":(" + identifier + ")(?:\\((" +
992
993                    // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
994                    // 1. quoted (capture 3; capture 4 or capture 5)
995                    "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
996
997                    // 2. simple (capture 6)
998                    "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
999
1000                    // 3. anything else (capture 2)
1001                    ".*" +
1002                    ")\\)|)",
1003
1004                // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
1005                rwhitespace = new RegExp( whitespace + "+", "g" ),
1006                rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" +
1007                    whitespace + "+$", "g" ),
1008
1009                rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
1010                rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace +
1011                    "*" ),
1012                rdescend = new RegExp( whitespace + "|>" ),
1013
1014                rpseudo = new RegExp( pseudos ),
1015                ridentifier = new RegExp( "^" + identifier + "$" ),
1016
1017                matchExpr = {
1018                    "ID": new RegExp( "^#(" + identifier + ")" ),
1019                    "CLASS": new RegExp( "^\\.(" + identifier + ")" ),
1020                    "TAG": new RegExp( "^(" + identifier + "|[*])" ),
1021                    "ATTR": new RegExp( "^" + attributes ),
1022                    "PSEUDO": new RegExp( "^" + pseudos ),
1023                    "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
1024                        whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
1025                        whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
1026                    "bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
1027
1028                    // For use in libraries implementing .is()
1029                    // We use this for POS matching in `select`
1030                    "needsContext": new RegExp( "^" + whitespace +
1031                        "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
1032                        "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
1033                },
1034
1035                rhtml = /HTML$/i,
1036                rinputs = /^(?:input|select|textarea|button)$/i,
1037                rheader = /^h\d$/i,
1038
1039                rnative = /^[^{]+\{\s*\[native \w/,
1040
1041                // Easily-parseable/retrievable ID or TAG or CLASS selectors
1042                rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
1043
1044                rsibling = /[+~]/,
1045
1046                // CSS escapes
1047                // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
1048                runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ),
1049                funescape = function( escape, nonHex ) {
1050                    var high = "0x" + escape.slice( 1 ) - 0x10000;
1051
1052                    return nonHex ?
1053
1054                        // Strip the backslash prefix from a non-hex escape sequence
1055                        nonHex :
1056
1057                        // Replace a hexadecimal escape sequence with the encoded Unicode code point
1058                        // Support: IE <=11+
1059                        // For values outside the Basic Multilingual Plane (BMP), manually construct a
1060                        // surrogate pair
1061                        high < 0 ?
1062                            String.fromCharCode( high + 0x10000 ) :
1063                            String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
1064                },
1065
1066                // CSS string/identifier serialization
1067                // https://drafts.csswg.org/cssom/#common-serializing-idioms
1068                rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
1069                fcssescape = function( ch, asCodePoint ) {
1070                    if ( asCodePoint ) {
1071
1072                        // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
1073                        if ( ch === "\0" ) {
1074                            return "\uFFFD";
1075                        }
1076
1077                        // Control characters and (dependent upon position) numbers get escaped as code points
1078                        return ch.slice( 0, -1 ) + "\\" +
1079                            ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
1080                    }
1081
1082                    // Other potentially-special ASCII characters get backslash-escaped
1083                    return "\\" + ch;
1084                },
1085
1086                // Used for iframes
1087                // See setDocument()
1088                // Removing the function wrapper causes a "Permission Denied"
1089                // error in IE
1090                unloadHandler = function() {
1091                    setDocument();
1092                },
1093
1094                inDisabledFieldset = addCombinator(
1095                    function( elem ) {
1096                        return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
1097                    },
1098                    { dir: "parentNode", next: "legend" }
1099                );
1100
1101// Optimize for push.apply( _, NodeList )
1102            try {
1103                push.apply(
1104                    ( arr = slice.call( preferredDoc.childNodes ) ),
1105                    preferredDoc.childNodes
1106                );
1107
1108                // Support: Android<4.0
1109                // Detect silently failing push.apply
1110                // eslint-disable-next-line no-unused-expressions
1111                arr[ preferredDoc.childNodes.length ].nodeType;
1112            } catch ( e ) {
1113                push = { apply: arr.length ?
1114
1115                        // Leverage slice if possible
1116                        function( target, els ) {
1117                            pushNative.apply( target, slice.call( els ) );
1118                        } :
1119
1120                        // Support: IE<9
1121                        // Otherwise append directly
1122                        function( target, els ) {
1123                            var j = target.length,
1124                                i = 0;
1125
1126                            // Can't trust NodeList.length
1127                            while ( ( target[ j++ ] = els[ i++ ] ) ) {}
1128                            target.length = j - 1;
1129                        }
1130                };
1131            }
1132
1133            function Sizzle( selector, context, results, seed ) {
1134                var m, i, elem, nid, match, groups, newSelector,
1135                    newContext = context && context.ownerDocument,
1136
1137                    // nodeType defaults to 9, since context defaults to document
1138                    nodeType = context ? context.nodeType : 9;
1139
1140                results = results || [];
1141
1142                // Return early from calls with invalid selector or context
1143                if ( typeof selector !== "string" || !selector ||
1144                    nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
1145
1146                    return results;
1147                }
1148
1149                // Try to shortcut find operations (as opposed to filters) in HTML documents
1150                if ( !seed ) {
1151                    setDocument( context );
1152                    context = context || document;
1153
1154                    if ( documentIsHTML ) {
1155
1156                        // If the selector is sufficiently simple, try using a "get*By*" DOM method
1157                        // (excepting DocumentFragment context, where the methods don't exist)
1158                        if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
1159
1160                            // ID selector
1161                            if ( ( m = match[ 1 ] ) ) {
1162
1163                                // Document context
1164                                if ( nodeType === 9 ) {
1165                                    if ( ( elem = context.getElementById( m ) ) ) {
1166
1167                                        // Support: IE, Opera, Webkit
1168                                        // TODO: identify versions
1169                                        // getElementById can match elements by name instead of ID
1170                                        if ( elem.id === m ) {
1171                                            results.push( elem );
1172                                            return results;
1173                                        }
1174                                    } else {
1175                                        return results;
1176                                    }
1177
1178                                    // Element context
1179                                } else {
1180
1181                                    // Support: IE, Opera, Webkit
1182                                    // TODO: identify versions
1183                                    // getElementById can match elements by name instead of ID
1184                                    if ( newContext && ( elem = newContext.getElementById( m ) ) &&
1185                                        contains( context, elem ) &&
1186                                        elem.id === m ) {
1187
1188                                        results.push( elem );
1189                                        return results;
1190                                    }
1191                                }
1192
1193                                // Type selector
1194                            } else if ( match[ 2 ] ) {
1195                                push.apply( results, context.getElementsByTagName( selector ) );
1196                                return results;
1197
1198                                // Class selector
1199                            } else if ( ( m = match[ 3 ] ) && support.getElementsByClassName &&
1200                                context.getElementsByClassName ) {
1201
1202                                push.apply( results, context.getElementsByClassName( m ) );
1203                                return results;
1204                            }
1205                        }
1206
1207                        // Take advantage of querySelectorAll
1208                        if ( support.qsa &&
1209                            !nonnativeSelectorCache[ selector + " " ] &&
1210                            ( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&
1211
1212                            // Support: IE 8 only
1213                            // Exclude object elements
1214                            ( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) {
1215
1216                            newSelector = selector;
1217                            newContext = context;
1218
1219                            // qSA considers elements outside a scoping root when evaluating child or
1220                            // descendant combinators, which is not what we want.
1221                            // In such cases, we work around the behavior by prefixing every selector in the
1222                            // list with an ID selector referencing the scope context.
1223                            // The technique has to be used as well when a leading combinator is used
1224                            // as such selectors are not recognized by querySelectorAll.
1225                            // Thanks to Andrew Dupont for this technique.
1226                            if ( nodeType === 1 &&
1227                                ( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {
1228
1229                                // Expand context for sibling selectors
1230                                newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
1231                                    context;
1232
1233                                // We can use :scope instead of the ID hack if the browser
1234                                // supports it & if we're not changing the context.
1235                                if ( newContext !== context || !support.scope ) {
1236
1237                                    // Capture the context ID, setting it first if necessary
1238                                    if ( ( nid = context.getAttribute( "id" ) ) ) {
1239                                        nid = nid.replace( rcssescape, fcssescape );
1240                                    } else {
1241                                        context.setAttribute( "id", ( nid = expando ) );
1242                                    }
1243                                }
1244
1245                                // Prefix every selector in the list
1246                                groups = tokenize( selector );
1247                                i = groups.length;
1248                                while ( i-- ) {
1249                                    groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
1250                                        toSelector( groups[ i ] );
1251                                }
1252                                newSelector = groups.join( "," );
1253                            }
1254
1255                            try {
1256                                push.apply( results,
1257                                    newContext.querySelectorAll( newSelector )
1258                                );
1259                                return results;
1260                            } catch ( qsaError ) {
1261                                nonnativeSelectorCache( selector, true );
1262                            } finally {
1263                                if ( nid === expando ) {
1264                                    context.removeAttribute( "id" );
1265                                }
1266                            }
1267                        }
1268                    }
1269                }
1270
1271                // All others
1272                return select( selector.replace( rtrim, "$1" ), context, results, seed );
1273            }
1274
1275            /**
1276             * Create key-value caches of limited size
1277             * @returns {function(string, object)} Returns the Object data after storing it on itself with
1278             *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
1279             *	deleting the oldest entry
1280             */
1281            function createCache() {
1282                var keys = [];
1283
1284                function cache( key, value ) {
1285
1286                    // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
1287                    if ( keys.push( key + " " ) > Expr.cacheLength ) {
1288
1289                        // Only keep the most recent entries
1290                        delete cache[ keys.shift() ];
1291                    }
1292                    return ( cache[ key + " " ] = value );
1293                }
1294                return cache;
1295            }
1296
1297            /**
1298             * Mark a function for special use by Sizzle
1299             * @param {Function} fn The function to mark
1300             */
1301            function markFunction( fn ) {
1302                fn[ expando ] = true;
1303                return fn;
1304            }
1305
1306            /**
1307             * Support testing using an element
1308             * @param {Function} fn Passed the created element and returns a boolean result
1309             */
1310            function assert( fn ) {
1311                var el = document.createElement( "fieldset" );
1312
1313                try {
1314                    return !!fn( el );
1315                } catch ( e ) {
1316                    return false;

1317                } finally {
1318
1319                    // Remove from its parent by default
1320                    if ( el.parentNode ) {
1321                        el.parentNode.removeChild( el );
1322                    }
1323
1324                    // release memory in IE
1325                    el = null;
1326                }
1327            }
1328
1329            /**
1330             * Adds the same handler for all of the specified attrs
1331             * @param {String} attrs Pipe-separated list of attributes
1332             * @param {Function} handler The method that will be applied
1333             */
1334            function addHandle( attrs, handler ) {
1335                var arr = attrs.split( "|" ),
1336                    i = arr.length;
1337
1338                while ( i-- ) {
1339                    Expr.attrHandle[ arr[ i ] ] = handler;
1340                }
1341            }
1342
1343            /**
1344             * Checks document order of two siblings
1345             * @param {Element} a
1346             * @param {Element} b
1347             * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
1348             */
1349            function siblingCheck( a, b ) {
1350                var cur = b && a,
1351                    diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
1352                        a.sourceIndex - b.sourceIndex;
1353
1354                // Use IE sourceIndex if available on both nodes
1355                if ( diff ) {
1356                    return diff;
1357                }
1358
1359                // Check if b follows a
1360                if ( cur ) {
1361                    while ( ( cur = cur.nextSibling ) ) {
1362                        if ( cur === b ) {
1363                            return -1;
1364                        }
1365                    }
1366                }
1367
1368                return a ? 1 : -1;
1369            }
1370
1371            /**
1372             * Returns a function to use in pseudos for input types
1373             * @param {String} type
1374             */
1375            function createInputPseudo( type ) {
1376                return function( elem ) {
1377                    var name = elem.nodeName.toLowerCase();
1378                    return name === "input" && elem.type === type;
1379                };
1380            }
1381
1382            /**
1383             * Returns a function to use in pseudos for buttons
1384             * @param {String} type
1385             */
1386            function createButtonPseudo( type ) {
1387                return function( elem ) {
1388                    var name = elem.nodeName.toLowerCase();
1389                    return ( name === "input" || name === "button" ) && elem.type === type;
1390                };
1391            }
1392
1393            /**
1394             * Returns a function to use in pseudos for :enabled/:disabled
1395             * @param {Boolean} disabled true for :disabled; false for :enabled
1396             */
1397            function createDisabledPseudo( disabled ) {
1398
1399                // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
1400                return function( elem ) {
1401
1402                    // Only certain elements can match :enabled or :disabled
1403                    // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
1404                    // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
1405                    if ( "form" in elem ) {
1406
1407                        // Check for inherited disabledness on relevant non-disabled elements:
1408                        // * listed form-associated elements in a disabled fieldset
1409                        //   https://html.spec.whatwg.org/multipage/forms.html#category-listed
1410                        //   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
1411                        // * option elements in a disabled optgroup
1412                        //   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
1413                        // All such elements have a "form" property.
1414                        if ( elem.parentNode && elem.disabled === false ) {
1415
1416                            // Option elements defer to a parent optgroup if present
1417                            if ( "label" in elem ) {
1418                                if ( "label" in elem.parentNode ) {
1419                                    return elem.parentNode.disabled === disabled;
1420                                } else {
1421                                    return elem.disabled === disabled;
1422                                }
1423                            }
1424

1425                            // Support: IE 6 - 11
1426                            // Use the isDisabled shortcut property to check for disabled fieldset ancestors
1427                            return elem.isDisabled === disabled ||
1428
1429                                // Where there is no isDisabled, check manually
1430                                /* jshint -W018 */
1431                                elem.isDisabled !== !disabled &&
1432                                inDisabledFieldset( elem ) === disabled;
1433                        }
1434
1435                        return elem.disabled === disabled;
1436
1437                        // Try to winnow out elements that can't be disabled before trusting the disabled property.
1438                        // Some victims get caught in our net (label, legend, menu, track), but it shouldn't
1439                        // even exist on them, let alone have a boolean value.
1440                    } else if ( "label" in elem ) {
1441                        return elem.disabled === disabled;
1442                    }
1443
1444                    // Remaining elements are neither :enabled nor :disabled
1445                    return false;
1446                };
1447            }
1448
1449            /**
1450             * Returns a function to use in pseudos for positionals
1451             * @param {Function} fn
1452             */
1453            function createPositionalPseudo( fn ) {
1454                return markFunction( function( argument ) {
1455                    argument = +argument;
1456                    return markFunction( function( seed, matches ) {
1457                        var j,
1458                            matchIndexes = fn( [], seed.length, argument ),
1459                            i = matchIndexes.length;
1460
1461                        // Match elements found at the specified indexes
1462                        while ( i-- ) {
1463                            if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
1464                                seed[ j ] = !( matches[ j ] = seed[ j ] );
1465                            }
1466                        }
1467                    } );
1468                } );
1469            }
1470
1471            /**
1472             * Checks a node for validity as a Sizzle context
1473             * @param {Element|Object=} context
1474             * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1475             */
1476            function testContext( context ) {
1477                return context && typeof context.getElementsByTagName !== "undefined" && context;
1478            }
1479
1480// Expose support vars for convenience
1481            support = Sizzle.support = {};
1482
1483            /**
1484             * Detects XML nodes
1485             * @param {Element|Object} elem An element or a document
1486             * @returns {Boolean} True iff elem is a non-HTML XML node
1487             */
1488            isXML = Sizzle.isXML = function( elem ) {
1489                var namespace = elem && elem.namespaceURI,
1490                    docElem = elem && ( elem.ownerDocument || elem ).documentElement;
1491
1492                // Support: IE <=8
1493                // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes
1494                // https://bugs.jquery.com/ticket/4833
1495                return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" );
1496            };
1497
1498            /**
1499             * Sets document-related variables once based on the current document
1500             * @param {Element|Object} [doc] An element or document object to use to set the document
1501             * @returns {Object} Returns the current document
1502             */
1503            setDocument = Sizzle.setDocument = function( node ) {
1504                var hasCompare, subWindow,
1505                    doc = node ? node.ownerDocument || node : preferredDoc;
1506
1507                // Return early if doc is invalid or already selected
1508                // Support: IE 11+, Edge 17 - 18+
1509                // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1510                // two documents; shallow comparisons work.
1511                // eslint-disable-next-line eqeqeq
1512                if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {
1513                    return document;
1514                }
1515
1516                // Update global variables
1517                document = doc;
1518                docElem = document.documentElement;
1519                documentIsHTML = !isXML( document );
1520
1521                // Support: IE 9 - 11+, Edge 12 - 18+
1522                // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
1523                // Support: IE 11+, Edge 17 - 18+
1524                // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1525                // two documents; shallow comparisons work.
1526                // eslint-disable-next-line eqeqeq
1527                if ( preferredDoc != document &&
1528                    ( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
1529
1530                    // Support: IE 11, Edge
1531                    if ( subWindow.addEventListener ) {
1532                        subWindow.addEventListener( "unload", unloadHandler, false );
1533
1534                        // Support: IE 9 - 10 only
1535                    } else if ( subWindow.attachEvent ) {
1536                        subWindow.attachEvent( "onunload", unloadHandler );
1537                    }
1538                }
1539
1540                // Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,
1541                // Safari 4 - 5 only, Opera <=11.6 - 12.x only
1542                // IE/Edge & older browsers don't support the :scope pseudo-class.
1543                // Support: Safari 6.0 only
1544                // Safari 6.0 supports :scope but it's an alias of :root there.
1545                support.scope = assert( function( el ) {
1546                    docElem.appendChild( el ).appendChild( document.createElement( "div" ) );
1547                    return typeof el.querySelectorAll !== "undefined" &&
1548                        !el.querySelectorAll( ":scope fieldset div" ).length;
1549                } );
1550
1551                /* Attributes
1552	---------------------------------------------------------------------- */
1553
1554                // Support: IE<8
1555                // Verify that getAttribute really returns attributes and not properties
1556                // (excepting IE8 booleans)
1557                support.attributes = assert( function( el ) {
1558                    el.className = "i";
1559                    return !el.getAttribute( "className" );
1560                } );
1561
1562                /* getElement(s)By*
1563	---------------------------------------------------------------------- */
1564
1565                // Check if getElementsByTagName("*") returns only elements
1566                support.getElementsByTagName = assert( function( el ) {
1567                    el.appendChild( document.createComment( "" ) );
1568                    return !el.getElementsByTagName( "*" ).length;
1569                } );
1570
1571                // Support: IE<9
1572                support.getElementsByClassName = rnative.test( document.getElementsByClassName );
1573
1574                // Support: IE<10
1575                // Check if getElementById returns elements by name
1576                // The broken getElementById methods don't pick up programmatically-set names,
1577                // so use a roundabout getElementsByName test
1578                support.getById = assert( function( el ) {
1579                    docElem.appendChild( el ).id = expando;
1580                    return !document.getElementsByName || !document.getElementsByName( expando ).length;
1581                } );
1582
1583                // ID filter and find
1584                if ( support.getById ) {
1585                    Expr.filter[ "ID" ] = function( id ) {
1586                        var attrId = id.replace( runescape, funescape );
1587                        return function( elem ) {
1588                            return elem.getAttribute( "id" ) === attrId;
1589                        };
1590                    };
1591                    Expr.find[ "ID" ] = function( id, context ) {
1592                        if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1593                            var elem = context.getElementById( id );
1594                            return elem ? [ elem ] : [];
1595                        }
1596                    };
1597                } else {
1598                    Expr.filter[ "ID" ] =  function( id ) {
1599                        var attrId = id.replace( runescape, funescape );
1600                        return function( elem ) {
1601                            var node = typeof elem.getAttributeNode !== "undefined" &&
1602                                elem.getAttributeNode( "id" );
1603                            return node && node.value === attrId;
1604                        };
1605                    };
1606
1607                    // Support: IE 6 - 7 only
1608                    // getElementById is not reliable as a find shortcut
1609                    Expr.find[ "ID" ] = function( id, context ) {
1610                        if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1611                            var node, i, elems,
1612                                elem = context.getElementById( id );
1613
1614                            if ( elem ) {
1615
1616                                // Verify the id attribute
1617                                node = elem.getAttributeNode( "id" );
1618                                if ( node && node.value === id ) {
1619                                    return [ elem ];
1620                                }
1621
1622                                // Fall back on getElementsByName
1623                                elems = context.getElementsByName( id );
1624                                i = 0;
1625                                while ( ( elem = elems[ i++ ] ) ) {
1626                                    node = elem.getAttributeNode( "id" );
1627                                    if ( node && node.value === id ) {
1628                                        return [ elem ];
1629                                    }
1630                                }
1631                            }
1632
1633                            return [];
1634                        }
1635                    };
1636                }
1637
1638                // Tag
1639                Expr.find[ "TAG" ] = support.getElementsByTagName ?
1640                    function( tag, context ) {
1641                        if ( typeof context.getElementsByTagName !== "undefined" ) {
1642                            return context.getElementsByTagName( tag );
1643
1644                            // DocumentFragment nodes don't have gEBTN
1645                        } else if ( support.qsa ) {
1646                            return context.querySelectorAll( tag );
1647                        }
1648                    } :
1649
1650                    function( tag, context ) {
1651                        var elem,
1652                            tmp = [],
1653                            i = 0,
1654
1655                            // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1656                            results = context.getElementsByTagName( tag );
1657
1658                        // Filter out possible comments
1659                        if ( tag === "*" ) {
1660                            while ( ( elem = results[ i++ ] ) ) {
1661                                if ( elem.nodeType === 1 ) {
1662                                    tmp.push( elem );
1663                                }
1664                            }
1665
1666                            return tmp;
1667                        }
1668                        return results;
1669                    };
1670
1671                // Class
1672                Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) {
1673                    if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
1674                        return context.getElementsByClassName( className );
1675                    }
1676                };
1677
1678                /* QSA/matchesSelector
1679	---------------------------------------------------------------------- */
1680
1681                // QSA and matchesSelector support
1682
1683                // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1684                rbuggyMatches = [];
1685
1686                // qSa(:focus) reports false when true (Chrome 21)
1687                // We allow this because of a bug in IE8/9 that throws an error
1688                // whenever `document.activeElement` is accessed on an iframe
1689                // So, we allow :focus to pass through QSA all the time to avoid the IE error
1690                // See https://bugs.jquery.com/ticket/13378
1691                rbuggyQSA = [];
1692
1693                if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {
1694
1695                    // Build QSA regex
1696                    // Regex strategy adopted from Diego Perini
1697                    assert( function( el ) {
1698
1699                        var input;
1700
1701                        // Select is set to empty string on purpose
1702                        // This is to test IE's treatment of not explicitly
1703                        // setting a boolean content attribute,
1704                        // since its presence should be enough
1705                        // https://bugs.jquery.com/ticket/12359
1706                        docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
1707                            "<select id='" + expando + "-\r\\' msallowcapture=''>" +
1708                            "<option selected=''></option></select>";
1709
1710                        // Support: IE8, Opera 11-12.16
1711                        // Nothing should be selected when empty strings follow ^= or $= or *=
1712                        // The test attribute must be unknown in Opera but "safe" for WinRT
1713                        // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1714                        if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) {
1715                            rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1716                        }
1717
1718                        // Support: IE8
1719                        // Boolean attributes and "value" are not treated correctly
1720                        if ( !el.querySelectorAll( "[selected]" ).length ) {
1721                            rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1722                        }
1723
1724                        // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1725                        if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1726                            rbuggyQSA.push( "~=" );
1727                        }
1728
1729                        // Support: IE 11+, Edge 15 - 18+
1730                        // IE 11/Edge don't find elements on a `[name='']` query in some cases.
1731                        // Adding a temporary attribute to the document before the selection works
1732                        // around the issue.
1733                        // Interestingly, IE 10 & older don't seem to have the issue.
1734                        input = document.createElement( "input" );
1735                        input.setAttribute( "name", "" );
1736                        el.appendChild( input );
1737                        if ( !el.querySelectorAll( "[name='']" ).length ) {
1738                            rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" +
1739                                whitespace + "*(?:''|\"\")" );
1740                        }
1741
1742                        // Webkit/Opera - :checked should return selected option elements
1743                        // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1744                        // IE8 throws error here and will not see later tests
1745                        if ( !el.querySelectorAll( ":checked" ).length ) {
1746                            rbuggyQSA.push( ":checked" );
1747                        }
1748
1749                        // Support: Safari 8+, iOS 8+
1750                        // https://bugs.webkit.org/show_bug.cgi?id=136851
1751                        // In-page `selector#id sibling-combinator selector` fails
1752                        if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
1753                            rbuggyQSA.push( ".#.+[+~]" );
1754                        }
1755
1756                        // Support: Firefox <=3.6 - 5 only
1757                        // Old Firefox doesn't throw on a badly-escaped identifier.
1758                        el.querySelectorAll( "\\\f" );
1759                        rbuggyQSA.push( "[\\r\\n\\f]" );
1760                    } );
1761
1762                    assert( function( el ) {
1763                        el.innerHTML = "<a href='' disabled='disabled'></a>" +
1764                            "<select disabled='disabled'><option/></select>";
1765
1766                        // Support: Windows 8 Native Apps
1767                        // The type and name attributes are restricted during .innerHTML assignment
1768                        var input = document.createElement( "input" );
1769                        input.setAttribute( "type", "hidden" );
1770                        el.appendChild( input ).setAttribute( "name", "D" );
1771
1772                        // Support: IE8
1773                        // Enforce case-sensitivity of name attribute
1774                        if ( el.querySelectorAll( "[name=d]" ).length ) {
1775                            rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1776                        }
1777
1778                        // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1779                        // IE8 throws error here and will not see later tests
1780                        if ( el.querySelectorAll( ":enabled" ).length !== 2 ) {
1781                            rbuggyQSA.push( ":enabled", ":disabled" );
1782                        }
1783
1784                        // Support: IE9-11+
1785                        // IE's :disabled selector does not pick up the children of disabled fieldsets
1786                        docElem.appendChild( el ).disabled = true;
1787                        if ( el.querySelectorAll( ":disabled" ).length !== 2 ) {
1788                            rbuggyQSA.push( ":enabled", ":disabled" );
1789                        }
1790
1791                        // Support: Opera 10 - 11 only
1792                        // Opera 10-11 does not throw on post-comma invalid pseudos
1793                        el.querySelectorAll( "*,:x" );
1794                        rbuggyQSA.push( ",.*:" );
1795                    } );
1796                }
1797
1798                if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches ||
1799                    docElem.webkitMatchesSelector ||
1800                    docElem.mozMatchesSelector ||
1801                    docElem.oMatchesSelector ||
1802                    docElem.msMatchesSelector ) ) ) ) {
1803
1804                    assert( function( el ) {
1805
1806                        // Check to see if it's possible to do matchesSelector
1807                        // on a disconnected node (IE 9)
1808                        support.disconnectedMatch = matches.call( el, "*" );
1809
1810                        // This should fail with an exception
1811                        // Gecko does not error, returns false instead
1812                        matches.call( el, "[s!='']:x" );
1813                        rbuggyMatches.push( "!=", pseudos );
1814                    } );
1815                }
1816
1817                rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) );
1818                rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( "|" ) );
1819
1820                /* Contains
1821	---------------------------------------------------------------------- */
1822                hasCompare = rnative.test( docElem.compareDocumentPosition );
1823
1824                // Element contains another
1825                // Purposefully self-exclusive
1826                // As in, an element does not contain itself
1827                contains = hasCompare || rnative.test( docElem.contains ) ?
1828                    function( a, b ) {
1829                        var adown = a.nodeType === 9 ? a.documentElement : a,
1830                            bup = b && b.parentNode;
1831                        return a === bup || !!( bup && bup.nodeType === 1 && (
1832                            adown.contains ?
1833                                adown.contains( bup ) :
1834                                a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1835                        ) );
1836                    } :
1837                    function( a, b ) {
1838                        if ( b ) {
1839                            while ( ( b = b.parentNode ) ) {
1840                                if ( b === a ) {
1841                                    return true;
1842                                }
1843                            }
1844                        }
1845                        return false;
1846                    };
1847
1848                /* Sorting
1849	---------------------------------------------------------------------- */
1850
1851                // Document order sorting
1852                sortOrder = hasCompare ?
1853                    function( a, b ) {
1854
1855                        // Flag for duplicate removal
1856                        if ( a === b ) {
1857                            hasDuplicate = true;
1858                            return 0;
1859                        }
1860
1861                        // Sort on method existence if only one input has compareDocumentPosition
1862                        var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1863                        if ( compare ) {
1864                            return compare;
1865                        }
1866
1867                        // Calculate position if both inputs belong to the same document
1868                        // Support: IE 11+, Edge 17 - 18+
1869                        // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1870                        // two documents; shallow comparisons work.
1871                        // eslint-disable-next-line eqeqeq
1872                        compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?
1873                            a.compareDocumentPosition( b ) :
1874
1875                            // Otherwise we know they are disconnected
1876                            1;
1877
1878                        // Disconnected nodes
1879                        if ( compare & 1 ||
1880                            ( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {
1881
1882                            // Choose the first element that is related to our preferred document
1883                            // Support: IE 11+, Edge 17 - 18+
1884                            // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1885                            // two documents; shallow comparisons work.
1886                            // eslint-disable-next-line eqeqeq
1887                            if ( a == document || a.ownerDocument == preferredDoc &&
1888                                contains( preferredDoc, a ) ) {
1889                                return -1;
1890                            }
1891
1892                            // Support: IE 11+, Edge 17 - 18+
1893                            // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1894                            // two documents; shallow comparisons work.
1895                            // eslint-disable-next-line eqeqeq
1896                            if ( b == document || b.ownerDocument == preferredDoc &&
1897                                contains( preferredDoc, b ) ) {
1898                                return 1;
1899                            }
1900
1901                            // Maintain original order
1902                            return sortInput ?
1903                                ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1904                                0;
1905                        }
1906
1907                        return compare & 4 ? -1 : 1;
1908                    } :
1909                    function( a, b ) {
1910
1911                        // Exit early if the nodes are identical
1912                        if ( a === b ) {
1913                            hasDuplicate = true;
1914                            return 0;
1915                        }
1916
1917                        var cur,
1918                            i = 0,
1919                            aup = a.parentNode,
1920                            bup = b.parentNode,
1921                            ap = [ a ],
1922                            bp = [ b ];
1923
1924                        // Parentless nodes are either documents or disconnected
1925                        if ( !aup || !bup ) {
1926
1927                            // Support: IE 11+, Edge 17 - 18+
1928                            // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1929                            // two documents; shallow comparisons work.
1930                            /* eslint-disable eqeqeq */
1931                            return a == document ? -1 :
1932                                b == document ? 1 :
1933                                    /* eslint-enable eqeqeq */
1934                                    aup ? -1 :
1935                                        bup ? 1 :
1936                                            sortInput ?
1937                                                ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1938                                                0;
1939
1940                            // If the nodes are siblings, we can do a quick check
1941                        } else if ( aup === bup ) {
1942                            return siblingCheck( a, b );
1943                        }
1944
1945                        // Otherwise we need full lists of their ancestors for comparison
1946                        cur = a;
1947                        while ( ( cur = cur.parentNode ) ) {
1948                            ap.unshift( cur );
1949                        }
1950                        cur = b;
1951                        while ( ( cur = cur.parentNode ) ) {
1952                            bp.unshift( cur );
1953                        }
1954
1955                        // Walk down the tree looking for a discrepancy
1956                        while ( ap[ i ] === bp[ i ] ) {
1957                            i++;
1958                        }
1959
1960                        return i ?
1961
1962                            // Do a sibling check if the nodes have a common ancestor
1963                            siblingCheck( ap[ i ], bp[ i ] ) :
1964
1965                            // Otherwise nodes in our document sort first
1966                            // Support: IE 11+, Edge 17 - 18+
1967                            // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1968                            // two documents; shallow comparisons work.
1969                            /* eslint-disable eqeqeq */
1970                            ap[ i ] == preferredDoc ? -1 :
1971                                bp[ i ] == preferredDoc ? 1 :
1972                                    /* eslint-enable eqeqeq */
1973                                    0;
1974                    };
1975
1976                return document;
1977            };
1978
1979            Sizzle.matches = function( expr, elements ) {
1980                return Sizzle( expr, null, null, elements );
1981            };
1982
1983            Sizzle.matchesSelector = function( elem, expr ) {
1984                setDocument( elem );
1985
1986                if ( support.matchesSelector && documentIsHTML &&
1987                    !nonnativeSelectorCache[ expr + " " ] &&
1988                    ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1989                    ( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1990
1991                    try {
1992                        var ret = matches.call( elem, expr );
1993
1994                        // IE 9's matchesSelector returns false on disconnected nodes
1995                        if ( ret || support.disconnectedMatch ||
1996
1997                            // As well, disconnected nodes are said to be in a document
1998                            // fragment in IE 9
1999                            elem.document && elem.document.nodeType !== 11 ) {
2000                            return ret;
2001                        }
2002                    } catch ( e ) {
2003                        nonnativeSelectorCache( expr, true );
2004                    }
2005                }
2006
2007                return Sizzle( expr, document, null, [ elem ] ).length > 0;
2008            };
2009
2010            Sizzle.contains = function( context, elem ) {
2011
2012                // Set document vars if needed
2013                // Support: IE 11+, Edge 17 - 18+
2014                // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2015                // two documents; shallow comparisons work.
2016                // eslint-disable-next-line eqeqeq
2017                if ( ( context.ownerDocument || context ) != document ) {
2018                    setDocument( context );
2019                }
2020                return contains( context, elem );
2021            };
2022
2023            Sizzle.attr = function( elem, name ) {
2024
2025                // Set document vars if needed
2026                // Support: IE 11+, Edge 17 - 18+
2027                // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2028                // two documents; shallow comparisons work.
2029                // eslint-disable-next-line eqeqeq
2030                if ( ( elem.ownerDocument || elem ) != document ) {
2031                    setDocument( elem );
2032                }
2033
2034                var fn = Expr.attrHandle[ name.toLowerCase() ],
2035
2036                    // Don't get fooled by Object.prototype properties (jQuery #13807)
2037                    val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
2038                        fn( elem, name, !documentIsHTML ) :
2039                        undefined;
2040
2041                return val !== undefined ?
2042                    val :
2043                    support.attributes || !documentIsHTML ?
2044                        elem.getAttribute( name ) :
2045                        ( val = elem.getAttributeNode( name ) ) && val.specified ?
2046                            val.value :
2047                            null;
2048            };
2049
2050            Sizzle.escape = function( sel ) {
2051                return ( sel + "" ).replace( rcssescape, fcssescape );
2052            };
2053
2054            Sizzle.error = function( msg ) {
2055                throw new Error( "Syntax error, unrecognized expression: " + msg );
2056            };
2057
2058            /**
2059             * Document sorting and removing duplicates
2060             * @param {ArrayLike} results
2061             */
2062            Sizzle.uniqueSort = function( results ) {
2063                var elem,
2064                    duplicates = [],
2065                    j = 0,
2066                    i = 0;
2067
2068                // Unless we *know* we can detect duplicates, assume their presence
2069                hasDuplicate = !support.detectDuplicates;
2070                sortInput = !support.sortStable && results.slice( 0 );
2071                results.sort( sortOrder );
2072
2073                if ( hasDuplicate ) {
2074                    while ( ( elem = results[ i++ ] ) ) {
2075                        if ( elem === results[ i ] ) {
2076                            j = duplicates.push( i );
2077                        }
2078                    }
2079                    while ( j-- ) {
2080                        results.splice( duplicates[ j ], 1 );
2081                    }
2082                }
2083
2084                // Clear input after sorting to release objects
2085                // See https://github.com/jquery/sizzle/pull/225
2086                sortInput = null;
2087
2088                return results;
2089            };
2090
2091            /**
2092             * Utility function for retrieving the text value of an array of DOM nodes
2093             * @param {Array|Element} elem
2094             */
2095            getText = Sizzle.getText = function( elem ) {
2096                var node,
2097                    ret = "",
2098                    i = 0,
2099                    nodeType = elem.nodeType;
2100
2101                if ( !nodeType ) {
2102
2103                    // If no nodeType, this is expected to be an array
2104                    while ( ( node = elem[ i++ ] ) ) {
2105
2106                        // Do not traverse comment nodes
2107                        ret += getText( node );
2108                    }
2109                } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
2110
2111                    // Use textContent for elements
2112                    // innerText usage removed for consistency of new lines (jQuery #11153)
2113                    if ( typeof elem.textContent === "string" ) {
2114                        return elem.textContent;
2115                    } else {
2116
2117                        // Traverse its children
2118                        for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2119                            ret += getText( elem );
2120                        }
2121                    }
2122                } else if ( nodeType === 3 || nodeType === 4 ) {
2123                    return elem.nodeValue;
2124                }
2125

2126                // Do not include comment or processing instruction nodes
2127
2128                return ret;
2129            };
2130
2131            Expr = Sizzle.selectors = {
2132
2133                // Can be adjusted by the user
2134                cacheLength: 50,
2135
2136                createPseudo: markFunction,
2137
2138                match: matchExpr,
2139
2140                attrHandle: {},
2141
2142                find: {},
2143
2144                relative: {
2145                    ">": { dir: "parentNode", first: true },
2146                    " ": { dir: "parentNode" },
2147                    "+": { dir: "previousSibling", first: true },
2148                    "~": { dir: "previousSibling" }
2149                },
2150
2151                preFilter: {
2152                    "ATTR": function( match ) {
2153                        match[ 1 ] = match[ 1 ].replace( runescape, funescape );
2154
2155                        // Move the given value to match[3] whether quoted or unquoted
2156                        match[ 3 ] = ( match[ 3 ] || match[ 4 ] ||
2157                            match[ 5 ] || "" ).replace( runescape, funescape );
2158
2159                        if ( match[ 2 ] === "~=" ) {
2160                            match[ 3 ] = " " + match[ 3 ] + " ";
2161                        }
2162
2163                        return match.slice( 0, 4 );
2164                    },
2165
2166                    "CHILD": function( match ) {
2167
2168                        /* matches from matchExpr["CHILD"]
2169				1 type (only|nth|...)
2170				2 what (child|of-type)
2171				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
2172				4 xn-component of xn+y argument ([+-]?\d*n|)
2173				5 sign of xn-component
2174				6 x of xn-component
2175				7 sign of y-component
2176				8 y of y-component
2177			*/
2178                        match[ 1 ] = match[ 1 ].toLowerCase();
2179
2180                        if ( match[ 1 ].slice( 0, 3 ) === "nth" ) {
2181
2182                            // nth-* requires argument
2183                            if ( !match[ 3 ] ) {
2184                                Sizzle.error( match[ 0 ] );
2185                            }
2186
2187                            // numeric x and y parameters for Expr.filter.CHILD
2188                            // remember that false/true cast respectively to 0/1
2189                            match[ 4 ] = +( match[ 4 ] ?
2190                                match[ 5 ] + ( match[ 6 ] || 1 ) :
2191                                2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) );
2192                            match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" );
2193
2194                            // other types prohibit arguments
2195                        } else if ( match[ 3 ] ) {
2196                            Sizzle.error( match[ 0 ] );
2197                        }
2198
2199                        return match;
2200                    },
2201
2202                    "PSEUDO": function( match ) {
2203                        var excess,
2204                            unquoted = !match[ 6 ] && match[ 2 ];
2205
2206                        if ( matchExpr[ "CHILD" ].test( match[ 0 ] ) ) {
2207                            return null;
2208                        }
2209
2210                        // Accept quoted arguments as-is
2211                        if ( match[ 3 ] ) {
2212                            match[ 2 ] = match[ 4 ] || match[ 5 ] || "";
2213
2214                            // Strip excess characters from unquoted arguments
2215                        } else if ( unquoted && rpseudo.test( unquoted ) &&
2216
2217                            // Get excess from tokenize (recursively)
2218                            ( excess = tokenize( unquoted, true ) ) &&
2219
2220                            // advance to the next closing parenthesis
2221                            ( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) {
2222
2223                            // excess is a negative index
2224                            match[ 0 ] = match[ 0 ].slice( 0, excess );
2225                            match[ 2 ] = unquoted.slice( 0, excess );
2226                        }
2227
2228                        // Return only captures needed by the pseudo filter method (type and argument)
2229                        return match.slice( 0, 3 );
2230                    }
2231                },
2232
2233                filter: {
2234
2235                    "TAG": function( nodeNameSelector ) {
2236                        var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
2237                        return nodeNameSelector === "*" ?
2238                            function() {
2239                                return true;
2240                            } :
2241                            function( elem ) {
2242                                return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
2243                            };
2244                    },
2245
2246                    "CLASS": function( className ) {
2247                        var pattern = classCache[ className + " " ];
2248
2249                        return pattern ||
2250                            ( pattern = new RegExp( "(^|" + whitespace +
2251                                ")" + className + "(" + whitespace + "|$)" ) ) && classCache(
2252                                className, function( elem ) {
2253                                    return pattern.test(
2254                                        typeof elem.className === "string" && elem.className ||
2255                                        typeof elem.getAttribute !== "undefined" &&
2256                                        elem.getAttribute( "class" ) ||
2257                                        ""
2258                                    );
2259                                } );
2260                    },
2261
2262                    "ATTR": function( name, operator, check ) {
2263                        return function( elem ) {
2264                            var result = Sizzle.attr( elem, name );
2265
2266                            if ( result == null ) {
2267                                return operator === "!=";
2268                            }
2269                            if ( !operator ) {
2270                                return true;
2271                            }
2272
2273                            result += "";
2274
2275                            /* eslint-disable max-len */
2276
2277                            return operator === "=" ? result === check :
2278                                operator === "!=" ? result !== check :
2279                                    operator === "^=" ? check && result.indexOf( check ) === 0 :
2280                                        operator === "*=" ? check && result.indexOf( check ) > -1 :
2281                                            operator === "$=" ? check && result.slice( -check.length ) === check :
2282                                                operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
2283                                                    operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
2284                                                        false;
2285                            /* eslint-enable max-len */
2286
2287                        };
2288                    },
2289
2290                    "CHILD": function( type, what, _argument, first, last ) {
2291                        var simple = type.slice( 0, 3 ) !== "nth",
2292                            forward = type.slice( -4 ) !== "last",
2293                            ofType = what === "of-type";
2294
2295                        return first === 1 && last === 0 ?
2296
2297                            // Shortcut for :nth-*(n)
2298                            function( elem ) {
2299                                return !!elem.parentNode;
2300                            } :
2301
2302                            function( elem, _context, xml ) {
2303                                var cache, uniqueCache, outerCache, node, nodeIndex, start,
2304                                    dir = simple !== forward ? "nextSibling" : "previousSibling",
2305                                    parent = elem.parentNode,
2306                                    name = ofType && elem.nodeName.toLowerCase(),
2307                                    useCache = !xml && !ofType,
2308                                    diff = false;
2309
2310                                if ( parent ) {
2311
2312                                    // :(first|last|only)-(child|of-type)
2313                                    if ( simple ) {
2314                                        while ( dir ) {
2315                                            node = elem;
2316                                            while ( ( node = node[ dir ] ) ) {
2317                                                if ( ofType ?
2318                                                    node.nodeName.toLowerCase() === name :
2319                                                    node.nodeType === 1 ) {
2320
2321                                                    return false;
2322                                                }
2323                                            }
2324
2325                                            // Reverse direction for :only-* (if we haven't yet done so)
2326                                            start = dir = type === "only" && !start && "nextSibling";
2327                                        }
2328                                        return true;
2329                                    }
2330
2331                                    start = [ forward ? parent.firstChild : parent.lastChild ];
2332
2333                                    // non-xml :nth-child(...) stores cache data on `parent`
2334                                    if ( forward && useCache ) {
2335
2336                                        // Seek `elem` from a previously-cached index
2337
2338                                        // ...in a gzip-friendly way
2339                                        node = parent;
2340                                        outerCache = node[ expando ] || ( node[ expando ] = {} );
2341
2342                                        // Support: IE <9 only
2343                                        // Defend against cloned attroperties (jQuery gh-1709)
2344                                        uniqueCache = outerCache[ node.uniqueID ] ||
2345                                            ( outerCache[ node.uniqueID ] = {} );
2346
2347                                        cache = uniqueCache[ type ] || [];
2348                                        nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
2349                                        diff = nodeIndex && cache[ 2 ];
2350                                        node = nodeIndex && parent.childNodes[ nodeIndex ];
2351
2352                                        while ( ( node = ++nodeIndex && node && node[ dir ] ||
2353
2354                                            // Fallback to seeking `elem` from the start
2355                                            ( diff = nodeIndex = 0 ) || start.pop() ) ) {
2356
2357                                            // When found, cache indexes on `parent` and break
2358                                            if ( node.nodeType === 1 && ++diff && node === elem ) {
2359                                                uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
2360                                                break;
2361                                            }
2362                                        }
2363
2364                                    } else {
2365
2366                                        // Use previously-cached element index if available
2367                                        if ( useCache ) {
2368
2369                                            // ...in a gzip-friendly way
2370                                            node = elem;
2371                                            outerCache = node[ expando ] || ( node[ expando ] = {} );
2372
2373                                            // Support: IE <9 only
2374                                            // Defend against cloned attroperties (jQuery gh-1709)
2375                                            uniqueCache = outerCache[ node.uniqueID ] ||
2376                                                ( outerCache[ node.uniqueID ] = {} );
2377
2378                                            cache = uniqueCache[ type ] || [];
2379                                            nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
2380                                            diff = nodeIndex;
2381                                        }
2382
2383                                        // xml :nth-child(...)
2384                                        // or :nth-last-child(...) or :nth(-last)?-of-type(...)
2385                                        if ( diff === false ) {
2386
2387                                            // Use the same loop as above to seek `elem` from the start
2388                                            while ( ( node = ++nodeIndex && node && node[ dir ] ||
2389                                                ( diff = nodeIndex = 0 ) || start.pop() ) ) {
2390
2391                                                if ( ( ofType ?
2392                                                    node.nodeName.toLowerCase() === name :
2393                                                    node.nodeType === 1 ) &&
2394                                                    ++diff ) {
2395
2396                                                    // Cache the index of each encountered element
2397                                                    if ( useCache ) {
2398                                                        outerCache = node[ expando ] ||
2399                                                            ( node[ expando ] = {} );
2400

2401                                                        // Support: IE <9 only
2402                                                        // Defend against cloned attroperties (jQuery gh-1709)
2403                                                        uniqueCache = outerCache[ node.uniqueID ] ||
2404                                                            ( outerCache[ node.uniqueID ] = {} );
2405
2406                                                        uniqueCache[ type ] = [ dirruns, diff ];
2407                                                    }
2408
2409                                                    if ( node === elem ) {
2410                                                        break;
2411                                                    }
2412                                                }
2413                                            }
2414                                        }
2415                                    }
2416
2417                                    // Incorporate the offset, then check against cycle size
2418                                    diff -= last;
2419                                    return diff === first || ( diff % first === 0 && diff / first >= 0 );
2420                                }
2421                            };
2422                    },
2423
2424                    "PSEUDO": function( pseudo, argument ) {
2425
2426                        // pseudo-class names are case-insensitive
2427                        // http://www.w3.org/TR/selectors/#pseudo-classes
2428                        // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2429                        // Remember that setFilters inherits from pseudos
2430                        var args,
2431                            fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
2432                                Sizzle.error( "unsupported pseudo: " + pseudo );
2433
2434                        // The user may use createPseudo to indicate that
2435                        // arguments are needed to create the filter function
2436                        // just as Sizzle does
2437                        if ( fn[ expando ] ) {
2438                            return fn( argument );
2439                        }
2440
2441                        // But maintain support for old signatures
2442                        if ( fn.length > 1 ) {
2443                            args = [ pseudo, pseudo, "", argument ];
2444                            return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
2445                                markFunction( function( seed, matches ) {
2446                                    var idx,
2447                                        matched = fn( seed, argument ),
2448                                        i = matched.length;
2449                                    while ( i-- ) {
2450                                        idx = indexOf( seed, matched[ i ] );
2451                                        seed[ idx ] = !( matches[ idx ] = matched[ i ] );
2452                                    }
2453                                } ) :
2454                                function( elem ) {
2455                                    return fn( elem, 0, args );
2456                                };
2457                        }
2458
2459                        return fn;
2460                    }
2461                },
2462
2463                pseudos: {
2464
2465                    // Potentially complex pseudos
2466                    "not": markFunction( function( selector ) {
2467
2468                        // Trim the selector passed to compile
2469                        // to avoid treating leading and trailing
2470                        // spaces as combinators
2471                        var input = [],
2472                            results = [],
2473                            matcher = compile( selector.replace( rtrim, "$1" ) );
2474
2475                        return matcher[ expando ] ?
2476                            markFunction( function( seed, matches, _context, xml ) {
2477                                var elem,
2478                                    unmatched = matcher( seed, null, xml, [] ),
2479                                    i = seed.length;
2480
2481                                // Match elements unmatched by `matcher`
2482                                while ( i-- ) {
2483                                    if ( ( elem = unmatched[ i ] ) ) {
2484                                        seed[ i ] = !( matches[ i ] = elem );
2485                                    }
2486                                }
2487                            } ) :
2488                            function( elem, _context, xml ) {
2489                                input[ 0 ] = elem;
2490                                matcher( input, null, xml, results );
2491
2492                                // Don't keep the element (issue #299)
2493                                input[ 0 ] = null;
2494                                return !results.pop();
2495                            };
2496                    } ),
2497
2498                    "has": markFunction( function( selector ) {
2499                        return function( elem ) {
2500                            return Sizzle( selector, elem ).length > 0;
2501                        };
2502                    } ),
2503
2504                    "contains": markFunction( function( text ) {
2505                        text = text.replace( runescape, funescape );
2506                        return function( elem ) {
2507                            return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;
2508                        };
2509                    } ),
2510
2511                    // "Whether an element is represented by a :lang() selector
2512                    // is based solely on the element's language value
2513                    // being equal to the identifier C,
2514                    // or beginning with the identifier C immediately followed by "-".
2515                    // The matching of C against the element's language value is performed case-insensitively.
2516                    // The identifier C does not have to be a valid language name."
2517                    // http://www.w3.org/TR/selectors/#lang-pseudo
2518                    "lang": markFunction( function( lang ) {
2519
2520                        // lang value must be a valid identifier
2521                        if ( !ridentifier.test( lang || "" ) ) {
2522                            Sizzle.error( "unsupported lang: " + lang );
2523                        }
2524                        lang = lang.replace( runescape, funescape ).toLowerCase();
2525                        return function( elem ) {
2526                            var elemLang;
2527                            do {
2528                                if ( ( elemLang = documentIsHTML ?
2529                                    elem.lang :
2530                                    elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) {
2531
2532                                    elemLang = elemLang.toLowerCase();
2533                                    return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2534                                }
2535                            } while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );
2536                            return false;
2537                        };
2538                    } ),
2539
2540                    // Miscellaneous
2541                    "target": function( elem ) {
2542                        var hash = window.location && window.location.hash;
2543                        return hash && hash.slice( 1 ) === elem.id;
2544                    },
2545
2546                    "root": function( elem ) {
2547                        return elem === docElem;
2548                    },
2549
2550                    "focus": function( elem ) {
2551                        return elem === document.activeElement &&
2552                            ( !document.hasFocus || document.hasFocus() ) &&
2553                            !!( elem.type || elem.href || ~elem.tabIndex );
2554                    },
2555
2556                    // Boolean properties
2557                    "enabled": createDisabledPseudo( false ),
2558                    "disabled": createDisabledPseudo( true ),
2559
2560                    "checked": function( elem ) {
2561
2562                        // In CSS3, :checked should return both checked and selected elements
2563                        // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2564                        var nodeName = elem.nodeName.toLowerCase();
2565                        return ( nodeName === "input" && !!elem.checked ) ||
2566                            ( nodeName === "option" && !!elem.selected );
2567                    },
2568
2569                    "selected": function( elem ) {
2570
2571                        // Accessing this property makes selected-by-default
2572                        // options in Safari work properly
2573                        if ( elem.parentNode ) {
2574                            // eslint-disable-next-line no-unused-expressions
2575                            elem.parentNode.selectedIndex;
2576                        }
2577
2578                        return elem.selected === true;
2579                    },
2580
2581                    // Contents
2582                    "empty": function( elem ) {
2583
2584                        // http://www.w3.org/TR/selectors/#empty-pseudo
2585                        // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
2586                        //   but not by others (comment: 8; processing instruction: 7; etc.)
2587                        // nodeType < 6 works because attributes (2) do not appear as children
2588                        for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2589                            if ( elem.nodeType < 6 ) {
2590                                return false;
2591                            }
2592                        }
2593                        return true;
2594                    },
2595
2596                    "parent": function( elem ) {
2597                        return !Expr.pseudos[ "empty" ]( elem );
2598                    },
2599
2600                    // Element/input types
2601                    "header": function( elem ) {
2602                        return rheader.test( elem.nodeName );
2603                    },
2604
2605                    "input": function( elem ) {
2606                        return rinputs.test( elem.nodeName );
2607                    },
2608
2609                    "button": function( elem ) {
2610                        var name = elem.nodeName.toLowerCase();
2611                        return name === "input" && elem.type === "button" || name === "button";
2612                    },
2613
2614                    "text": function( elem ) {
2615                        var attr;
2616                        return elem.nodeName.toLowerCase() === "input" &&
2617                            elem.type === "text" &&
2618
2619                            // Support: IE<8
2620                            // New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
2621                            ( ( attr = elem.getAttribute( "type" ) ) == null ||
2622                                attr.toLowerCase() === "text" );
2623                    },
2624
2625                    // Position-in-collection
2626                    "first": createPositionalPseudo( function() {
2627                        return [ 0 ];
2628                    } ),
2629
2630                    "last": createPositionalPseudo( function( _matchIndexes, length ) {
2631                        return [ length - 1 ];
2632                    } ),
2633
2634                    "eq": createPositionalPseudo( function( _matchIndexes, length, argument ) {
2635                        return [ argument < 0 ? argument + length : argument ];
2636                    } ),
2637
2638                    "even": createPositionalPseudo( function( matchIndexes, length ) {
2639                        var i = 0;
2640                        for ( ; i < length; i += 2 ) {
2641                            matchIndexes.push( i );
2642                        }
2643                        return matchIndexes;
2644                    } ),
2645
2646                    "odd": createPositionalPseudo( function( matchIndexes, length ) {
2647                        var i = 1;
2648                        for ( ; i < length; i += 2 ) {
2649                            matchIndexes.push( i );
2650                        }
2651                        return matchIndexes;
2652                    } ),
2653
2654                    "lt": createPositionalPseudo( function( matchIndexes, length, argument ) {
2655                        var i = argument < 0 ?
2656                            argument + length :
2657                            argument > length ?
2658                                length :
2659                                argument;
2660                        for ( ; --i >= 0; ) {
2661                            matchIndexes.push( i );
2662                        }
2663                        return matchIndexes;
2664                    } ),
2665
2666                    "gt": createPositionalPseudo( function( matchIndexes, length, argument ) {
2667                        var i = argument < 0 ? argument + length : argument;
2668                        for ( ; ++i < length; ) {
2669                            matchIndexes.push( i );
2670                        }
2671                        return matchIndexes;
2672                    } )
2673                }
2674            };
2675
2676            Expr.pseudos[ "nth" ] = Expr.pseudos[ "eq" ];
2677
2678// Add button/input type pseudos
2679            for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2680                Expr.pseudos[ i ] = createInputPseudo( i );
2681            }
2682            for ( i in { submit: true, reset: true } ) {
2683                Expr.pseudos[ i ] = createButtonPseudo( i );
2684            }
2685
2686// Easy API for creating new setFilters
2687            function setFilters() {}
2688            setFilters.prototype = Expr.filters = Expr.pseudos;
2689            Expr.setFilters = new setFilters();
2690
2691            tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
2692                var matched, match, tokens, type,
2693                    soFar, groups, preFilters,
2694                    cached = tokenCache[ selector + " " ];
2695
2696                if ( cached ) {
2697                    return parseOnly ? 0 : cached.slice( 0 );
2698                }
2699
2700                soFar = selector;
2701                groups = [];
2702                preFilters = Expr.preFilter;
2703
2704                while ( soFar ) {
2705
2706                    // Comma and first run
2707                    if ( !matched || ( match = rcomma.exec( soFar ) ) ) {
2708                        if ( match ) {
2709
2710                            // Don't consume trailing commas as valid
2711                            soFar = soFar.slice( match[ 0 ].length ) || soFar;
2712                        }
2713                        groups.push( ( tokens = [] ) );
2714                    }
2715
2716                    matched = false;