How to use elem.nodeName.toLowerCase method in Cypress

1/*!2 * jquery javascript library v1.10.23 * http://jquery.com/4 *5 * includes sizzle.js6 * http://sizzlejs.com/7 *8 * copyright 2005, 2013 jquery foundation, inc. and other contributors9 * released under the mit license10 * http://jquery.org/license11 *12 * date: 2013-07-03t13:48z13 */14(function( window, undefined ) {15// can't do this because several apps including asp.net trace16// the stack via arguments.caller.callee and firefox dies if17// you try to trace through "use strict" call chains. (#13335)18// support: firefox 18+19//"use strict";20    var21    // the deferred used on dom ready22        readylist,23    // a central reference to the root jquery(document)24        rootjquery,25    // support: ie<1026    // for `typeof xmlnode.method` instead of `xmlnode.method !== undefined`27        core_strundefined = typeof undefined,28    // use the correct document accordingly with window argument (sandbox)29        location = window.location,30        document = window.document,31        docelem = document.documentelement,32    // map over jquery in case of overwrite33        _jquery = window.jquery,34    // map over the $ in case of overwrite35        _$ = window.$,36    // [[class]] -> type pairs37        class2type = {},38    // list of deleted data cache ids, so we can reuse them39        core_deletedids = [],40        core_version = "1.10.2",41    // save a reference to some core methods42        core_concat = core_deletedids.concat,43        core_push = core_deletedids.push,44        core_slice = core_deletedids.slice,45        core_indexof = core_deletedids.indexof,46        core_tostring = class2type.tostring,47        core_hasown = class2type.hasownproperty,48        core_trim = core_version.trim,49    // define a local copy of jquery50        jquery = function( selector, context ) {51            // the jquery object is actually just the init constructor 'enhanced'52            return new jquery.fn.init( selector, context, rootjquery );53        },54    // used for matching numbers55        core_pnum = /[+-]?(?:\d*\.|)\d+(?:[ee][+-]?\d+|)/.source,56    // used for splitting on whitespace57        core_rnotwhite = /\s+/g,58    // make sure we trim bom and nbsp (here's looking at you, safari 5.0 and ie)59        rtrim = /^[\s\ufeff\xa0]+|[\s\ufeff\xa0]+$/g,60    // a simple way to check for html strings61    // prioritize #id over <tag> to avoid xss via location.hash (#9521)62    // strict html recognition (#11290: must start with <)63        rquickexpr = /^(?:\s*(<[\w\w]+>)[^>]*|#([\w-]*))$/,64    // match a standalone tag65        rsingletag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,66    // json regexp67        rvalidchars = /^[\],:{}\s]*$/,68        rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,69        rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fa-f]{4})/g,70        rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[ee][+-]?\d+|)/g,71    // matches dashed string for camelizing72        rmsprefix = /^-ms-/,73        rdashalpha = /-([\da-z])/gi,74    // used by jquery.camelcase as callback to replace()75        fcamelcase = function( all, letter ) {76            return letter.touppercase();77        },78    // the ready event handler79        completed = function( event ) {80            // readystate === "complete" is good enough for us to call the dom ready in oldie81            if ( document.addeventlistener || event.type === "load" || document.readystate === "complete" ) {82                detach();83                jquery.ready();84            }85        },86    // clean-up method for dom ready events87        detach = function() {88            if ( document.addeventlistener ) {89                document.removeeventlistener( "domcontentloaded", completed, false );90                window.removeeventlistener( "load", completed, false );91            } else {92                document.detachevent( "onreadystatechange", completed );93                window.detachevent( "onload", completed );94            }95        };96    jquery.fn = jquery.prototype = {97        // the current version of jquery being used98        jquery: core_version,99        constructor: jquery,100        init: function( selector, context, rootjquery ) {101            var match, elem;102            // handle: $(""), $(null), $(undefined), $(false)103            if ( !selector ) {104                return this;105            }106            // handle html strings107            if ( typeof selector === "string" ) {108                if ( selector.charat(0) === "<" && selector.charat( selector.length - 1 ) === ">" && selector.length >= 3 ) {109                    // assume that strings that start and end with <> are html and skip the regex check110                    match = [ null, selector, null ];111                } else {112                    match = rquickexpr.exec( selector );113                }114                // match html or make sure no context is specified for #id115                if ( match && (match[1] || !context) ) {116                    // handle: $(html) -> $(array)117                    if ( match[1] ) {118                        context = context instanceof jquery ? context[0] : context;119                        // scripts is true for back-compat120                        jquery.merge( this, jquery.parsehtml(121                            match[1],122                                context && context.nodetype ? context.ownerdocument || context : document,123                            true124                        ) );125                        // handle: $(html, props)126                        if ( rsingletag.test( match[1] ) && jquery.isplainobject( context ) ) {127                            for ( match in context ) {128                                // properties of context are called as methods if possible129                                if ( jquery.isfunction( this[ match ] ) ) {130                                    this[ match ]( context[ match ] );131                                    // ...and otherwise set as attributes132                                } else {133                                    this.attr( match, context[ match ] );134                                }135                            }136                        }137                        return this;138                        // handle: $(#id)139                    } else {140                        elem = document.getelementbyid( match[2] );141                        // check parentnode to catch when blackberry 4.6 returns142                        // nodes that are no longer in the document #6963143                        if ( elem && elem.parentnode ) {144                            // handle the case where ie and opera return items145                            // by name instead of id146                            if ( elem.id !== match[2] ) {147                                return rootjquery.find( selector );148                            }149                            // otherwise, we inject the element directly into the jquery object150                            this.length = 1;151                            this[0] = elem;152                        }153                        this.context = document;154                        this.selector = selector;155                        return this;156                    }157                    // handle: $(expr, $(...))158                } else if ( !context || context.jquery ) {159                    return ( context || rootjquery ).find( selector );160                    // handle: $(expr, context)161                    // (which is just equivalent to: $(context).find(expr)162                } else {163                    return this.constructor( context ).find( selector );164                }165                // handle: $(domelement)166            } else if ( selector.nodetype ) {167                this.context = this[0] = selector;168                this.length = 1;169                return this;170                // handle: $(function)171                // shortcut for document ready172            } else if ( jquery.isfunction( selector ) ) {173                return rootjquery.ready( selector );174            }175            if ( selector.selector !== undefined ) {176                this.selector = selector.selector;177                this.context = selector.context;178            }179            return jquery.makearray( selector, this );180        },181        // start with an empty selector182        selector: "",183        // the default length of a jquery object is 0184        length: 0,185        toarray: function() {186            return core_slice.call( this );187        },188        // get the nth element in the matched element set or189        // get the whole matched element set as a clean array190        get: function( num ) {191            return num == null ?192                // return a 'clean' array193                this.toarray() :194                // return just the object195                ( num < 0 ? this[ this.length + num ] : this[ num ] );196        },197        // take an array of elements and push it onto the stack198        // (returning the new matched element set)199        pushstack: function( elems ) {200            // build a new jquery matched element set201            var ret = jquery.merge( this.constructor(), elems );202            // add the old object onto the stack (as a reference)203            ret.prevobject = this;204            ret.context = this.context;205            // return the newly-formed element set206            return ret;207        },208        // execute a callback for every element in the matched set.209        // (you can seed the arguments with an array of args, but this is210        // only used internally.)211        each: function( callback, args ) {212            return jquery.each( this, callback, args );213        },214        ready: function( fn ) {215            // add the callback216            jquery.ready.promise().done( fn );217            return this;218        },219        slice: function() {220            return this.pushstack( core_slice.apply( this, arguments ) );221        },222        first: function() {223            return this.eq( 0 );224        },225        last: function() {226            return this.eq( -1 );227        },228        eq: function( i ) {229            var len = this.length,230                j = +i + ( i < 0 ? len : 0 );231            return this.pushstack( j >= 0 && j < len ? [ this[j] ] : [] );232        },233        map: function( callback ) {234            return this.pushstack( jquery.map(this, function( elem, i ) {235                return callback.call( elem, i, elem );236            }));237        },238        end: function() {239            return this.prevobject || this.constructor(null);240        },241        // for internal use only.242        // behaves like an array's method, not like a jquery method.243        push: core_push,244        sort: [].sort,245        splice: [].splice246    };247// give the init function the jquery prototype for later instantiation248    jquery.fn.init.prototype = jquery.fn;249    jquery.extend = jquery.fn.extend = function() {250        var src, copyisarray, copy, name, options, clone,251            target = arguments[0] || {},252            i = 1,253            length = arguments.length,254            deep = false;255        // handle a deep copy situation256        if ( typeof target === "boolean" ) {257            deep = target;258            target = arguments[1] || {};259            // skip the boolean and the target260            i = 2;261        }262        // handle case when target is a string or something (possible in deep copy)263        if ( typeof target !== "object" && !jquery.isfunction(target) ) {264            target = {};265        }266        // extend jquery itself if only one argument is passed267        if ( length === i ) {268            target = this;269            --i;270        }271        for ( ; i < length; i++ ) {272            // only deal with non-null/undefined values273            if ( (options = arguments[ i ]) != null ) {274                // extend the base object275                for ( name in options ) {276                    src = target[ name ];277                    copy = options[ name ];278                    // prevent never-ending loop279                    if ( target === copy ) {280                        continue;281                    }282                    // recurse if we're merging plain objects or arrays283                    if ( deep && copy && ( jquery.isplainobject(copy) || (copyisarray = jquery.isarray(copy)) ) ) {284                        if ( copyisarray ) {285                            copyisarray = false;286                            clone = src && jquery.isarray(src) ? src : [];287                        } else {288                            clone = src && jquery.isplainobject(src) ? src : {};289                        }290                        // never move original objects, clone them291                        target[ name ] = jquery.extend( deep, clone, copy );292                        // don't bring in undefined values293                    } else if ( copy !== undefined ) {294                        target[ name ] = copy;295                    }296                }297            }298        }299        // return the modified object300        return target;301    };302    jquery.extend({303        // unique for each copy of jquery on the page304        // non-digits removed to match rinlinejquery305        expando: "jquery" + ( core_version + math.random() ).replace( /\d/g, "" ),306        noconflict: function( deep ) {307            if ( window.$ === jquery ) {308                window.$ = _$;309            }310            if ( deep && window.jquery === jquery ) {311                window.jquery = _jquery;312            }313            return jquery;314        },315        // is the dom ready to be used? set to true once it occurs.316        isready: false,317        // a counter to track how many items to wait for before318        // the ready event fires. see #6781319        readywait: 1,320        // hold (or release) the ready event321        holdready: function( hold ) {322            if ( hold ) {323                jquery.readywait++;324            } else {325                jquery.ready( true );326            }327        },328        // handle when the dom is ready329        ready: function( wait ) {330            // abort if there are pending holds or we're already ready331            if ( wait === true ? --jquery.readywait : jquery.isready ) {332                return;333            }334            // make sure body exists, at least, in case ie gets a little overzealous (ticket #5443).335            if ( !document.body ) {336                return settimeout( jquery.ready );337            }338            // remember that the dom is ready339            jquery.isready = true;340            // if a normal dom ready event fired, decrement, and wait if need be341            if ( wait !== true && --jquery.readywait > 0 ) {342                return;343            }344            // if there are functions bound, to execute345            readylist.resolvewith( document, [ jquery ] );346            // trigger any bound ready events347            if ( jquery.fn.trigger ) {348                jquery( document ).trigger("ready").off("ready");349            }350        },351        // see test/unit/core.js for details concerning isfunction.352        // since version 1.3, dom methods and functions like alert353        // aren't supported. they return false on ie (#2968).354        isfunction: function( obj ) {355            return jquery.type(obj) === "function";356        },357        isarray: array.isarray || function( obj ) {358            return jquery.type(obj) === "array";359        },360        iswindow: function( obj ) {361            /* jshint eqeqeq: false */362            return obj != null && obj == obj.window;363        },364        isnumeric: function( obj ) {365            return !isnan( parsefloat(obj) ) && isfinite( obj );366        },367        type: function( obj ) {368            if ( obj == null ) {369                return string( obj );370            }371            return typeof obj === "object" || typeof obj === "function" ?372                class2type[ core_tostring.call(obj) ] || "object" :373                typeof obj;374        },375        isplainobject: function( obj ) {376            var key;377            // must be an object.378            // because of ie, we also have to check the presence of the constructor property.379            // make sure that dom nodes and window objects don't pass through, as well380            if ( !obj || jquery.type(obj) !== "object" || obj.nodetype || jquery.iswindow( obj ) ) {381                return false;382            }383            try {384                // not own constructor property must be object385                if ( obj.constructor &&386                    !core_hasown.call(obj, "constructor") &&387                    !core_hasown.call(obj.constructor.prototype, "isprototypeof") ) {388                    return false;389                }390            } catch ( e ) {391                // ie8,9 will throw exceptions on certain host objects #9897392                return false;393            }394            // support: ie<9395            // handle iteration over inherited properties before own properties.396            if ( jquery.support.ownlast ) {397                for ( key in obj ) {398                    return core_hasown.call( obj, key );399                }400            }401            // own properties are enumerated firstly, so to speed up,402            // if last one is own, then all properties are own.403            for ( key in obj ) {}404            return key === undefined || core_hasown.call( obj, key );405        },406        isemptyobject: function( obj ) {407            var name;408            for ( name in obj ) {409                return false;410            }411            return true;412        },413        error: function( msg ) {414            throw new error( msg );415        },416        // data: string of html417        // context (optional): if specified, the fragment will be created in this context, defaults to document418        // keepscripts (optional): if true, will include scripts passed in the html string419        parsehtml: function( data, context, keepscripts ) {420            if ( !data || typeof data !== "string" ) {421                return null;422            }423            if ( typeof context === "boolean" ) {424                keepscripts = context;425                context = false;426            }427            context = context || document;428            var parsed = rsingletag.exec( data ),429                scripts = !keepscripts && [];430            // single tag431            if ( parsed ) {432                return [ context.createelement( parsed[1] ) ];433            }434            parsed = jquery.buildfragment( [ data ], context, scripts );435            if ( scripts ) {436                jquery( scripts ).remove();437            }438            return jquery.merge( [], parsed.childnodes );439        },440        parsejson: function( data ) {441            // attempt to parse using the native json parser first442            if ( window.json && window.json.parse ) {443                return window.json.parse( data );444            }445            if ( data === null ) {446                return data;447            }448            if ( typeof data === "string" ) {449                // make sure leading/trailing whitespace is removed (ie can't handle it)450                data = jquery.trim( data );451                if ( data ) {452                    // make sure the incoming data is actual json453                    // logic borrowed from http://json.org/json2.js454                    if ( rvalidchars.test( data.replace( rvalidescape, "@" )455                        .replace( rvalidtokens, "]" )456                        .replace( rvalidbraces, "")) ) {457                        return ( new function( "return " + data ) )();458                    }459                }460            }461            jquery.error( "invalid json: " + data );462        },463        // cross-browser xml parsing464        parsexml: function( data ) {465            var xml, tmp;466            if ( !data || typeof data !== "string" ) {467                return null;468            }469            try {470                if ( window.domparser ) { // standard471                    tmp = new domparser();472                    xml = tmp.parsefromstring( data , "text/xml" );473                } else { // ie474                    xml = new activexobject( "microsoft.xmldom" );475                    xml.async = "false";476                    xml.loadxml( data );477                }478            } catch( e ) {479                xml = undefined;480            }481            if ( !xml || !xml.documentelement || xml.getelementsbytagname( "parsererror" ).length ) {482                jquery.error( "invalid xml: " + data );483            }484            return xml;485        },486        noop: function() {},487        // evaluates a script in a global context488        // workarounds based on findings by jim driscoll489        // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context490        globaleval: function( data ) {491            if ( data && jquery.trim( data ) ) {492                // we use execscript on internet explorer493                // we use an anonymous function so that context is window494                // rather than jquery in firefox495                ( window.execscript || function( data ) {496                    window[ "eval" ].call( window, data );497                } )( data );498            }499        },500        // convert dashed to camelcase; used by the css and data modules501        // microsoft forgot to hump their vendor prefix (#9572)502        camelcase: function( string ) {503            return string.replace( rmsprefix, "ms-" ).replace( rdashalpha, fcamelcase );504        },505        nodename: function( elem, name ) {506            return elem.nodename && elem.nodename.tolowercase() === name.tolowercase();507        },508        // args is for internal usage only509        each: function( obj, callback, args ) {510            var value,511                i = 0,512                length = obj.length,513                isarray = isarraylike( obj );514            if ( args ) {515                if ( isarray ) {516                    for ( ; i < length; i++ ) {517                        value = callback.apply( obj[ i ], args );518                        if ( value === false ) {519                            break;520                        }521                    }522                } else {523                    for ( i in obj ) {524                        value = callback.apply( obj[ i ], args );525                        if ( value === false ) {526                            break;527                        }528                    }529                }530                // a special, fast, case for the most common use of each531            } else {532                if ( isarray ) {533                    for ( ; i < length; i++ ) {534                        value = callback.call( obj[ i ], i, obj[ i ] );535                        if ( value === false ) {536                            break;537                        }538                    }539                } else {540                    for ( i in obj ) {541                        value = callback.call( obj[ i ], i, obj[ i ] );542                        if ( value === false ) {543                            break;544                        }545                    }546                }547            }548            return obj;549        },550        // use native string.trim function wherever possible551        trim: core_trim && !core_trim.call("\ufeff\xa0") ?552            function( text ) {553                return text == null ?554                    "" :555                    core_trim.call( text );556            } :557            // otherwise use our own trimming functionality558            function( text ) {559                return text == null ?560                    "" :561                    ( text + "" ).replace( rtrim, "" );562            },563        // results is for internal usage only564        makearray: function( arr, results ) {565            var ret = results || [];566            if ( arr != null ) {567                if ( isarraylike( object(arr) ) ) {568                    jquery.merge( ret,569                            typeof arr === "string" ?570                            [ arr ] : arr571                    );572                } else {573                    core_push.call( ret, arr );574                }575            }576            return ret;577        },578        inarray: function( elem, arr, i ) {579            var len;580            if ( arr ) {581                if ( core_indexof ) {582                    return core_indexof.call( arr, elem, i );583                }584                len = arr.length;585                i = i ? i < 0 ? math.max( 0, len + i ) : i : 0;586                for ( ; i < len; i++ ) {587                    // skip accessing in sparse arrays588                    if ( i in arr && arr[ i ] === elem ) {589                        return i;590                    }591                }592            }593            return -1;594        },595        merge: function( first, second ) {596            var l = second.length,597                i = first.length,598                j = 0;599            if ( typeof l === "number" ) {600                for ( ; j < l; j++ ) {601                    first[ i++ ] = second[ j ];602                }603            } else {604                while ( second[j] !== undefined ) {605                    first[ i++ ] = second[ j++ ];606                }607            }608            first.length = i;609            return first;610        },611        grep: function( elems, callback, inv ) {612            var retval,613                ret = [],614                i = 0,615                length = elems.length;616            inv = !!inv;617            // go through the array, only saving the items618            // that pass the validator function619            for ( ; i < length; i++ ) {620                retval = !!callback( elems[ i ], i );621                if ( inv !== retval ) {622                    ret.push( elems[ i ] );623                }624            }625            return ret;626        },627        // arg is for internal usage only628        map: function( elems, callback, arg ) {629            var value,630                i = 0,631                length = elems.length,632                isarray = isarraylike( elems ),633                ret = [];634            // go through the array, translating each of the items to their635            if ( isarray ) {636                for ( ; i < length; i++ ) {637                    value = callback( elems[ i ], i, arg );638                    if ( value != null ) {639                        ret[ ret.length ] = value;640                    }641                }642                // go through every key on the object,643            } else {644                for ( i in elems ) {645                    value = callback( elems[ i ], i, arg );646                    if ( value != null ) {647                        ret[ ret.length ] = value;648                    }649                }650            }651            // flatten any nested arrays652            return core_concat.apply( [], ret );653        },654        // a global guid counter for objects655        guid: 1,656        // bind a function to a context, optionally partially applying any657        // arguments.658        proxy: function( fn, context ) {659            var args, proxy, tmp;660            if ( typeof context === "string" ) {661                tmp = fn[ context ];662                context = fn;663                fn = tmp;664            }665            // quick check to determine if target is callable, in the spec666            // this throws a typeerror, but we will just return undefined.667            if ( !jquery.isfunction( fn ) ) {668                return undefined;669            }670            // simulated bind671            args = core_slice.call( arguments, 2 );672            proxy = function() {673                return fn.apply( context || this, args.concat( core_slice.call( arguments ) ) );674            };675            // set the guid of unique handler to the same of original handler, so it can be removed676            proxy.guid = fn.guid = fn.guid || jquery.guid++;677            return proxy;678        },679        // multifunctional method to get and set values of a collection680        // the value/s can optionally be executed if it's a function681        access: function( elems, fn, key, value, chainable, emptyget, raw ) {682            var i = 0,683                length = elems.length,684                bulk = key == null;685            // sets many values686            if ( jquery.type( key ) === "object" ) {687                chainable = true;688                for ( i in key ) {689                    jquery.access( elems, fn, i, key[i], true, emptyget, raw );690                }691                // sets one value692            } else if ( value !== undefined ) {693                chainable = true;694                if ( !jquery.isfunction( value ) ) {695                    raw = true;696                }697                if ( bulk ) {698                    // bulk operations run against the entire set699                    if ( raw ) {700                        fn.call( elems, value );701                        fn = null;702                        // ...except when executing function values703                    } else {704                        bulk = fn;705                        fn = function( elem, key, value ) {706                            return bulk.call( jquery( elem ), value );707                        };708                    }709                }710                if ( fn ) {711                    for ( ; i < length; i++ ) {712                        fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );713                    }714                }715            }716            return chainable ?717                elems :718                // gets719                bulk ?720                    fn.call( elems ) :721                    length ? fn( elems[0], key ) : emptyget;722        },723        now: function() {724            return ( new date() ).gettime();725        },726        // a method for quickly swapping in/out css properties to get correct calculations.727        // note: this method belongs to the css module but it's needed here for the support module.728        // if support gets modularized, this method should be moved back to the css module.729        swap: function( elem, options, callback, args ) {730            var ret, name,731                old = {};732            // remember the old values, and insert the new ones733            for ( name in options ) {734                old[ name ] = elem.style[ name ];735                elem.style[ name ] = options[ name ];736            }737            ret = callback.apply( elem, args || [] );738            // revert the old values739            for ( name in options ) {740                elem.style[ name ] = old[ name ];741            }742            return ret;743        }744    });745    jquery.ready.promise = function( obj ) {746        if ( !readylist ) {747            readylist = jquery.deferred();748            // catch cases where $(document).ready() is called after the browser event has already occurred.749            // we once tried to use readystate "interactive" here, but it caused issues like the one750            // discovered by chriss here: http://bugs.jquery.com/ticket/12282#comment:15751            if ( document.readystate === "complete" ) {752                // handle it asynchronously to allow scripts the opportunity to delay ready753                settimeout( jquery.ready );754                // standards-based browsers support domcontentloaded755            } else if ( document.addeventlistener ) {756                // use the handy event callback757                document.addeventlistener( "domcontentloaded", completed, false );758                // a fallback to window.onload, that will always work759                window.addeventlistener( "load", completed, false );760                // if ie event model is used761            } else {762                // ensure firing before onload, maybe late but safe also for iframes763                document.attachevent( "onreadystatechange", completed );764                // a fallback to window.onload, that will always work765                window.attachevent( "onload", completed );766                // if ie and not a frame767                // continually check to see if the document is ready768                var top = false;769                try {770                    top = window.frameelement == null && document.documentelement;771                } catch(e) {}772                if ( top && top.doscroll ) {773                    (function doscrollcheck() {774                        if ( !jquery.isready ) {775                            try {776                                // use the trick by diego perini777                                // http://javascript.nwbox.com/iecontentloaded/778                                top.doscroll("left");779                            } catch(e) {780                                return settimeout( doscrollcheck, 50 );781                            }782                            // detach all dom ready events783                            detach();784                            // and execute any waiting functions785                            jquery.ready();786                        }787                    })();788                }789            }790        }791        return readylist.promise( obj );792    };793// populate the class2type map794    jquery.each("boolean number string function array date regexp object error".split(" "), function(i, name) {795        class2type[ "[object " + name + "]" ] = name.tolowercase();796    });797    function isarraylike( obj ) {798        var length = obj.length,799            type = jquery.type( obj );800        if ( jquery.iswindow( obj ) ) {801            return false;802        }803        if ( obj.nodetype === 1 && length ) {804            return true;805        }806        return type === "array" || type !== "function" &&807            ( length === 0 ||808                typeof length === "number" && length > 0 && ( length - 1 ) in obj );809    }810// all jquery objects should point back to these811    rootjquery = jquery(document);812    /*!813     * sizzle css selector engine v1.10.2814     * http://sizzlejs.com/815     *816     * copyright 2013 jquery foundation, inc. and other contributors817     * released under the mit license818     * http://jquery.org/license819     *820     * date: 2013-07-03821     */822    (function( window, undefined ) {823        var i,824            support,825            cachedruns,826            expr,827            gettext,828            isxml,829            compile,830            outermostcontext,831            sortinput,832        // local document vars833            setdocument,834            document,835            docelem,836            documentishtml,837            rbuggyqsa,838            rbuggymatches,839            matches,840            contains,841        // instance-specific data842            expando = "sizzle" + -(new date()),843            preferreddoc = window.document,844            dirruns = 0,845            done = 0,846            classcache = createcache(),847            tokencache = createcache(),848            compilercache = createcache(),849            hasduplicate = false,850            sortorder = function( a, b ) {851                if ( a === b ) {852                    hasduplicate = true;853                    return 0;854                }855                return 0;856            },857        // general-purpose constants858            strundefined = typeof undefined,859            max_negative = 1 << 31,860        // instance methods861            hasown = ({}).hasownproperty,862            arr = [],863            pop = arr.pop,864            push_native = arr.push,865            push = arr.push,866            slice = arr.slice,867        // use a stripped-down indexof if we can't use a native one868            indexof = arr.indexof || function( elem ) {869                var i = 0,870                    len = this.length;871                for ( ; i < len; i++ ) {872                    if ( this[i] === elem ) {873                        return i;874                    }875                }876                return -1;877            },878            booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",879        // regular expressions880        // whitespace characters http://www.w3.org/tr/css3-selectors/#whitespace881            whitespace = "[\\x20\\t\\r\\n\\f]",882        // http://www.w3.org/tr/css3-syntax/#characters883            characterencoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",884        // loosely modeled on css identifier characters885        // an unquoted value should be a css identifier http://www.w3.org/tr/css3-selectors/#attribute-selectors886        // proper syntax: http://www.w3.org/tr/css21/syndata.html#value-def-identifier887            identifier = characterencoding.replace( "w", "w#" ),888        // acceptable operators http://www.w3.org/tr/selectors/#attribute-selectors889            attributes = "\\[" + whitespace + "*(" + characterencoding + ")" + whitespace +890                "*(?:([*^$|!~]?=)" + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]",891        // prefer arguments quoted,892        //   then not containing pseudos/brackets,893        //   then attribute selectors/non-parenthetical expressions,894        //   then anything else895        // these preferences are here to reduce the number of selectors896        //   needing tokenize in the pseudo prefilter897            pseudos = ":(" + characterencoding + ")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" + attributes.replace( 3, 8 ) + ")*)|.*)\\)|)",898        // leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter899            rtrim = new regexp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),900            rcomma = new regexp( "^" + whitespace + "*," + whitespace + "*" ),901            rcombinators = new regexp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),902            rsibling = new regexp( whitespace + "*[+~]" ),903            rattributequotes = new regexp( "=" + whitespace + "*([^\\]'\"]*)" + whitespace + "*\\]", "g" ),904            rpseudo = new regexp( pseudos ),905            ridentifier = new regexp( "^" + identifier + "$" ),906            matchexpr = {907                "id": new regexp( "^#(" + characterencoding + ")" ),908                "class": new regexp( "^\\.(" + characterencoding + ")" ),909                "tag": new regexp( "^(" + characterencoding.replace( "w", "w*" ) + ")" ),910                "attr": new regexp( "^" + attributes ),911                "pseudo": new regexp( "^" + pseudos ),912                "child": new regexp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +913                    "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +914                    "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),915                "bool": new regexp( "^(?:" + booleans + ")$", "i" ),916                // for use in libraries implementing .is()917                // we use this for pos matching in `select`918                "needscontext": new regexp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +919                    whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )920            },921            rnative = /^[^{]+\{\s*\[native \w/,922        // easily-parseable/retrievable id or tag or class selectors923            rquickexpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,924            rinputs = /^(?:input|select|textarea|button)$/i,925            rheader = /^h\d$/i,926            rescape = /'|\\/g,927        // css escapes http://www.w3.org/tr/css21/syndata.html#escaped-characters928            runescape = new regexp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),929            funescape = function( _, escaped, escapedwhitespace ) {930                var high = "0x" + escaped - 0x10000;931                // nan means non-codepoint932                // support: firefox933                // workaround erroneous numeric interpretation of +"0x"934                return high !== high || escapedwhitespace ?935                    escaped :936                    // bmp codepoint937                        high < 0 ?938                    string.fromcharcode( high + 0x10000 ) :939                    // supplemental plane codepoint (surrogate pair)940                    string.fromcharcode( high >> 10 | 0xd800, high & 0x3ff | 0xdc00 );941            };942// optimize for push.apply( _, nodelist )943        try {944            push.apply(945                (arr = slice.call( preferreddoc.childnodes )),946                preferreddoc.childnodes947            );948            // support: android<4.0949            // detect silently failing push.apply950            arr[ preferreddoc.childnodes.length ].nodetype;951        } catch ( e ) {952            push = { apply: arr.length ?953                // leverage slice if possible954                function( target, els ) {955                    push_native.apply( target, slice.call(els) );956                } :957                // support: ie<9958                // otherwise append directly959                function( target, els ) {960                    var j = target.length,961                        i = 0;962                    // can't trust nodelist.length963                    while ( (target[j++] = els[i++]) ) {}964                    target.length = j - 1;965                }966            };967        }968        function sizzle( selector, context, results, seed ) {969            var match, elem, m, nodetype,970            // qsa vars971                i, groups, old, nid, newcontext, newselector;972            if ( ( context ? context.ownerdocument || context : preferreddoc ) !== document ) {973                setdocument( context );974            }975            context = context || document;976            results = results || [];977            if ( !selector || typeof selector !== "string" ) {978                return results;979            }980            if ( (nodetype = context.nodetype) !== 1 && nodetype !== 9 ) {981                return [];982            }983            if ( documentishtml && !seed ) {984                // shortcuts985                if ( (match = rquickexpr.exec( selector )) ) {986                    // speed-up: sizzle("#id")987                    if ( (m = match[1]) ) {988                        if ( nodetype === 9 ) {989                            elem = context.getelementbyid( m );990                            // check parentnode to catch when blackberry 4.6 returns991                            // nodes that are no longer in the document #6963992                            if ( elem && elem.parentnode ) {993                                // handle the case where ie, opera, and webkit return items994                                // by name instead of id995                                if ( elem.id === m ) {996                                    results.push( elem );997                                    return results;998                                }999                            } else {1000                                return results;1001                            }1002                        } else {1003                            // context is not a document1004                            if ( context.ownerdocument && (elem = context.ownerdocument.getelementbyid( m )) &&1005                                contains( context, elem ) && elem.id === m ) {1006                                results.push( elem );1007                                return results;1008                            }1009                        }1010                        // speed-up: sizzle("tag")1011                    } else if ( match[2] ) {1012                        push.apply( results, context.getelementsbytagname( selector ) );1013                        return results;1014                        // speed-up: sizzle(".class")1015                    } else if ( (m = match[3]) && support.getelementsbyclassname && context.getelementsbyclassname ) {1016                        push.apply( results, context.getelementsbyclassname( m ) );1017                        return results;1018                    }1019                }1020                // qsa path1021                if ( support.qsa && (!rbuggyqsa || !rbuggyqsa.test( selector )) ) {1022                    nid = old = expando;1023                    newcontext = context;1024                    newselector = nodetype === 9 && selector;1025                    // qsa works strangely on element-rooted queries1026                    // we can work around this by specifying an extra id on the root1027                    // and working up from there (thanks to andrew dupont for the technique)1028                    // ie 8 doesn't work on object elements1029                    if ( nodetype === 1 && context.nodename.tolowercase() !== "object" ) {1030                        groups = tokenize( selector );1031                        if ( (old = context.getattribute("id")) ) {1032                            nid = old.replace( rescape, "\\$&" );1033                        } else {1034                            context.setattribute( "id", nid );1035                        }1036                        nid = "[id='" + nid + "'] ";1037                        i = groups.length;1038                        while ( i-- ) {1039                            groups[i] = nid + toselector( groups[i] );1040                        }1041                        newcontext = rsibling.test( selector ) && context.parentnode || context;1042                        newselector = groups.join(",");1043                    }1044                    if ( newselector ) {1045                        try {1046                            push.apply( results,1047                                newcontext.queryselectorall( newselector )1048                            );1049                            return results;1050                        } catch(qsaerror) {1051                        } finally {1052                            if ( !old ) {1053                                context.removeattribute("id");1054                            }1055                        }1056                    }1057                }1058            }1059            // all others1060            return select( selector.replace( rtrim, "$1" ), context, results, seed );1061        }1062        /**1063         * create key-value caches of limited size1064         * @returns {function(string, object)} returns the object data after storing it on itself with1065         *	property name the (space-suffixed) string and (if the cache is larger than expr.cachelength)1066         *	deleting the oldest entry1067         */1068        function createcache() {1069            var keys = [];1070            function cache( key, value ) {1071                // use (key + " ") to avoid collision with native prototype properties (see issue #157)1072                if ( keys.push( key += " " ) > expr.cachelength ) {1073                    // only keep the most recent entries1074                    delete cache[ keys.shift() ];1075                }1076                return (cache[ key ] = value);1077            }1078            return cache;1079        }1080        /**1081         * mark a function for special use by sizzle1082         * @param {function} fn the function to mark1083         */1084        function markfunction( fn ) {1085            fn[ expando ] = true;1086            return fn;1087        }1088        /**1089         * support testing using an element1090         * @param {function} fn passed the created div and expects a boolean result1091         */1092        function assert( fn ) {1093            var div = document.createelement("div");1094            try {1095                return !!fn( div );1096            } catch (e) {1097                return false;1098            } finally {1099                // remove from its parent by default1100                if ( div.parentnode ) {1101                    div.parentnode.removechild( div );1102                }1103                // release memory in ie1104                div = null;1105            }1106        }1107        /**1108         * adds the same handler for all of the specified attrs1109         * @param {string} attrs pipe-separated list of attributes1110         * @param {function} handler the method that will be applied1111         */1112        function addhandle( attrs, handler ) {1113            var arr = attrs.split("|"),1114                i = attrs.length;1115            while ( i-- ) {1116                expr.attrhandle[ arr[i] ] = handler;1117            }1118        }1119        /**1120         * checks document order of two siblings1121         * @param {element} a1122         * @param {element} b1123         * @returns {number} returns less than 0 if a precedes b, greater than 0 if a follows b1124         */1125        function siblingcheck( a, b ) {1126            var cur = b && a,1127                diff = cur && a.nodetype === 1 && b.nodetype === 1 &&1128                    ( ~b.sourceindex || max_negative ) -1129                    ( ~a.sourceindex || max_negative );1130            // use ie sourceindex if available on both nodes1131            if ( diff ) {1132                return diff;1133            }1134            // check if b follows a1135            if ( cur ) {1136                while ( (cur = cur.nextsibling) ) {1137                    if ( cur === b ) {1138                        return -1;1139                    }1140                }1141            }1142            return a ? 1 : -1;1143        }1144        /**1145         * returns a function to use in pseudos for input types1146         * @param {string} type1147         */1148        function createinputpseudo( type ) {1149            return function( elem ) {1150                var name = elem.nodename.tolowercase();1151                return name === "input" && elem.type === type;1152            };1153        }1154        /**1155         * returns a function to use in pseudos for buttons1156         * @param {string} type1157         */1158        function createbuttonpseudo( type ) {1159            return function( elem ) {1160                var name = elem.nodename.tolowercase();1161                return (name === "input" || name === "button") && elem.type === type;1162            };1163        }1164        /**1165         * returns a function to use in pseudos for positionals1166         * @param {function} fn1167         */1168        function createpositionalpseudo( fn ) {1169            return markfunction(function( argument ) {1170                argument = +argument;1171                return markfunction(function( seed, matches ) {1172                    var j,1173                        matchindexes = fn( [], seed.length, argument ),1174                        i = matchindexes.length;1175                    // match elements found at the specified indexes1176                    while ( i-- ) {1177                        if ( seed[ (j = matchindexes[i]) ] ) {1178                            seed[j] = !(matches[j] = seed[j]);1179                        }1180                    }1181                });1182            });1183        }1184        /**1185         * detect xml1186         * @param {element|object} elem an element or a document1187         */1188        isxml = sizzle.isxml = function( elem ) {1189            // documentelement is verified for cases where it doesn't yet exist1190            // (such as loading iframes in ie - #4833)1191            var documentelement = elem && (elem.ownerdocument || elem).documentelement;1192            return documentelement ? documentelement.nodename !== "html" : false;1193        };1194// expose support vars for convenience1195        support = sizzle.support = {};1196        /**1197         * sets document-related variables once based on the current document1198         * @param {element|object} [doc] an element or document object to use to set the document1199         * @returns {object} returns the current document1200         */1201        setdocument = sizzle.setdocument = function( node ) {1202            var doc = node ? node.ownerdocument || node : preferreddoc,1203                parent = doc.defaultview;1204            // if no document and documentelement is available, return1205            if ( doc === document || doc.nodetype !== 9 || !doc.documentelement ) {1206                return document;1207            }1208            // set our document1209            document = doc;1210            docelem = doc.documentelement;1211            // support tests1212            documentishtml = !isxml( doc );1213            // support: ie>81214            // if iframe document is assigned to "document" variable and if iframe has been reloaded,1215            // ie will throw "permission denied" error when accessing "document" variable, see jquery #139361216            // ie6-8 do not support the defaultview property so parent will be undefined1217            if ( parent && parent.attachevent && parent !== parent.top ) {1218                parent.attachevent( "onbeforeunload", function() {1219                    setdocument();1220                });1221            }1222            /* attributes1223             ---------------------------------------------------------------------- */1224            // support: ie<81225            // verify that getattribute really returns attributes and not properties (excepting ie8 booleans)1226            support.attributes = assert(function( div ) {1227                div.classname = "i";1228                return !div.getattribute("classname");1229            });1230            /* getelement(s)by*1231             ---------------------------------------------------------------------- */1232            // check if getelementsbytagname("*") returns only elements1233            support.getelementsbytagname = assert(function( div ) {1234                div.appendchild( doc.createcomment("") );1235                return !div.getelementsbytagname("*").length;1236            });1237            // check if getelementsbyclassname can be trusted1238            support.getelementsbyclassname = assert(function( div ) {1239                div.innerhtml = "<div class='a'></div><div class='a i'></div>";1240                // support: safari<41241                // catch class over-caching1242                div.firstchild.classname = "i";1243                // support: opera<101244                // catch gebcn failure to find non-leading classes1245                return div.getelementsbyclassname("i").length === 2;1246            });1247            // support: ie<101248            // check if getelementbyid returns elements by name1249            // the broken getelementbyid methods don't pick up programatically-set names,1250            // so use a roundabout getelementsbyname test1251            support.getbyid = assert(function( div ) {1252                docelem.appendchild( div ).id = expando;1253                return !doc.getelementsbyname || !doc.getelementsbyname( expando ).length;1254            });1255            // id find and filter1256            if ( support.getbyid ) {1257                expr.find["id"] = function( id, context ) {1258                    if ( typeof context.getelementbyid !== strundefined && documentishtml ) {1259                        var m = context.getelementbyid( id );1260                        // check parentnode to catch when blackberry 4.6 returns1261                        // nodes that are no longer in the document #69631262                        return m && m.parentnode ? [m] : [];1263                    }1264                };1265                expr.filter["id"] = function( id ) {1266                    var attrid = id.replace( runescape, funescape );1267                    return function( elem ) {1268                        return elem.getattribute("id") === attrid;1269                    };1270                };1271            } else {1272                // support: ie6/71273                // getelementbyid is not reliable as a find shortcut1274                delete expr.find["id"];1275                expr.filter["id"] =  function( id ) {1276                    var attrid = id.replace( runescape, funescape );1277                    return function( elem ) {1278                        var node = typeof elem.getattributenode !== strundefined && elem.getattributenode("id");1279                        return node && node.value === attrid;1280                    };1281                };1282            }1283            // tag1284            expr.find["tag"] = support.getelementsbytagname ?1285                function( tag, context ) {1286                    if ( typeof context.getelementsbytagname !== strundefined ) {1287                        return context.getelementsbytagname( tag );1288                    }1289                } :1290                function( tag, context ) {1291                    var elem,1292                        tmp = [],1293                        i = 0,1294                        results = context.getelementsbytagname( tag );1295                    // filter out possible comments1296                    if ( tag === "*" ) {1297                        while ( (elem = results[i++]) ) {1298                            if ( elem.nodetype === 1 ) {1299                                tmp.push( elem );1300                            }1301                        }1302                        return tmp;1303                    }1304                    return results;1305                };1306            // class1307            expr.find["class"] = support.getelementsbyclassname && function( classname, context ) {1308                if ( typeof context.getelementsbyclassname !== strundefined && documentishtml ) {1309                    return context.getelementsbyclassname( classname );1310                }1311            };1312            /* qsa/matchesselector1313             ---------------------------------------------------------------------- */1314            // qsa and matchesselector support1315            // matchesselector(:active) reports false when true (ie9/opera 11.5)1316            rbuggymatches = [];1317            // qsa(:focus) reports false when true (chrome 21)1318            // we allow this because of a bug in ie8/9 that throws an error1319            // whenever `document.activeelement` is accessed on an iframe1320            // so, we allow :focus to pass through qsa all the time to avoid the ie error1321            // see http://bugs.jquery.com/ticket/133781322            rbuggyqsa = [];1323            if ( (support.qsa = rnative.test( doc.queryselectorall )) ) {1324                // build qsa regex1325                // regex strategy adopted from diego perini1326                assert(function( div ) {1327                    // select is set to empty string on purpose1328                    // this is to test ie's treatment of not explicitly1329                    // setting a boolean content attribute,1330                    // since its presence should be enough1331                    // http://bugs.jquery.com/ticket/123591332                    div.innerhtml = "<select><option selected=''></option></select>";1333                    // support: ie81334                    // boolean attributes and "value" are not treated correctly1335                    if ( !div.queryselectorall("[selected]").length ) {1336                        rbuggyqsa.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );1337                    }1338                    // webkit/opera - :checked should return selected option elements1339                    // http://www.w3.org/tr/2011/rec-css3-selectors-20110929/#checked1340                    // ie8 throws error here and will not see later tests1341                    if ( !div.queryselectorall(":checked").length ) {1342                        rbuggyqsa.push(":checked");1343                    }1344                });1345                assert(function( div ) {1346                    // support: opera 10-12/ie81347                    // ^= $= *= and empty values1348                    // should not select anything1349                    // support: windows 8 native apps1350                    // the type attribute is restricted during .innerhtml assignment1351                    var input = doc.createelement("input");1352                    input.setattribute( "type", "hidden" );1353                    div.appendchild( input ).setattribute( "t", "" );1354                    if ( div.queryselectorall("[t^='']").length ) {1355                        rbuggyqsa.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );1356                    }1357                    // ff 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)1358                    // ie8 throws error here and will not see later tests1359                    if ( !div.queryselectorall(":enabled").length ) {1360                        rbuggyqsa.push( ":enabled", ":disabled" );1361                    }1362                    // opera 10-11 does not throw on post-comma invalid pseudos1363                    div.queryselectorall("*,:x");1364                    rbuggyqsa.push(",.*:");1365                });1366            }1367            if ( (support.matchesselector = rnative.test( (matches = docelem.webkitmatchesselector ||1368                docelem.mozmatchesselector ||1369                docelem.omatchesselector ||1370                docelem.msmatchesselector) )) ) {1371                assert(function( div ) {1372                    // check to see if it's possible to do matchesselector1373                    // on a disconnected node (ie 9)1374                    support.disconnectedmatch = matches.call( div, "div" );1375                    // this should fail with an exception1376                    // gecko does not error, returns false instead1377                    matches.call( div, "[s!='']:x" );1378                    rbuggymatches.push( "!=", pseudos );1379                });1380            }1381            rbuggyqsa = rbuggyqsa.length && new regexp( rbuggyqsa.join("|") );1382            rbuggymatches = rbuggymatches.length && new regexp( rbuggymatches.join("|") );1383            /* contains1384             ---------------------------------------------------------------------- */1385            // element contains another1386            // purposefully does not implement inclusive descendent1387            // as in, an element does not contain itself1388            contains = rnative.test( docelem.contains ) || docelem.comparedocumentposition ?1389                function( a, b ) {1390                    var adown = a.nodetype === 9 ? a.documentelement : a,1391                        bup = b && b.parentnode;1392                    return a === bup || !!( bup && bup.nodetype === 1 && (1393                        adown.contains ?1394                            adown.contains( bup ) :1395                            a.comparedocumentposition && a.comparedocumentposition( bup ) & 161396                        ));1397                } :1398                function( a, b ) {1399                    if ( b ) {1400                        while ( (b = b.parentnode) ) {1401                            if ( b === a ) {1402                                return true;1403                            }1404                        }1405                    }1406                    return false;1407                };1408            /* sorting1409             ---------------------------------------------------------------------- */1410            // document order sorting1411            sortorder = docelem.comparedocumentposition ?1412                function( a, b ) {1413                    // flag for duplicate removal1414                    if ( a === b ) {1415                        hasduplicate = true;1416                        return 0;1417                    }1418                    var compare = b.comparedocumentposition && a.comparedocumentposition && a.comparedocumentposition( b );1419                    if ( compare ) {1420                        // disconnected nodes1421                        if ( compare & 1 ||1422                            (!support.sortdetached && b.comparedocumentposition( a ) === compare) ) {1423                            // choose the first element that is related to our preferred document1424                            if ( a === doc || contains(preferreddoc, a) ) {1425                                return -1;1426                            }1427                            if ( b === doc || contains(preferreddoc, b) ) {1428                                return 1;1429                            }1430                            // maintain original order1431                            return sortinput ?1432                                ( indexof.call( sortinput, a ) - indexof.call( sortinput, b ) ) :1433                                0;1434                        }1435                        return compare & 4 ? -1 : 1;1436                    }1437                    // not directly comparable, sort on existence of method1438                    return a.comparedocumentposition ? -1 : 1;1439                } :1440                function( a, b ) {1441                    var cur,1442                        i = 0,1443                        aup = a.parentnode,1444                        bup = b.parentnode,1445                        ap = [ a ],1446                        bp = [ b ];1447                    // exit early if the nodes are identical1448                    if ( a === b ) {1449                        hasduplicate = true;1450                        return 0;1451                        // parentless nodes are either documents or disconnected1452                    } else if ( !aup || !bup ) {1453                        return a === doc ? -1 :1454                                b === doc ? 1 :1455                            aup ? -1 :1456                                bup ? 1 :1457                                    sortinput ?1458                                        ( indexof.call( sortinput, a ) - indexof.call( sortinput, b ) ) :1459                                        0;1460                        // if the nodes are siblings, we can do a quick check1461                    } else if ( aup === bup ) {1462                        return siblingcheck( a, b );1463                    }1464                    // otherwise we need full lists of their ancestors for comparison1465                    cur = a;1466                    while ( (cur = cur.parentnode) ) {1467                        ap.unshift( cur );1468                    }1469                    cur = b;1470                    while ( (cur = cur.parentnode) ) {1471                        bp.unshift( cur );1472                    }1473                    // walk down the tree looking for a discrepancy1474                    while ( ap[i] === bp[i] ) {1475                        i++;1476                    }1477                    return i ?1478                        // do a sibling check if the nodes have a common ancestor1479                        siblingcheck( ap[i], bp[i] ) :1480                        // otherwise nodes in our document sort first1481                            ap[i] === preferreddoc ? -1 :1482                            bp[i] === preferreddoc ? 1 :1483                        0;1484                };1485            return doc;1486        };1487        sizzle.matches = function( expr, elements ) {1488            return sizzle( expr, null, null, elements );1489        };1490        sizzle.matchesselector = function( elem, expr ) {1491            // set document vars if needed1492            if ( ( elem.ownerdocument || elem ) !== document ) {1493                setdocument( elem );1494            }1495            // make sure that attribute selectors are quoted1496            expr = expr.replace( rattributequotes, "='$1']" );1497            if ( support.matchesselector && documentishtml &&1498                ( !rbuggymatches || !rbuggymatches.test( expr ) ) &&1499                ( !rbuggyqsa     || !rbuggyqsa.test( expr ) ) ) {1500                try {1501                    var ret = matches.call( elem, expr );1502                    // ie 9's matchesselector returns false on disconnected nodes1503                    if ( ret || support.disconnectedmatch ||1504                        // as well, disconnected nodes are said to be in a document1505                        // fragment in ie 91506                        elem.document && elem.document.nodetype !== 11 ) {1507                        return ret;1508                    }1509                } catch(e) {}1510            }1511            return sizzle( expr, document, null, [elem] ).length > 0;1512        };1513        sizzle.contains = function( context, elem ) {1514            // set document vars if needed1515            if ( ( context.ownerdocument || context ) !== document ) {1516                setdocument( context );1517            }1518            return contains( context, elem );1519        };1520        sizzle.attr = function( elem, name ) {1521            // set document vars if needed1522            if ( ( elem.ownerdocument || elem ) !== document ) {1523                setdocument( elem );1524            }1525            var fn = expr.attrhandle[ name.tolowercase() ],1526            // don't get fooled by object.prototype properties (jquery #13807)1527                val = fn && hasown.call( expr.attrhandle, name.tolowercase() ) ?1528                    fn( elem, name, !documentishtml ) :1529                    undefined;1530            return val === undefined ?1531                    support.attributes || !documentishtml ?1532                elem.getattribute( name ) :1533                    (val = elem.getattributenode(name)) && val.specified ?1534                val.value :1535                null :1536                val;1537        };1538        sizzle.error = function( msg ) {1539            throw new error( "syntax error, unrecognized expression: " + msg );1540        };1541        /**1542         * document sorting and removing duplicates1543         * @param {arraylike} results1544         */1545        sizzle.uniquesort = function( results ) {1546            var elem,1547                duplicates = [],1548                j = 0,1549                i = 0;1550            // unless we *know* we can detect duplicates, assume their presence1551            hasduplicate = !support.detectduplicates;1552            sortinput = !support.sortstable && results.slice( 0 );1553            results.sort( sortorder );1554            if ( hasduplicate ) {1555                while ( (elem = results[i++]) ) {1556                    if ( elem === results[ i ] ) {1557                        j = duplicates.push( i );1558                    }1559                }1560                while ( j-- ) {1561                    results.splice( duplicates[ j ], 1 );1562                }1563            }1564            return results;1565        };1566        /**1567         * utility function for retrieving the text value of an array of dom nodes1568         * @param {array|element} elem1569         */1570        gettext = sizzle.gettext = function( elem ) {1571            var node,1572                ret = "",1573                i = 0,1574                nodetype = elem.nodetype;1575            if ( !nodetype ) {1576                // if no nodetype, this is expected to be an array1577                for ( ; (node = elem[i]); i++ ) {1578                    // do not traverse comment nodes1579                    ret += gettext( node );1580                }1581            } else if ( nodetype === 1 || nodetype === 9 || nodetype === 11 ) {1582                // use textcontent for elements1583                // innertext usage removed for consistency of new lines (see #11153)1584                if ( typeof elem.textcontent === "string" ) {1585                    return elem.textcontent;1586                } else {1587                    // traverse its children1588                    for ( elem = elem.firstchild; elem; elem = elem.nextsibling ) {1589                        ret += gettext( elem );1590                    }1591                }1592            } else if ( nodetype === 3 || nodetype === 4 ) {1593                return elem.nodevalue;1594            }1595            // do not include comment or processing instruction nodes1596            return ret;1597        };1598        expr = sizzle.selectors = {1599            // can be adjusted by the user1600            cachelength: 50,1601            createpseudo: markfunction,1602            match: matchexpr,1603            attrhandle: {},1604            find: {},1605            relative: {1606                ">": { dir: "parentnode", first: true },1607                " ": { dir: "parentnode" },1608                "+": { dir: "previoussibling", first: true },1609                "~": { dir: "previoussibling" }1610            },1611            prefilter: {1612                "attr": function( match ) {1613                    match[1] = match[1].replace( runescape, funescape );1614                    // move the given value to match[3] whether quoted or unquoted1615                    match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape );1616                    if ( match[2] === "~=" ) {1617                        match[3] = " " + match[3] + " ";1618                    }1619                    return match.slice( 0, 4 );1620                },1621                "child": function( match ) {1622                    /* matches from matchexpr["child"]1623                     1 type (only|nth|...)1624                     2 what (child|of-type)1625                     3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)1626                     4 xn-component of xn+y argument ([+-]?\d*n|)1627                     5 sign of xn-component1628                     6 x of xn-component1629                     7 sign of y-component1630                     8 y of y-component1631                     */1632                    match[1] = match[1].tolowercase();1633                    if ( match[1].slice( 0, 3 ) === "nth" ) {1634                        // nth-* requires argument1635                        if ( !match[3] ) {1636                            sizzle.error( match[0] );1637                        }1638                        // numeric x and y parameters for expr.filter.child1639                        // remember that false/true cast respectively to 0/11640                        match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );1641                        match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );1642                        // other types prohibit arguments1643                    } else if ( match[3] ) {1644                        sizzle.error( match[0] );1645                    }1646                    return match;1647                },1648                "pseudo": function( match ) {1649                    var excess,1650                        unquoted = !match[5] && match[2];1651                    if ( matchexpr["child"].test( match[0] ) ) {1652                        return null;1653                    }1654                    // accept quoted arguments as-is1655                    if ( match[3] && match[4] !== undefined ) {1656                        match[2] = match[4];1657                        // strip excess characters from unquoted arguments1658                    } else if ( unquoted && rpseudo.test( unquoted ) &&1659                        // get excess from tokenize (recursively)1660                        (excess = tokenize( unquoted, true )) &&1661                        // advance to the next closing parenthesis1662                        (excess = unquoted.indexof( ")", unquoted.length - excess ) - unquoted.length) ) {1663                        // excess is a negative index1664                        match[0] = match[0].slice( 0, excess );1665                        match[2] = unquoted.slice( 0, excess );1666                    }1667                    // return only captures needed by the pseudo filter method (type and argument)1668                    return match.slice( 0, 3 );1669                }1670            },1671            filter: {1672                "tag": function( nodenameselector ) {1673                    var nodename = nodenameselector.replace( runescape, funescape ).tolowercase();1674                    return nodenameselector === "*" ?1675                        function() { return true; } :1676                        function( elem ) {1677                            return elem.nodename && elem.nodename.tolowercase() === nodename;1678                        };1679                },1680                "class": function( classname ) {1681                    var pattern = classcache[ classname + " " ];1682                    return pattern ||1683                        (pattern = new regexp( "(^|" + whitespace + ")" + classname + "(" + whitespace + "|$)" )) &&1684                        classcache( classname, function( elem ) {1685                            return pattern.test( typeof elem.classname === "string" && elem.classname || typeof elem.getattribute !== strundefined && elem.getattribute("class") || "" );1686                        });1687                },1688                "attr": function( name, operator, check ) {1689                    return function( elem ) {1690                        var result = sizzle.attr( elem, name );1691                        if ( result == null ) {1692                            return operator === "!=";1693                        }1694                        if ( !operator ) {1695                            return true;1696                        }1697                        result += "";1698                        return operator === "=" ? result === check :1699                                operator === "!=" ? result !== check :1700                                operator === "^=" ? check && result.indexof( check ) === 0 :1701                                operator === "*=" ? check && result.indexof( check ) > -1 :1702                                operator === "$=" ? check && result.slice( -check.length ) === check :1703                                operator === "~=" ? ( " " + result + " " ).indexof( check ) > -1 :1704                                operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :1705                            false;1706                    };1707                },1708                "child": function( type, what, argument, first, last ) {1709                    var simple = type.slice( 0, 3 ) !== "nth",1710                        forward = type.slice( -4 ) !== "last",1711                        oftype = what === "of-type";1712                    return first === 1 && last === 0 ?1713                        // shortcut for :nth-*(n)1714                        function( elem ) {1715                            return !!elem.parentnode;1716                        } :1717                        function( elem, context, xml ) {1718                            var cache, outercache, node, diff, nodeindex, start,1719                                dir = simple !== forward ? "nextsibling" : "previoussibling",1720                                parent = elem.parentnode,1721                                name = oftype && elem.nodename.tolowercase(),1722                                usecache = !xml && !oftype;1723                            if ( parent ) {1724                                // :(first|last|only)-(child|of-type)1725                                if ( simple ) {1726                                    while ( dir ) {1727                                        node = elem;1728                                        while ( (node = node[ dir ]) ) {1729                                            if ( oftype ? node.nodename.tolowercase() === name : node.nodetype === 1 ) {1730                                                return false;1731                                            }1732                                        }1733                                        // reverse direction for :only-* (if we haven't yet done so)1734                                        start = dir = type === "only" && !start && "nextsibling";1735                                    }1736                                    return true;1737                                }1738                                start = [ forward ? parent.firstchild : parent.lastchild ];1739                                // non-xml :nth-child(...) stores cache data on `parent`1740                                if ( forward && usecache ) {1741                                    // seek `elem` from a previously-cached index1742                                    outercache = parent[ expando ] || (parent[ expando ] = {});1743                                    cache = outercache[ type ] || [];1744                                    nodeindex = cache[0] === dirruns && cache[1];1745                                    diff = cache[0] === dirruns && cache[2];1746                                    node = nodeindex && parent.childnodes[ nodeindex ];1747                                    while ( (node = ++nodeindex && node && node[ dir ] ||1748                                        // fallback to seeking `elem` from the start1749                                        (diff = nodeindex = 0) || start.pop()) ) {1750                                        // when found, cache indexes on `parent` and break1751                                        if ( node.nodetype === 1 && ++diff && node === elem ) {1752                                            outercache[ type ] = [ dirruns, nodeindex, diff ];1753                                            break;1754                                        }1755                                    }1756                                    // use previously-cached element index if available1757                                } else if ( usecache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {1758                                    diff = cache[1];1759                                    // xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)1760                                } else {1761                                    // use the same loop as above to seek `elem` from the start1762                                    while ( (node = ++nodeindex && node && node[ dir ] ||1763                                        (diff = nodeindex = 0) || start.pop()) ) {1764                                        if ( ( oftype ? node.nodename.tolowercase() === name : node.nodetype === 1 ) && ++diff ) {1765                                            // cache the index of each encountered element1766                                            if ( usecache ) {1767                                                (node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];1768                                            }1769                                            if ( node === elem ) {1770                                                break;1771                                            }1772                                        }1773                                    }1774                                }1775                                // incorporate the offset, then check against cycle size1776                                diff -= last;1777                                return diff === first || ( diff % first === 0 && diff / first >= 0 );1778                            }1779                        };1780                },1781                "pseudo": function( pseudo, argument ) {1782                    // pseudo-class names are case-insensitive1783                    // http://www.w3.org/tr/selectors/#pseudo-classes1784                    // prioritize by case sensitivity in case custom pseudos are added with uppercase letters1785                    // remember that setfilters inherits from pseudos1786                    var args,1787                        fn = expr.pseudos[ pseudo ] || expr.setfilters[ pseudo.tolowercase() ] ||1788                            sizzle.error( "unsupported pseudo: " + pseudo );1789                    // the user may use createpseudo to indicate that1790                    // arguments are needed to create the filter function1791                    // just as sizzle does1792                    if ( fn[ expando ] ) {1793                        return fn( argument );1794                    }1795                    // but maintain support for old signatures1796                    if ( fn.length > 1 ) {1797                        args = [ pseudo, pseudo, "", argument ];1798                        return expr.setfilters.hasownproperty( pseudo.tolowercase() ) ?1799                            markfunction(function( seed, matches ) {1800                                var idx,1801                                    matched = fn( seed, argument ),1802                                    i = matched.length;1803                                while ( i-- ) {1804                                    idx = indexof.call( seed, matched[i] );1805                                    seed[ idx ] = !( matches[ idx ] = matched[i] );1806                                }1807                            }) :1808                            function( elem ) {1809                                return fn( elem, 0, args );1810                            };1811                    }1812                    return fn;1813                }1814            },1815            pseudos: {1816                // potentially complex pseudos1817                "not": markfunction(function( selector ) {1818                    // trim the selector passed to compile1819                    // to avoid treating leading and trailing1820                    // spaces as combinators1821                    var input = [],1822                        results = [],1823                        matcher = compile( selector.replace( rtrim, "$1" ) );1824                    return matcher[ expando ] ?1825                        markfunction(function( seed, matches, context, xml ) {1826                            var elem,1827                                unmatched = matcher( seed, null, xml, [] ),1828                                i = seed.length;1829                            // match elements unmatched by `matcher`1830                            while ( i-- ) {1831                                if ( (elem = unmatched[i]) ) {1832                                    seed[i] = !(matches[i] = elem);1833                                }1834                            }1835                        }) :1836                        function( elem, context, xml ) {1837                            input[0] = elem;1838                            matcher( input, null, xml, results );1839                            return !results.pop();1840                        };1841                }),1842                "has": markfunction(function( selector ) {1843                    return function( elem ) {1844                        return sizzle( selector, elem ).length > 0;1845                    };1846                }),1847                "contains": markfunction(function( text ) {1848                    return function( elem ) {1849                        return ( elem.textcontent || elem.innertext || gettext( elem ) ).indexof( text ) > -1;1850                    };1851                }),1852                // "whether an element is represented by a :lang() selector1853                // is based solely on the element's language value1854                // being equal to the identifier c,1855                // or beginning with the identifier c immediately followed by "-".1856                // the matching of c against the element's language value is performed case-insensitively.1857                // the identifier c does not have to be a valid language name."1858                // http://www.w3.org/tr/selectors/#lang-pseudo1859                "lang": markfunction( function( lang ) {1860                    // lang value must be a valid identifier1861                    if ( !ridentifier.test(lang || "") ) {1862                        sizzle.error( "unsupported lang: " + lang );1863                    }1864                    lang = lang.replace( runescape, funescape ).tolowercase();1865                    return function( elem ) {1866                        var elemlang;1867                        do {1868                            if ( (elemlang = documentishtml ?1869                                elem.lang :1870                                elem.getattribute("xml:lang") || elem.getattribute("lang")) ) {1871                                elemlang = elemlang.tolowercase();1872                                return elemlang === lang || elemlang.indexof( lang + "-" ) === 0;1873                            }1874                        } while ( (elem = elem.parentnode) && elem.nodetype === 1 );1875                        return false;1876                    };1877                }),1878                // miscellaneous1879                "target": function( elem ) {1880                    var hash = window.location && window.location.hash;1881                    return hash && hash.slice( 1 ) === elem.id;1882                },1883                "root": function( elem ) {1884                    return elem === docelem;1885                },1886                "focus": function( elem ) {1887                    return elem === document.activeelement && (!document.hasfocus || document.hasfocus()) && !!(elem.type || elem.href || ~elem.tabindex);1888                },1889                // boolean properties1890                "enabled": function( elem ) {1891                    return elem.disabled === false;1892                },1893                "disabled": function( elem ) {1894                    return elem.disabled === true;1895                },1896                "checked": function( elem ) {1897                    // in css3, :checked should return both checked and selected elements1898                    // http://www.w3.org/tr/2011/rec-css3-selectors-20110929/#checked1899                    var nodename = elem.nodename.tolowercase();1900                    return (nodename === "input" && !!elem.checked) || (nodename === "option" && !!elem.selected);1901                },1902                "selected": function( elem ) {1903                    // accessing this property makes selected-by-default1904                    // options in safari work properly1905                    if ( elem.parentnode ) {1906                        elem.parentnode.selectedindex;1907                    }1908                    return elem.selected === true;1909                },1910                // contents1911                "empty": function( elem ) {1912                    // http://www.w3.org/tr/selectors/#empty-pseudo1913                    // :empty is only affected by element nodes and content nodes(including text(3), cdata(4)),1914                    //   not comment, processing instructions, or others1915                    // thanks to diego perini for the nodename shortcut1916                    //   greater than "@" means alpha characters (specifically not starting with "#" or "?")1917                    for ( elem = elem.firstchild; elem; elem = elem.nextsibling ) {1918                        if ( elem.nodename > "@" || elem.nodetype === 3 || elem.nodetype === 4 ) {1919                            return false;1920                        }1921                    }1922                    return true;1923                },1924                "parent": function( elem ) {1925                    return !expr.pseudos["empty"]( elem );1926                },1927                // element/input types1928                "header": function( elem ) {1929                    return rheader.test( elem.nodename );1930                },1931                "input": function( elem ) {1932                    return rinputs.test( elem.nodename );1933                },1934                "button": function( elem ) {1935                    var name = elem.nodename.tolowercase();1936                    return name === "input" && elem.type === "button" || name === "button";1937                },1938                "text": function( elem ) {1939                    var attr;1940                    // ie6 and 7 will map elem.type to 'text' for new html5 types (search, etc)1941                    // use getattribute instead to test this case1942                    return elem.nodename.tolowercase() === "input" &&1943                        elem.type === "text" &&1944                        ( (attr = elem.getattribute("type")) == null || attr.tolowercase() === elem.type );1945                },1946                // position-in-collection1947                "first": createpositionalpseudo(function() {1948                    return [ 0 ];1949                }),1950                "last": createpositionalpseudo(function( matchindexes, length ) {1951                    return [ length - 1 ];1952                }),1953                "eq": createpositionalpseudo(function( matchindexes, length, argument ) {1954                    return [ argument < 0 ? argument + length : argument ];1955                }),1956                "even": createpositionalpseudo(function( matchindexes, length ) {1957                    var i = 0;1958                    for ( ; i < length; i += 2 ) {1959                        matchindexes.push( i );1960                    }1961                    return matchindexes;1962                }),1963                "odd": createpositionalpseudo(function( matchindexes, length ) {1964                    var i = 1;1965                    for ( ; i < length; i += 2 ) {1966                        matchindexes.push( i );1967                    }1968                    return matchindexes;1969                }),1970                "lt": createpositionalpseudo(function( matchindexes, length, argument ) {1971                    var i = argument < 0 ? argument + length : argument;1972                    for ( ; --i >= 0; ) {1973                        matchindexes.push( i );1974                    }1975                    return matchindexes;1976                }),1977                "gt": createpositionalpseudo(function( matchindexes, length, argument ) {1978                    var i = argument < 0 ? argument + length : argument;1979                    for ( ; ++i < length; ) {1980                        matchindexes.push( i );1981                    }1982                    return matchindexes;1983                })1984            }1985        };1986        expr.pseudos["nth"] = expr.pseudos["eq"];1987// add button/input type pseudos1988        for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {1989            expr.pseudos[ i ] = createinputpseudo( i );1990        }1991        for ( i in { submit: true, reset: true } ) {1992            expr.pseudos[ i ] = createbuttonpseudo( i );1993        }1994// easy api for creating new setfilters1995        function setfilters() {}1996        setfilters.prototype = expr.filters = expr.pseudos;1997        expr.setfilters = new setfilters();1998        function tokenize( selector, parseonly ) {1999            var matched, match, tokens, type,2000                sofar, groups, prefilters,2001                cached = tokencache[ selector + " " ];2002            if ( cached ) {2003                return parseonly ? 0 : cached.slice( 0 );2004            }2005            sofar = selector;2006            groups = [];2007            prefilters = expr.prefilter;2008            while ( sofar ) {2009                // comma and first run2010                if ( !matched || (match = rcomma.exec( sofar )) ) {2011                    if ( match ) {2012                        // don't consume trailing commas as valid2013                        sofar = sofar.slice( match[0].length ) || sofar;2014                    }2015                    groups.push( tokens = [] );2016                }2017                matched = false;2018                // combinators2019                if ( (match = rcombinators.exec( sofar )) ) {2020                    matched = match.shift();2021                    tokens.push({2022                        value: matched,2023                        // cast descendant combinators to space2024                        type: match[0].replace( rtrim, " " )2025                    });2026                    sofar = sofar.slice( matched.length );2027                }2028                // filters2029                for ( type in expr.filter ) {2030                    if ( (match = matchexpr[ type ].exec( sofar )) && (!prefilters[ type ] ||2031                        (match = prefilters[ type ]( match ))) ) {2032                        matched = match.shift();2033                        tokens.push({2034                            value: matched,2035                            type: type,2036                            matches: match2037                        });2038                        sofar = sofar.slice( matched.length );2039                    }2040                }2041                if ( !matched ) {2042                    break;2043                }2044            }2045            // return the length of the invalid excess2046            // if we're just parsing2047            // otherwise, throw an error or return tokens2048            return parseonly ?2049                sofar.length :2050                sofar ?2051                    sizzle.error( selector ) :2052                    // cache the tokens2053                    tokencache( selector, groups ).slice( 0 );2054        }2055        function toselector( tokens ) {2056            var i = 0,2057                len = tokens.length,2058                selector = "";2059            for ( ; i < len; i++ ) {2060                selector += tokens[i].value;2061            }2062            return selector;2063        }2064        function addcombinator( matcher, combinator, base ) {2065            var dir = combinator.dir,2066                checknonelements = base && dir === "parentnode",2067                donename = done++;2068            return combinator.first ?2069                // check against closest ancestor/preceding element2070                function( elem, context, xml ) {2071                    while ( (elem = elem[ dir ]) ) {2072                        if ( elem.nodetype === 1 || checknonelements ) {2073                            return matcher( elem, context, xml );2074                        }2075                    }2076                } :2077                // check against all ancestor/preceding elements2078                function( elem, context, xml ) {2079                    var data, cache, outercache,2080                        dirkey = dirruns + " " + donename;2081                    // we can't set arbitrary data on xml nodes, so they don't benefit from dir caching2082                    if ( xml ) {2083                        while ( (elem = elem[ dir ]) ) {2084                            if ( elem.nodetype === 1 || checknonelements ) {2085                                if ( matcher( elem, context, xml ) ) {2086                                    return true;2087                                }2088                            }2089                        }2090                    } else {2091                        while ( (elem = elem[ dir ]) ) {2092                            if ( elem.nodetype === 1 || checknonelements ) {2093                                outercache = elem[ expando ] || (elem[ expando ] = {});2094                                if ( (cache = outercache[ dir ]) && cache[0] === dirkey ) {2095                                    if ( (data = cache[1]) === true || data === cachedruns ) {2096                                        return data === true;2097                                    }2098                                } else {2099                                    cache = outercache[ dir ] = [ dirkey ];2100                                    cache[1] = matcher( elem, context, xml ) || cachedruns;2101                                    if ( cache[1] === true ) {2102                                        return true;2103                                    }2104                                }2105                            }2106                        }2107                    }2108                };2109        }2110        function elementmatcher( matchers ) {2111            return matchers.length > 1 ?2112                function( elem, context, xml ) {2113                    var i = matchers.length;2114                    while ( i-- ) {2115                        if ( !matchers[i]( elem, context, xml ) ) {2116                            return false;2117                        }2118                    }2119                    return true;2120                } :2121                matchers[0];2122        }2123        function condense( unmatched, map, filter, context, xml ) {2124            var elem,2125                newunmatched = [],2126                i = 0,2127                len = unmatched.length,2128                mapped = map != null;2129            for ( ; i < len; i++ ) {2130                if ( (elem = unmatched[i]) ) {2131                    if ( !filter || filter( elem, context, xml ) ) {2132                        newunmatched.push( elem );2133                        if ( mapped ) {2134                            map.push( i );2135                        }2136                    }2137                }2138            }2139            return newunmatched;2140        }2141        function setmatcher( prefilter, selector, matcher, postfilter, postfinder, postselector ) {2142            if ( postfilter && !postfilter[ expando ] ) {2143                postfilter = setmatcher( postfilter );2144            }2145            if ( postfinder && !postfinder[ expando ] ) {2146                postfinder = setmatcher( postfinder, postselector );2147            }2148            return markfunction(function( seed, results, context, xml ) {2149                var temp, i, elem,2150                    premap = [],2151                    postmap = [],2152                    preexisting = results.length,2153                // get initial elements from seed or context2154                    elems = seed || multiplecontexts( selector || "*", context.nodetype ? [ context ] : context, [] ),2155                // prefilter to get matcher input, preserving a map for seed-results synchronization2156                    matcherin = prefilter && ( seed || !selector ) ?2157                        condense( elems, premap, prefilter, context, xml ) :2158                        elems,2159                    matcherout = matcher ?2160                        // if we have a postfinder, or filtered seed, or non-seed postfilter or preexisting results,2161                            postfinder || ( seed ? prefilter : preexisting || postfilter ) ?2162                        // ...intermediate processing is necessary2163                        [] :2164                        // ...otherwise use results directly2165                        results :2166                        matcherin;2167                // find primary matches2168                if ( matcher ) {2169                    matcher( matcherin, matcherout, context, xml );2170                }2171                // apply postfilter2172                if ( postfilter ) {2173                    temp = condense( matcherout, postmap );2174                    postfilter( temp, [], context, xml );2175                    // un-match failing elements by moving them back to matcherin2176                    i = temp.length;2177                    while ( i-- ) {2178                        if ( (elem = temp[i]) ) {2179                            matcherout[ postmap[i] ] = !(matcherin[ postmap[i] ] = elem);2180                        }2181                    }2182                }2183                if ( seed ) {2184                    if ( postfinder || prefilter ) {2185                        if ( postfinder ) {2186                            // get the final matcherout by condensing this intermediate into postfinder contexts2187                            temp = [];2188                            i = matcherout.length;2189                            while ( i-- ) {2190                                if ( (elem = matcherout[i]) ) {2191                                    // restore matcherin since elem is not yet a final match2192                                    temp.push( (matcherin[i] = elem) );2193                                }2194                            }2195                            postfinder( null, (matcherout = []), temp, xml );2196                        }2197                        // move matched elements from seed to results to keep them synchronized2198                        i = matcherout.length;2199                        while ( i-- ) {2200                            if ( (elem = matcherout[i]) &&2201                                (temp = postfinder ? indexof.call( seed, elem ) : premap[i]) > -1 ) {2202                                seed[temp] = !(results[temp] = elem);2203                            }2204                        }2205                    }2206                    // add elements to results, through postfinder if defined2207                } else {2208                    matcherout = condense(2209                            matcherout === results ?2210                            matcherout.splice( preexisting, matcherout.length ) :2211                            matcherout2212                    );2213                    if ( postfinder ) {2214                        postfinder( null, results, matcherout, xml );2215                    } else {2216                        push.apply( results, matcherout );2217                    }2218                }2219            });2220        }2221        function matcherfromtokens( tokens ) {2222            var checkcontext, matcher, j,2223                len = tokens.length,2224                leadingrelative = expr.relative[ tokens[0].type ],2225                implicitrelative = leadingrelative || expr.relative[" "],2226                i = leadingrelative ? 1 : 0,2227            // the foundational matcher ensures that elements are reachable from top-level context(s)2228                matchcontext = addcombinator( function( elem ) {2229                    return elem === checkcontext;2230                }, implicitrelative, true ),2231                matchanycontext = addcombinator( function( elem ) {2232                    return indexof.call( checkcontext, elem ) > -1;2233                }, implicitrelative, true ),2234                matchers = [ function( elem, context, xml ) {2235                    return ( !leadingrelative && ( xml || context !== outermostcontext ) ) || (2236                        (checkcontext = context).nodetype ?2237                            matchcontext( elem, context, xml ) :2238                            matchanycontext( elem, context, xml ) );2239                } ];2240            for ( ; i < len; i++ ) {2241                if ( (matcher = expr.relative[ tokens[i].type ]) ) {2242                    matchers = [ addcombinator(elementmatcher( matchers ), matcher) ];2243                } else {2244                    matcher = expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );2245                    // return special upon seeing a positional matcher2246                    if ( matcher[ expando ] ) {2247                        // find the next relative operator (if any) for proper handling2248                        j = ++i;2249                        for ( ; j < len; j++ ) {2250                            if ( expr.relative[ tokens[j].type ] ) {2251                                break;2252                            }2253                        }2254                        return setmatcher(2255                                i > 1 && elementmatcher( matchers ),2256                                i > 1 && toselector(2257                                // if the preceding token was a descendant combinator, insert an implicit any-element `*`2258                                tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })2259                            ).replace( rtrim, "$1" ),2260                            matcher,2261                                i < j && matcherfromtokens( tokens.slice( i, j ) ),2262                                j < len && matcherfromtokens( (tokens = tokens.slice( j )) ),2263                                j < len && toselector( tokens )2264                        );2265                    }2266                    matchers.push( matcher );2267                }2268            }2269            return elementmatcher( matchers );2270        }2271        function matcherfromgroupmatchers( elementmatchers, setmatchers ) {2272            // a counter to specify which element is currently being matched2273            var matchercachedruns = 0,2274                byset = setmatchers.length > 0,2275                byelement = elementmatchers.length > 0,2276                supermatcher = function( seed, context, xml, results, expandcontext ) {2277                    var elem, j, matcher,2278                        setmatched = [],2279                        matchedcount = 0,2280                        i = "0",2281                        unmatched = seed && [],2282                        outermost = expandcontext != null,2283                        contextbackup = outermostcontext,2284                    // we must always have either seed elements or context2285                        elems = seed || byelement && expr.find["tag"]( "*", expandcontext && context.parentnode || context ),2286                    // use integer dirruns iff this is the outermost matcher2287                        dirrunsunique = (dirruns += contextbackup == null ? 1 : math.random() || 0.1);2288                    if ( outermost ) {2289                        outermostcontext = context !== document && context;2290                        cachedruns = matchercachedruns;2291                    }2292                    // add elements passing elementmatchers directly to results2293                    // keep `i` a string if there are no elements so `matchedcount` will be "00" below2294                    for ( ; (elem = elems[i]) != null; i++ ) {2295                        if ( byelement && elem ) {2296                            j = 0;2297                            while ( (matcher = elementmatchers[j++]) ) {2298                                if ( matcher( elem, context, xml ) ) {2299                                    results.push( elem );2300                                    break;2301                                }2302                            }2303                            if ( outermost ) {2304                                dirruns = dirrunsunique;2305                                cachedruns = ++matchercachedruns;2306                            }2307                        }2308                        // track unmatched elements for set filters2309                        if ( byset ) {2310                            // they will have gone through all possible matchers2311                            if ( (elem = !matcher && elem) ) {2312                                matchedcount--;2313                            }2314                            // lengthen the array for every element, matched or not2315                            if ( seed ) {2316                                unmatched.push( elem );2317                            }2318                        }2319                    }2320                    // apply set filters to unmatched elements2321                    matchedcount += i;2322                    if ( byset && i !== matchedcount ) {2323                        j = 0;2324                        while ( (matcher = setmatchers[j++]) ) {2325                            matcher( unmatched, setmatched, context, xml );2326                        }2327                        if ( seed ) {2328                            // reintegrate element matches to eliminate the need for sorting2329                            if ( matchedcount > 0 ) {2330                                while ( i-- ) {2331                                    if ( !(unmatched[i] || setmatched[i]) ) {2332                                        setmatched[i] = pop.call( results );2333                                    }2334                                }2335                            }2336                            // discard index placeholder values to get only actual matches2337                            setmatched = condense( setmatched );2338                        }2339                        // add matches to results2340                        push.apply( results, setmatched );2341                        // seedless set matches succeeding multiple successful matchers stipulate sorting2342                        if ( outermost && !seed && setmatched.length > 0 &&2343                            ( matchedcount + setmatchers.length ) > 1 ) {2344                            sizzle.uniquesort( results );2345                        }2346                    }2347                    // override manipulation of globals by nested matchers2348                    if ( outermost ) {2349                        dirruns = dirrunsunique;2350                        outermostcontext = contextbackup;2351                    }2352                    return unmatched;2353                };2354            return byset ?2355                markfunction( supermatcher ) :2356                supermatcher;2357        }2358        compile = sizzle.compile = function( selector, group /* internal use only */ ) {2359            var i,2360                setmatchers = [],2361                elementmatchers = [],2362                cached = compilercache[ selector + " " ];2363            if ( !cached ) {2364                // generate a function of recursive functions that can be used to check each element2365                if ( !group ) {2366                    group = tokenize( selector );2367                }2368                i = group.length;2369                while ( i-- ) {2370                    cached = matcherfromtokens( group[i] );2371                    if ( cached[ expando ] ) {2372                        setmatchers.push( cached );2373                    } else {2374                        elementmatchers.push( cached );2375                    }2376                }2377                // cache the compiled function2378                cached = compilercache( selector, matcherfromgroupmatchers( elementmatchers, setmatchers ) );2379            }2380            return cached;2381        };2382        function multiplecontexts( selector, contexts, results ) {2383            var i = 0,2384                len = contexts.length;2385            for ( ; i < len; i++ ) {2386                sizzle( selector, contexts[i], results );2387            }2388            return results;2389        }2390        function select( selector, context, results, seed ) {2391            var i, tokens, token, type, find,2392                match = tokenize( selector );2393            if ( !seed ) {2394                // try to minimize operations if there is only one group2395                if ( match.length === 1 ) {2396                    // take a shortcut and set the context if the root selector is an id2397                    tokens = match[0] = match[0].slice( 0 );2398                    if ( tokens.length > 2 && (token = tokens[0]).type === "id" &&2399                        support.getbyid && context.nodetype === 9 && documentishtml &&2400                        expr.relative[ tokens[1].type ] ) {2401                        context = ( expr.find["id"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];2402                        if ( !context ) {2403                            return results;2404                        }2405                        selector = selector.slice( tokens.shift().value.length );2406                    }2407                    // fetch a seed set for right-to-left matching2408                    i = matchexpr["needscontext"].test( selector ) ? 0 : tokens.length;2409                    while ( i-- ) {2410                        token = tokens[i];2411                        // abort if we hit a combinator2412                        if ( expr.relative[ (type = token.type) ] ) {2413                            break;2414                        }2415                        if ( (find = expr.find[ type ]) ) {2416                            // search, expanding context for leading sibling combinators2417                            if ( (seed = find(2418                                token.matches[0].replace( runescape, funescape ),2419                                    rsibling.test( tokens[0].type ) && context.parentnode || context2420                            )) ) {2421                                // if seed is empty or no tokens remain, we can return early2422                                tokens.splice( i, 1 );2423                                selector = seed.length && toselector( tokens );2424                                if ( !selector ) {2425                                    push.apply( results, seed );2426                                    return results;2427                                }2428                                break;2429                            }2430                        }2431                    }2432                }2433            }2434            // compile and execute a filtering function2435            // provide `match` to avoid retokenization if we modified the selector above2436            compile( selector, match )(2437                seed,2438                context,2439                !documentishtml,2440                results,2441                rsibling.test( selector )2442            );2443            return results;2444        }2445// one-time assignments2446// sort stability2447        support.sortstable = expando.split("").sort( sortorder ).join("") === expando;2448// support: chrome<142449// always assume duplicates if they aren't passed to the comparison function2450        support.detectduplicates = hasduplicate;2451// initialize against the default document2452        setdocument();2453// support: webkit<537.32 - safari 6.0.3/chrome 25 (fixed in chrome 27)2454// detached nodes confoundingly follow *each other*2455        support.sortdetached = assert(function( div1 ) {2456            // should return 1, but returns 4 (following)2457            return div1.comparedocumentposition( document.createelement("div") ) & 1;2458        });2459// support: ie<82460// prevent attribute/property "interpolation"2461// http://msdn.microsoft.com/en-us/library/ms536429%28vs.85%29.aspx2462        if ( !assert(function( div ) {2463            div.innerhtml = "<a href='#'></a>";2464            return div.firstchild.getattribute("href") === "#" ;2465        }) ) {2466            addhandle( "type|href|height|width", function( elem, name, isxml ) {2467                if ( !isxml ) {2468                    return elem.getattribute( name, name.tolowercase() === "type" ? 1 : 2 );2469                }2470            });2471        }2472// support: ie<92473// use defaultvalue in place of getattribute("value")2474        if ( !support.attributes || !assert(function( div ) {2475            div.innerhtml = "<input/>";2476            div.firstchild.setattribute( "value", "" );2477            return div.firstchild.getattribute( "value" ) === "";2478        }) ) {2479            addhandle( "value", function( elem, name, isxml ) {2480                if ( !isxml && elem.nodename.tolowercase() === "input" ) {2481                    return elem.defaultvalue;2482                }2483            });2484        }2485// support: ie<92486// use getattributenode to fetch booleans when getattribute lies2487        if ( !assert(function( div ) {2488            return div.getattribute("disabled") == null;2489        }) ) {2490            addhandle( booleans, function( elem, name, isxml ) {2491                var val;2492                if ( !isxml ) {2493                    return (val = elem.getattributenode( name )) && val.specified ?2494                        val.value :2495                            elem[ name ] === true ? name.tolowercase() : null;2496                }2497            });2498        }2499        jquery.find = sizzle;2500        jquery.expr = sizzle.selectors;2501        jquery.expr[":"] = jquery.expr.pseudos;2502        jquery.unique = sizzle.uniquesort;2503        jquery.text = sizzle.gettext;2504        jquery.isxmldoc = sizzle.isxml;2505        jquery.contains = sizzle.contains;2506    })( window );2507// string to object options format cache2508    var optionscache = {};2509// convert string-formatted options into object-formatted ones and store in cache2510    function createoptions( options ) {2511        var object = optionscache[ options ] = {};2512        jquery.each( options.match( core_rnotwhite ) || [], function( _, flag ) {2513            object[ flag ] = true;2514        });2515        return object;2516    }2517    /*2518     * create a callback list using the following parameters:2519     *2520     *	options: an optional list of space-separated options that will change how2521     *			the callback list behaves or a more traditional option object2522     *2523     * by default a callback list will act like an event callback list and can be2524     * "fired" multiple times.2525     *2526     * possible options:2527     *2528     *	once:			will ensure the callback list can only be fired once (like a deferred)2529     *2530     *	memory:			will keep track of previous values and will call any callback added2531     *					after the list has been fired right away with the latest "memorized"2532     *					values (like a deferred)2533     *2534     *	unique:			will ensure a callback can only be added once (no duplicate in the list)2535     *2536     *	stoponfalse:	interrupt callings when a callback returns false2537     *2538     */2539    jquery.callbacks = function( options ) {2540        // convert options from string-formatted to object-formatted if needed2541        // (we check in cache first)2542        options = typeof options === "string" ?2543            ( optionscache[ options ] || createoptions( options ) ) :2544            jquery.extend( {}, options );2545        var // flag to know if list is currently firing2546            firing,2547        // last fire value (for non-forgettable lists)2548            memory,2549        // flag to know if list was already fired2550            fired,2551        // end of the loop when firing2552            firinglength,2553        // index of currently firing callback (modified by remove if needed)2554            firingindex,2555        // first callback to fire (used internally by add and firewith)2556            firingstart,2557        // actual callback list2558            list = [],2559        // stack of fire calls for repeatable lists2560            stack = !options.once && [],2561        // fire callbacks2562            fire = function( data ) {2563                memory = options.memory && data;2564                fired = true;2565                firingindex = firingstart || 0;2566                firingstart = 0;2567                firinglength = list.length;2568                firing = true;2569                for ( ; list && firingindex < firinglength; firingindex++ ) {2570                    if ( list[ firingindex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stoponfalse ) {2571                        memory = false; // to prevent further calls using add2572                        break;2573                    }2574                }2575                firing = false;2576                if ( list ) {2577                    if ( stack ) {2578                        if ( stack.length ) {2579                            fire( stack.shift() );2580                        }2581                    } else if ( memory ) {2582                        list = [];2583                    } else {2584                        self.disable();2585                    }2586                }2587            },2588        // actual callbacks object2589            self = {2590                // add a callback or a collection of callbacks to the list2591                add: function() {2592                    if ( list ) {2593                        // first, we save the current length2594                        var start = list.length;2595                        (function add( args ) {2596                            jquery.each( args, function( _, arg ) {2597                                var type = jquery.type( arg );2598                                if ( type === "function" ) {2599                                    if ( !options.unique || !self.has( arg ) ) {2600                                        list.push( arg );2601                                    }2602                                } else if ( arg && arg.length && type !== "string" ) {2603                                    // inspect recursively2604                                    add( arg );2605                                }2606                            });2607                        })( arguments );2608                        // do we need to add the callbacks to the2609                        // current firing batch?2610                        if ( firing ) {2611                            firinglength = list.length;2612                            // with memory, if we're not firing then2613                            // we should call right away2614                        } else if ( memory ) {2615                            firingstart = start;2616                            fire( memory );2617                        }2618                    }2619                    return this;2620                },2621                // remove a callback from the list2622                remove: function() {2623                    if ( list ) {2624                        jquery.each( arguments, function( _, arg ) {2625                            var index;2626                            while( ( index = jquery.inarray( arg, list, index ) ) > -1 ) {2627                                list.splice( index, 1 );2628                                // handle firing indexes2629                                if ( firing ) {2630                                    if ( index <= firinglength ) {2631                                        firinglength--;2632                                    }2633                                    if ( index <= firingindex ) {2634                                        firingindex--;2635                                    }2636                                }2637                            }2638                        });2639                    }2640                    return this;2641                },2642                // check if a given callback is in the list.2643                // if no argument is given, return whether or not list has callbacks attached.2644                has: function( fn ) {2645                    return fn ? jquery.inarray( fn, list ) > -1 : !!( list && list.length );2646                },2647                // remove all callbacks from the list2648                empty: function() {2649                    list = [];2650                    firinglength = 0;2651                    return this;2652                },2653                // have the list do nothing anymore2654                disable: function() {2655                    list = stack = memory = undefined;2656                    return this;2657                },2658                // is it disabled?2659                disabled: function() {2660                    return !list;2661                },2662                // lock the list in its current state2663                lock: function() {2664                    stack = undefined;2665                    if ( !memory ) {2666                        self.disable();2667                    }2668                    return this;2669                },2670                // is it locked?2671                locked: function() {2672                    return !stack;2673                },2674                // call all callbacks with the given context and arguments2675                firewith: function( context, args ) {2676                    if ( list && ( !fired || stack ) ) {2677                        args = args || [];2678                        args = [ context, args.slice ? args.slice() : args ];2679                        if ( firing ) {2680                            stack.push( args );2681                        } else {2682                            fire( args );2683                        }2684                    }2685                    return this;2686                },2687                // call all the callbacks with the given arguments2688                fire: function() {2689                    self.firewith( this, arguments );2690                    return this;2691                },2692                // to know if the callbacks have already been called at least once2693                fired: function() {2694                    return !!fired;2695                }2696            };2697        return self;2698    };2699    jquery.extend({2700        deferred: function( func ) {2701            var tuples = [2702                    // action, add listener, listener list, final state2703                    [ "resolve", "done", jquery.callbacks("once memory"), "resolved" ],2704                    [ "reject", "fail", jquery.callbacks("once memory"), "rejected" ],2705                    [ "notify", "progress", jquery.callbacks("memory") ]2706                ],2707                state = "pending",2708                promise = {2709                    state: function() {2710                        return state;2711                    },2712                    always: function() {2713                        deferred.done( arguments ).fail( arguments );2714                        return this;2715                    },2716                    then: function( /* fndone, fnfail, fnprogress */ ) {2717                        var fns = arguments;2718                        return jquery.deferred(function( newdefer ) {2719                            jquery.each( tuples, function( i, tuple ) {2720                                var action = tuple[ 0 ],2721                                    fn = jquery.isfunction( fns[ i ] ) && fns[ i ];2722                                // deferred[ done | fail | progress ] for forwarding actions to newdefer2723                                deferred[ tuple[1] ](function() {2724                                    var returned = fn && fn.apply( this, arguments );2725                                    if ( returned && jquery.isfunction( returned.promise ) ) {2726                                        returned.promise()2727                                            .done( newdefer.resolve )2728                                            .fail( newdefer.reject )2729                                            .progress( newdefer.notify );2730                                    } else {2731                                        newdefer[ action + "with" ]( this === promise ? newdefer.promise() : this, fn ? [ returned ] : arguments );2732                                    }2733                                });2734                            });2735                            fns = null;2736                        }).promise();2737                    },2738                    // get a promise for this deferred2739                    // if obj is provided, the promise aspect is added to the object2740                    promise: function( obj ) {2741                        return obj != null ? jquery.extend( obj, promise ) : promise;2742                    }2743                },2744                deferred = {};2745            // keep pipe for back-compat2746            promise.pipe = promise.then;2747            // add list-specific methods2748            jquery.each( tuples, function( i, tuple ) {2749                var list = tuple[ 2 ],2750                    statestring = tuple[ 3 ];2751                // promise[ done | fail | progress ] = list.add2752                promise[ tuple[1] ] = list.add;2753                // handle state2754                if ( statestring ) {2755                    list.add(function() {2756                        // state = [ resolved | rejected ]2757                        state = statestring;2758                        // [ reject_list | resolve_list ].disable; progress_list.lock2759                    }, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );2760                }2761                // deferred[ resolve | reject | notify ]2762                deferred[ tuple[0] ] = function() {2763                    deferred[ tuple[0] + "with" ]( this === deferred ? promise : this, arguments );2764                    return this;2765                };2766                deferred[ tuple[0] + "with" ] = list.firewith;2767            });2768            // make the deferred a promise2769            promise.promise( deferred );2770            // call given func if any2771            if ( func ) {2772                func.call( deferred, deferred );2773            }2774            // all done!2775            return deferred;2776        },2777        // deferred helper2778        when: function( subordinate /* , ..., subordinaten */ ) {2779            var i = 0,2780                resolvevalues = core_slice.call( arguments ),2781                length = resolvevalues.length,2782            // the count of uncompleted subordinates2783                remaining = length !== 1 || ( subordinate && jquery.isfunction( subordinate.promise ) ) ? length : 0,2784            // the master deferred. if resolvevalues consist of only a single deferred, just use that.2785                deferred = remaining === 1 ? subordinate : jquery.deferred(),2786            // update function for both resolve and progress values2787                updatefunc = function( i, contexts, values ) {2788                    return function( value ) {2789                        contexts[ i ] = this;2790                        values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;2791                        if( values === progressvalues ) {2792                            deferred.notifywith( contexts, values );2793                        } else if ( !( --remaining ) ) {2794                            deferred.resolvewith( contexts, values );2795                        }2796                    };2797                },2798                progressvalues, progresscontexts, resolvecontexts;2799            // add listeners to deferred subordinates; treat others as resolved2800            if ( length > 1 ) {2801                progressvalues = new array( length );2802                progresscontexts = new array( length );2803                resolvecontexts = new array( length );2804                for ( ; i < length; i++ ) {2805                    if ( resolvevalues[ i ] && jquery.isfunction( resolvevalues[ i ].promise ) ) {2806                        resolvevalues[ i ].promise()2807                            .done( updatefunc( i, resolvecontexts, resolvevalues ) )2808                            .fail( deferred.reject )2809                            .progress( updatefunc( i, progresscontexts, progressvalues ) );2810                    } else {2811                        --remaining;2812                    }2813                }2814            }2815            // if we're not waiting on anything, resolve the master2816            if ( !remaining ) {2817                deferred.resolvewith( resolvecontexts, resolvevalues );2818            }2819            return deferred.promise();2820        }2821    });2822    jquery.support = (function( support ) {2823        var all, a, input, select, fragment, opt, eventname, issupported, i,2824            div = document.createelement("div");2825        // setup2826        div.setattribute( "classname", "t" );2827        div.innerhtml = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";2828        // finish early in limited (non-browser) environments2829        all = div.getelementsbytagname("*") || [];2830        a = div.getelementsbytagname("a")[ 0 ];2831        if ( !a || !a.style || !all.length ) {2832            return support;2833        }2834        // first batch of tests2835        select = document.createelement("select");2836        opt = select.appendchild( document.createelement("option") );2837        input = div.getelementsbytagname("input")[ 0 ];2838        a.style.csstext = "top:1px;float:left;opacity:.5";2839        // test setattribute on camelcase class. if it works, we need attrfixes when doing get/setattribute (ie6/7)2840        support.getsetattribute = div.classname !== "t";2841        // ie strips leading whitespace when .innerhtml is used2842        support.leadingwhitespace = div.firstchild.nodetype === 3;2843        // make sure that tbody elements aren't automatically inserted2844        // ie will insert them into empty tables2845        support.tbody = !div.getelementsbytagname("tbody").length;2846        // make sure that link elements get serialized correctly by innerhtml2847        // this requires a wrapper element in ie2848        support.htmlserialize = !!div.getelementsbytagname("link").length;2849        // get the style information from getattribute2850        // (ie uses .csstext instead)2851        support.style = /top/.test( a.getattribute("style") );2852        // make sure that urls aren't manipulated2853        // (ie normalizes it by default)2854        support.hrefnormalized = a.getattribute("href") === "/a";2855        // make sure that element opacity exists2856        // (ie uses filter instead)2857        // use a regex to work around a webkit issue. see #51452858        support.opacity = /^0.5/.test( a.style.opacity );2859        // verify style float existence2860        // (ie uses stylefloat instead of cssfloat)2861        support.cssfloat = !!a.style.cssfloat;2862        // check the default checkbox/radio value ("" on webkit; "on" elsewhere)2863        support.checkon = !!input.value;2864        // make sure that a selected-by-default option has a working selected property.2865        // (webkit defaults to false instead of true, ie too, if it's in an optgroup)2866        support.optselected = opt.selected;2867        // tests for enctype support on a form (#6743)2868        support.enctype = !!document.createelement("form").enctype;2869        // makes sure cloning an html5 element does not cause problems2870        // where outerhtml is undefined, this still works2871        support.html5clone = document.createelement("nav").clonenode( true ).outerhtml !== "<:nav></:nav>";2872        // will be defined later2873        support.inlineblockneedslayout = false;2874        support.shrinkwrapblocks = false;2875        support.pixelposition = false;2876        support.deleteexpando = true;2877        support.nocloneevent = true;2878        support.reliablemarginright = true;2879        support.boxsizingreliable = true;2880        // make sure checked status is properly cloned2881        input.checked = true;2882        support.noclonechecked = input.clonenode( true ).checked;2883        // make sure that the options inside disabled selects aren't marked as disabled2884        // (webkit marks them as disabled)2885        select.disabled = true;2886        support.optdisabled = !opt.disabled;2887        // support: ie<92888        try {2889            delete div.test;2890        } catch( e ) {2891            support.deleteexpando = false;2892        }2893        // check if we can trust getattribute("value")2894        input = document.createelement("input");2895        input.setattribute( "value", "" );2896        support.input = input.getattribute( "value" ) === "";2897        // check if an input maintains its value after becoming a radio2898        input.value = "t";2899        input.setattribute( "type", "radio" );2900        support.radiovalue = input.value === "t";2901        // #11217 - webkit loses check when the name is after the checked attribute2902        input.setattribute( "checked", "t" );2903        input.setattribute( "name", "t" );2904        fragment = document.createdocumentfragment();2905        fragment.appendchild( input );2906        // check if a disconnected checkbox will retain its checked2907        // value of true after appended to the dom (ie6/7)2908        support.appendchecked = input.checked;2909        // webkit doesn't clone checked state correctly in fragments2910        support.checkclone = fragment.clonenode( true ).clonenode( true ).lastchild.checked;2911        // support: ie<92912        // opera does not clone events (and typeof div.attachevent === undefined).2913        // ie9-10 clones events bound via attachevent, but they don't trigger with .click()2914        if ( div.attachevent ) {2915            div.attachevent( "onclick", function() {2916                support.nocloneevent = false;2917            });2918            div.clonenode( true ).click();2919        }2920        // support: ie<9 (lack submit/change bubble), firefox 17+ (lack focusin event)2921        // beware of csp restrictions (https://developer.mozilla.org/en/security/csp)2922        for ( i in { submit: true, change: true, focusin: true }) {2923            div.setattribute( eventname = "on" + i, "t" );2924            support[ i + "bubbles" ] = eventname in window || div.attributes[ eventname ].expando === false;2925        }2926        div.style.backgroundclip = "content-box";2927        div.clonenode( true ).style.backgroundclip = "";2928        support.clearclonestyle = div.style.backgroundclip === "content-box";2929        // support: ie<92930        // iteration over object's inherited properties before its own.2931        for ( i in jquery( support ) ) {2932            break;2933        }2934        support.ownlast = i !== "0";2935        // run tests that need a body at doc ready2936        jquery(function() {2937            var container, margindiv, tds,2938                divreset = "padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;",2939                body = document.getelementsbytagname("body")[0];2940            if ( !body ) {2941                // return for frameset docs that don't have a body2942                return;2943            }2944            container = document.createelement("div");2945            container.style.csstext = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px";2946            body.appendchild( container ).appendchild( div );2947            // support: ie82948            // check if table cells still have offsetwidth/height when they are set2949            // to display:none and there are still other visible table cells in a2950            // table row; if so, offsetwidth/height are not reliable for use when2951            // determining if an element has been hidden directly using2952            // display:none (it is still safe to use offsets if a parent element is2953            // hidden; don safety goggles and see bug #4512 for more information).2954            div.innerhtml = "<table><tr><td></td><td>t</td></tr></table>";2955            tds = div.getelementsbytagname("td");2956            tds[ 0 ].style.csstext = "padding:0;margin:0;border:0;display:none";2957            issupported = ( tds[ 0 ].offsetheight === 0 );2958            tds[ 0 ].style.display = "";2959            tds[ 1 ].style.display = "none";2960            // support: ie82961            // check if empty table cells still have offsetwidth/height2962            support.reliablehiddenoffsets = issupported && ( tds[ 0 ].offsetheight === 0 );2963            // check box-sizing and margin behavior.2964            div.innerhtml = "";2965            div.style.csstext = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";2966            // workaround failing boxsizing test due to offsetwidth returning wrong value2967            // with some non-1 values of body zoom, ticket #135432968            jquery.swap( body, body.style.zoom != null ? { zoom: 1 } : {}, function() {2969                support.boxsizing = div.offsetwidth === 4;2970            });2971            // use window.getcomputedstyle because jsdom on node.js will break without it.2972            if ( window.getcomputedstyle ) {2973                support.pixelposition = ( window.getcomputedstyle( div, null ) || {} ).top !== "1%";2974                support.boxsizingreliable = ( window.getcomputedstyle( div, null ) || { width: "4px" } ).width === "4px";2975                // check if div with explicit width and no margin-right incorrectly2976                // gets computed margin-right based on width of container. (#3333)2977                // fails in webkit before feb 2011 nightlies2978                // webkit bug 13343 - getcomputedstyle returns wrong value for margin-right2979                margindiv = div.appendchild( document.createelement("div") );2980                margindiv.style.csstext = div.style.csstext = divreset;2981                margindiv.style.marginright = margindiv.style.width = "0";2982                div.style.width = "1px";2983                support.reliablemarginright =2984                    !parsefloat( ( window.getcomputedstyle( margindiv, null ) || {} ).marginright );2985            }2986            if ( typeof div.style.zoom !== core_strundefined ) {2987                // support: ie<82988                // check if natively block-level elements act like inline-block2989                // elements when setting their display to 'inline' and giving2990                // them layout2991                div.innerhtml = "";2992                div.style.csstext = divreset + "width:1px;padding:1px;display:inline;zoom:1";2993                support.inlineblockneedslayout = ( div.offsetwidth === 3 );2994                // support: ie62995                // check if elements with layout shrink-wrap their children2996                div.style.display = "block";2997                div.innerhtml = "<div></div>";2998                div.firstchild.style.width = "5px";2999                support.shrinkwrapblocks = ( div.offsetwidth !== 3 );3000                if ( support.inlineblockneedslayout ) {3001                    // prevent ie 6 from affecting layout for positioned elements #110483002                    // prevent ie from shrinking the body in ie 7 mode #128693003                    // support: ie<83004                    body.style.zoom = 1;3005                }3006            }3007            body.removechild( container );3008            // null elements to avoid leaks in ie3009            container = div = tds = margindiv = null;3010        });3011        // null elements to avoid leaks in ie3012        all = select = fragment = opt = a = input = null;3013        return support;3014    })({});3015    var rbrace = /(?:\{[\s\s]*\}|\[[\s\s]*\])$/,3016        rmultidash = /([a-z])/g;3017    function internaldata( elem, name, data, pvt /* internal use only */ ){3018        if ( !jquery.acceptdata( elem ) ) {3019            return;3020        }3021        var ret, thiscache,3022            internalkey = jquery.expando,3023        // we have to handle dom nodes and js objects differently because ie6-73024        // can't gc object references properly across the dom-js boundary3025            isnode = elem.nodetype,3026        // only dom nodes need the global jquery cache; js object data is3027        // attached directly to the object so gc can occur automatically3028            cache = isnode ? jquery.cache : elem,3029        // only defining an id for js objects if its cache already exists allows3030        // the code to shortcut on the same path as a dom node with no cache3031            id = isnode ? elem[ internalkey ] : elem[ internalkey ] && internalkey;3032        // avoid doing any more work than we need to when trying to get data on an3033        // object that has no data at all3034        if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && data === undefined && typeof name === "string" ) {3035            return;3036        }3037        if ( !id ) {3038            // only dom nodes need a new unique id for each element since their data3039            // ends up in the global cache3040            if ( isnode ) {3041                id = elem[ internalkey ] = core_deletedids.pop() || jquery.guid++;3042            } else {3043                id = internalkey;3044            }3045        }3046        if ( !cache[ id ] ) {3047            // avoid exposing jquery metadata on plain js objects when the object3048            // is serialized using json.stringify3049            cache[ id ] = isnode ? {} : { tojson: jquery.noop };3050        }3051        // an object can be passed to jquery.data instead of a key/value pair; this gets3052        // shallow copied over onto the existing cache3053        if ( typeof name === "object" || typeof name === "function" ) {3054            if ( pvt ) {3055                cache[ id ] = jquery.extend( cache[ id ], name );3056            } else {3057                cache[ id ].data = jquery.extend( cache[ id ].data, name );3058            }3059        }3060        thiscache = cache[ id ];3061        // jquery data() is stored in a separate object inside the object's internal data3062        // cache in order to avoid key collisions between internal data and user-defined3063        // data.3064        if ( !pvt ) {3065            if ( !thiscache.data ) {3066                thiscache.data = {};3067            }3068            thiscache = thiscache.data;3069        }3070        if ( data !== undefined ) {3071            thiscache[ jquery.camelcase( name ) ] = data;3072        }3073        // check for both converted-to-camel and non-converted data property names3074        // if a data property was specified3075        if ( typeof name === "string" ) {3076            // first try to find as-is property data3077            ret = thiscache[ name ];3078            // test for null|undefined property data3079            if ( ret == null ) {3080                // try to find the camelcased property3081                ret = thiscache[ jquery.camelcase( name ) ];3082            }3083        } else {3084            ret = thiscache;3085        }3086        return ret;3087    }3088    function internalremovedata( elem, name, pvt ) {3089        if ( !jquery.acceptdata( elem ) ) {3090            return;3091        }3092        var thiscache, i,3093            isnode = elem.nodetype,3094        // see jquery.data for more information3095            cache = isnode ? jquery.cache : elem,3096            id = isnode ? elem[ jquery.expando ] : jquery.expando;3097        // if there is already no cache entry for this object, there is no3098        // purpose in continuing3099        if ( !cache[ id ] ) {3100            return;3101        }3102        if ( name ) {3103            thiscache = pvt ? cache[ id ] : cache[ id ].data;3104            if ( thiscache ) {3105                // support array or space separated string names for data keys3106                if ( !jquery.isarray( name ) ) {3107                    // try the string as a key before any manipulation3108                    if ( name in thiscache ) {3109                        name = [ name ];3110                    } else {3111                        // split the camel cased version by spaces unless a key with the spaces exists3112                        name = jquery.camelcase( name );3113                        if ( name in thiscache ) {3114                            name = [ name ];3115                        } else {3116                            name = name.split(" ");3117                        }3118                    }3119                } else {3120                    // if "name" is an array of keys...3121                    // when data is initially created, via ("key", "val") signature,3122                    // keys will be converted to camelcase.3123                    // since there is no way to tell _how_ a key was added, remove3124                    // both plain key and camelcase key. #127863125                    // this will only penalize the array argument path.3126                    name = name.concat( jquery.map( name, jquery.camelcase ) );3127                }3128                i = name.length;3129                while ( i-- ) {3130                    delete thiscache[ name[i] ];3131                }3132                // if there is no data left in the cache, we want to continue3133                // and let the cache object itself get destroyed3134                if ( pvt ? !isemptydataobject(thiscache) : !jquery.isemptyobject(thiscache) ) {3135                    return;3136                }3137            }3138        }3139        // see jquery.data for more information3140        if ( !pvt ) {3141            delete cache[ id ].data;3142            // don't destroy the parent cache unless the internal data object3143            // had been the only thing left in it3144            if ( !isemptydataobject( cache[ id ] ) ) {3145                return;3146            }3147        }3148        // destroy the cache3149        if ( isnode ) {3150            jquery.cleandata( [ elem ], true );3151            // use delete when supported for expandos or `cache` is not a window per iswindow (#10080)3152            /* jshint eqeqeq: false */3153        } else if ( jquery.support.deleteexpando || cache != cache.window ) {3154            /* jshint eqeqeq: true */3155            delete cache[ id ];3156            // when all else fails, null3157        } else {3158            cache[ id ] = null;3159        }3160    }3161    jquery.extend({3162        cache: {},3163        // the following elements throw uncatchable exceptions if you3164        // attempt to add expando properties to them.3165        nodata: {3166            "applet": true,3167            "embed": true,3168            // ban all objects except for flash (which handle expandos)3169            "object": "clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"3170        },3171        hasdata: function( elem ) {3172            elem = elem.nodetype ? jquery.cache[ elem[jquery.expando] ] : elem[ jquery.expando ];3173            return !!elem && !isemptydataobject( elem );3174        },3175        data: function( elem, name, data ) {3176            return internaldata( elem, name, data );3177        },3178        removedata: function( elem, name ) {3179            return internalremovedata( elem, name );3180        },3181        // for internal use only.3182        _data: function( elem, name, data ) {3183            return internaldata( elem, name, data, true );3184        },3185        _removedata: function( elem, name ) {3186            return internalremovedata( elem, name, true );3187        },3188        // a method for determining if a dom node can handle the data expando3189        acceptdata: function( elem ) {3190            // do not set data on non-element because it will not be cleared (#8335).3191            if ( elem.nodetype && elem.nodetype !== 1 && elem.nodetype !== 9 ) {3192                return false;3193            }3194            var nodata = elem.nodename && jquery.nodata[ elem.nodename.tolowercase() ];3195            // nodes accept data unless otherwise specified; rejection can be conditional3196            return !nodata || nodata !== true && elem.getattribute("classid") === nodata;3197        }3198    });3199    jquery.fn.extend({3200        data: function( key, value ) {3201            var attrs, name,3202                data = null,3203                i = 0,3204                elem = this[0];3205            // special expections of .data basically thwart jquery.access,3206            // so implement the relevant behavior ourselves3207            // gets all values3208            if ( key === undefined ) {3209                if ( this.length ) {3210                    data = jquery.data( elem );3211                    if ( elem.nodetype === 1 && !jquery._data( elem, "parsedattrs" ) ) {3212                        attrs = elem.attributes;3213                        for ( ; i < attrs.length; i++ ) {3214                            name = attrs[i].name;3215                            if ( name.indexof("data-") === 0 ) {3216                                name = jquery.camelcase( name.slice(5) );3217                                dataattr( elem, name, data[ name ] );3218                            }3219                        }3220                        jquery._data( elem, "parsedattrs", true );3221                    }3222                }3223                return data;3224            }3225            // sets multiple values3226            if ( typeof key === "object" ) {3227                return this.each(function() {3228                    jquery.data( this, key );3229                });3230            }3231            return arguments.length > 1 ?3232                // sets one value3233                this.each(function() {3234                    jquery.data( this, key, value );3235                }) :3236                // gets one value3237                // try to fetch any internally stored data first3238                elem ? dataattr( elem, key, jquery.data( elem, key ) ) : null;3239        },3240        removedata: function( key ) {3241            return this.each(function() {3242                jquery.removedata( this, key );3243            });3244        }3245    });3246    function dataattr( elem, key, data ) {3247        // if nothing was found internally, try to fetch any3248        // data from the html5 data-* attribute3249        if ( data === undefined && elem.nodetype === 1 ) {3250            var name = "data-" + key.replace( rmultidash, "-$1" ).tolowercase();3251            data = elem.getattribute( name );3252            if ( typeof data === "string" ) {3253                try {3254                    data = data === "true" ? true :3255                            data === "false" ? false :3256                            data === "null" ? null :3257                        // only convert to a number if it doesn't change the string3258                            +data + "" === data ? +data :3259                        rbrace.test( data ) ? jquery.parsejson( data ) :3260                            data;3261                } catch( e ) {}3262                // make sure we set the data so it isn't changed later3263                jquery.data( elem, key, data );3264            } else {3265                data = undefined;3266            }3267        }3268        return data;3269    }3270// checks a cache object for emptiness3271    function isemptydataobject( obj ) {3272        var name;3273        for ( name in obj ) {3274            // if the public data object is empty, the private is still empty3275            if ( name === "data" && jquery.isemptyobject( obj[name] ) ) {3276                continue;3277            }3278            if ( name !== "tojson" ) {3279                return false;3280            }3281        }3282        return true;3283    }3284    jquery.extend({3285        queue: function( elem, type, data ) {3286            var queue;3287            if ( elem ) {3288                type = ( type || "fx" ) + "queue";3289                queue = jquery._data( elem, type );3290                // speed up dequeue by getting out quickly if this is just a lookup3291                if ( data ) {3292                    if ( !queue || jquery.isarray(data) ) {3293                        queue = jquery._data( elem, type, jquery.makearray(data) );3294                    } else {3295                        queue.push( data );3296                    }3297                }3298                return queue || [];3299            }3300        },3301        dequeue: function( elem, type ) {3302            type = type || "fx";3303            var queue = jquery.queue( elem, type ),3304                startlength = queue.length,3305                fn = queue.shift(),3306                hooks = jquery._queuehooks( elem, type ),3307                next = function() {3308                    jquery.dequeue( elem, type );3309                };3310            // if the fx queue is dequeued, always remove the progress sentinel3311            if ( fn === "inprogress" ) {3312                fn = queue.shift();3313                startlength--;3314            }3315            if ( fn ) {3316                // add a progress sentinel to prevent the fx queue from being3317                // automatically dequeued3318                if ( type === "fx" ) {3319                    queue.unshift( "inprogress" );3320                }3321                // clear up the last queue stop function3322                delete hooks.stop;3323                fn.call( elem, next, hooks );3324            }3325            if ( !startlength && hooks ) {3326                hooks.empty.fire();3327            }3328        },3329        // not intended for public consumption - generates a queuehooks object, or returns the current one3330        _queuehooks: function( elem, type ) {3331            var key = type + "queuehooks";3332            return jquery._data( elem, key ) || jquery._data( elem, key, {3333                empty: jquery.callbacks("once memory").add(function() {3334                    jquery._removedata( elem, type + "queue" );3335                    jquery._removedata( elem, key );3336                })3337            });3338        }3339    });3340    jquery.fn.extend({3341        queue: function( type, data ) {3342            var setter = 2;3343            if ( typeof type !== "string" ) {3344                data = type;3345                type = "fx";3346                setter--;3347            }3348            if ( arguments.length < setter ) {3349                return jquery.queue( this[0], type );3350            }3351            return data === undefined ?3352                this :3353                this.each(function() {3354                    var queue = jquery.queue( this, type, data );3355                    // ensure a hooks for this queue3356                    jquery._queuehooks( this, type );3357                    if ( type === "fx" && queue[0] !== "inprogress" ) {3358                        jquery.dequeue( this, type );3359                    }3360                });3361        },3362        dequeue: function( type ) {3363            return this.each(function() {3364                jquery.dequeue( this, type );3365            });3366        },3367        // based off of the plugin by clint helfers, with permission.3368        // http://blindsignals.com/index.php/2009/07/jquery-delay/3369        delay: function( time, type ) {3370            time = jquery.fx ? jquery.fx.speeds[ time ] || time : time;3371            type = type || "fx";3372            return this.queue( type, function( next, hooks ) {3373                var timeout = settimeout( next, time );3374                hooks.stop = function() {3375                    cleartimeout( timeout );3376                };3377            });3378        },3379        clearqueue: function( type ) {3380            return this.queue( type || "fx", [] );3381        },3382        // get a promise resolved when queues of a certain type3383        // are emptied (fx is the type by default)3384        promise: function( type, obj ) {3385            var tmp,3386                count = 1,3387                defer = jquery.deferred(),3388                elements = this,3389                i = this.length,3390                resolve = function() {3391                    if ( !( --count ) ) {3392                        defer.resolvewith( elements, [ elements ] );3393                    }3394                };3395            if ( typeof type !== "string" ) {3396                obj = type;3397                type = undefined;3398            }3399            type = type || "fx";3400            while( i-- ) {3401                tmp = jquery._data( elements[ i ], type + "queuehooks" );3402                if ( tmp && tmp.empty ) {3403                    count++;3404                    tmp.empty.add( resolve );3405                }3406            }3407            resolve();3408            return defer.promise( obj );3409        }3410    });3411    var nodehook, boolhook,3412        rclass = /[\t\r\n\f]/g,3413        rreturn = /\r/g,3414        rfocusable = /^(?:input|select|textarea|button|object)$/i,3415        rclickable = /^(?:a|area)$/i,3416        rusedefault = /^(?:checked|selected)$/i,3417        getsetattribute = jquery.support.getsetattribute,3418        getsetinput = jquery.support.input;3419    jquery.fn.extend({3420        attr: function( name, value ) {3421            return jquery.access( this, jquery.attr, name, value, arguments.length > 1 );3422        },3423        removeattr: function( name ) {3424            return this.each(function() {3425                jquery.removeattr( this, name );3426            });3427        },3428        prop: function( name, value ) {3429            return jquery.access( this, jquery.prop, name, value, arguments.length > 1 );3430        },3431        removeprop: function( name ) {3432            name = jquery.propfix[ name ] || name;3433            return this.each(function() {3434                // try/catch handles cases where ie balks (such as removing a property on window)3435                try {3436                    this[ name ] = undefined;3437                    delete this[ name ];3438                } catch( e ) {}3439            });3440        },3441        addclass: function( value ) {3442            var classes, elem, cur, clazz, j,3443                i = 0,3444                len = this.length,3445                proceed = typeof value === "string" && value;3446            if ( jquery.isfunction( value ) ) {3447                return this.each(function( j ) {3448                    jquery( this ).addclass( value.call( this, j, this.classname ) );3449                });3450            }3451            if ( proceed ) {3452                // the disjunction here is for better compressibility (see removeclass)3453                classes = ( value || "" ).match( core_rnotwhite ) || [];3454                for ( ; i < len; i++ ) {3455                    elem = this[ i ];3456                    cur = elem.nodetype === 1 && ( elem.classname ?3457                        ( " " + elem.classname + " " ).replace( rclass, " " ) :3458                        " "3459                        );3460                    if ( cur ) {3461                        j = 0;3462                        while ( (clazz = classes[j++]) ) {3463                            if ( cur.indexof( " " + clazz + " " ) < 0 ) {3464                                cur += clazz + " ";3465                            }3466                        }3467                        elem.classname = jquery.trim( cur );3468                    }3469                }3470            }3471            return this;3472        },3473        removeclass: function( value ) {3474            var classes, elem, cur, clazz, j,3475                i = 0,3476                len = this.length,3477                proceed = arguments.length === 0 || typeof value === "string" && value;3478            if ( jquery.isfunction( value ) ) {3479                return this.each(function( j ) {3480                    jquery( this ).removeclass( value.call( this, j, this.classname ) );3481                });3482            }3483            if ( proceed ) {3484                classes = ( value || "" ).match( core_rnotwhite ) || [];3485                for ( ; i < len; i++ ) {3486                    elem = this[ i ];3487                    // this expression is here for better compressibility (see addclass)3488                    cur = elem.nodetype === 1 && ( elem.classname ?3489                        ( " " + elem.classname + " " ).replace( rclass, " " ) :3490                        ""3491                        );3492                    if ( cur ) {3493                        j = 0;3494                        while ( (clazz = classes[j++]) ) {3495                            // remove *all* instances3496                            while ( cur.indexof( " " + clazz + " " ) >= 0 ) {3497                                cur = cur.replace( " " + clazz + " ", " " );3498                            }3499                        }3500                        elem.classname = value ? jquery.trim( cur ) : "";3501                    }3502                }3503            }3504            return this;3505        },3506        toggleclass: function( value, stateval ) {3507            var type = typeof value;3508            if ( typeof stateval === "boolean" && type === "string" ) {3509                return stateval ? this.addclass( value ) : this.removeclass( value );3510            }3511            if ( jquery.isfunction( value ) ) {3512                return this.each(function( i ) {3513                    jquery( this ).toggleclass( value.call(this, i, this.classname, stateval), stateval );3514                });3515            }3516            return this.each(function() {3517                if ( type === "string" ) {3518                    // toggle individual class names3519                    var classname,3520                        i = 0,3521                        self = jquery( this ),3522                        classnames = value.match( core_rnotwhite ) || [];3523                    while ( (classname = classnames[ i++ ]) ) {3524                        // check each classname given, space separated list3525                        if ( self.hasclass( classname ) ) {3526                            self.removeclass( classname );3527                        } else {3528                            self.addclass( classname );3529                        }3530                    }3531                    // toggle whole class name3532                } else if ( type === core_strundefined || type === "boolean" ) {3533                    if ( this.classname ) {3534                        // store classname if set3535                        jquery._data( this, "__classname__", this.classname );3536                    }3537                    // if the element has a class name or if we're passed "false",3538                    // then remove the whole classname (if there was one, the above saved it).3539                    // otherwise bring back whatever was previously saved (if anything),3540                    // falling back to the empty string if nothing was stored.3541                    this.classname = this.classname || value === false ? "" : jquery._data( this, "__classname__" ) || "";3542                }3543            });3544        },3545        hasclass: function( selector ) {3546            var classname = " " + selector + " ",3547                i = 0,3548                l = this.length;3549            for ( ; i < l; i++ ) {3550                if ( this[i].nodetype === 1 && (" " + this[i].classname + " ").replace(rclass, " ").indexof( classname ) >= 0 ) {3551                    return true;3552                }3553            }3554            return false;3555        },3556        val: function( value ) {3557            var ret, hooks, isfunction,3558                elem = this[0];3559            if ( !arguments.length ) {3560                if ( elem ) {3561                    hooks = jquery.valhooks[ elem.type ] || jquery.valhooks[ elem.nodename.tolowercase() ];3562                    if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {3563                        return ret;3564                    }3565                    ret = elem.value;3566                    return typeof ret === "string" ?3567                        // handle most common string cases3568                        ret.replace(rreturn, "") :3569                        // handle cases where value is null/undef or number3570                            ret == null ? "" : ret;3571                }3572                return;3573            }3574            isfunction = jquery.isfunction( value );3575            return this.each(function( i ) {3576                var val;3577                if ( this.nodetype !== 1 ) {3578                    return;3579                }3580                if ( isfunction ) {3581                    val = value.call( this, i, jquery( this ).val() );3582                } else {3583                    val = value;3584                }3585                // treat null/undefined as ""; convert numbers to string3586                if ( val == null ) {3587                    val = "";3588                } else if ( typeof val === "number" ) {3589                    val += "";3590                } else if ( jquery.isarray( val ) ) {3591                    val = jquery.map(val, function ( value ) {3592                        return value == null ? "" : value + "";3593                    });3594                }3595                hooks = jquery.valhooks[ this.type ] || jquery.valhooks[ this.nodename.tolowercase() ];3596                // if set returns undefined, fall back to normal setting3597                if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {3598                    this.value = val;3599                }3600            });3601        }3602    });3603    jquery.extend({3604        valhooks: {3605            option: {3606                get: function( elem ) {3607                    // use proper attribute retrieval(#6932, #12072)3608                    var val = jquery.find.attr( elem, "value" );3609                    return val != null ?3610                        val :3611                        elem.text;3612                }3613            },3614            select: {3615                get: function( elem ) {3616                    var value, option,3617                        options = elem.options,3618                        index = elem.selectedindex,3619                        one = elem.type === "select-one" || index < 0,3620                        values = one ? null : [],3621                        max = one ? index + 1 : options.length,3622                        i = index < 0 ?3623                            max :3624                            one ? index : 0;3625                    // loop through all the selected options3626                    for ( ; i < max; i++ ) {3627                        option = options[ i ];3628                        // oldie doesn't update selected after form reset (#2551)3629                        if ( ( option.selected || i === index ) &&3630                            // don't return options that are disabled or in a disabled optgroup3631                            ( jquery.support.optdisabled ? !option.disabled : option.getattribute("disabled") === null ) &&3632                            ( !option.parentnode.disabled || !jquery.nodename( option.parentnode, "optgroup" ) ) ) {3633                            // get the specific value for the option3634                            value = jquery( option ).val();3635                            // we don't need an array for one selects3636                            if ( one ) {3637                                return value;3638                            }3639                            // multi-selects return an array3640                            values.push( value );3641                        }3642                    }3643                    return values;3644                },3645                set: function( elem, value ) {3646                    var optionset, option,3647                        options = elem.options,3648                        values = jquery.makearray( value ),3649                        i = options.length;3650                    while ( i-- ) {3651                        option = options[ i ];3652                        if ( (option.selected = jquery.inarray( jquery(option).val(), values ) >= 0) ) {3653                            optionset = true;3654                        }3655                    }3656                    // force browsers to behave consistently when non-matching value is set3657                    if ( !optionset ) {3658                        elem.selectedindex = -1;3659                    }3660                    return values;3661                }3662            }3663        },3664        attr: function( elem, name, value ) {3665            var hooks, ret,3666                ntype = elem.nodetype;3667            // don't get/set attributes on text, comment and attribute nodes3668            if ( !elem || ntype === 3 || ntype === 8 || ntype === 2 ) {3669                return;3670            }3671            // fallback to prop when attributes are not supported3672            if ( typeof elem.getattribute === core_strundefined ) {3673                return jquery.prop( elem, name, value );3674            }3675            // all attributes are lowercase3676            // grab necessary hook if one is defined3677            if ( ntype !== 1 || !jquery.isxmldoc( elem ) ) {3678                name = name.tolowercase();3679                hooks = jquery.attrhooks[ name ] ||3680                    ( jquery.expr.match.bool.test( name ) ? boolhook : nodehook );3681            }3682            if ( value !== undefined ) {3683                if ( value === null ) {3684                    jquery.removeattr( elem, name );3685                } else if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {3686                    return ret;3687                } else {3688                    elem.setattribute( name, value + "" );3689                    return value;3690                }3691            } else if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {3692                return ret;3693            } else {3694                ret = jquery.find.attr( elem, name );3695                // non-existent attributes return null, we normalize to undefined3696                return ret == null ?3697                    undefined :3698                    ret;3699            }3700        },3701        removeattr: function( elem, value ) {3702            var name, propname,3703                i = 0,3704                attrnames = value && value.match( core_rnotwhite );3705            if ( attrnames && elem.nodetype === 1 ) {3706                while ( (name = attrnames[i++]) ) {3707                    propname = jquery.propfix[ name ] || name;3708                    // boolean attributes get special treatment (#10870)3709                    if ( jquery.expr.match.bool.test( name ) ) {3710                        // set corresponding property to false3711                        if ( getsetinput && getsetattribute || !rusedefault.test( name ) ) {3712                            elem[ propname ] = false;3713                            // support: ie<93714                            // also clear defaultchecked/defaultselected (if appropriate)3715                        } else {3716                            elem[ jquery.camelcase( "default-" + name ) ] =3717                                elem[ propname ] = false;3718                        }3719                        // see #9699 for explanation of this approach (setting first, then removal)3720                    } else {3721                        jquery.attr( elem, name, "" );3722                    }3723                    elem.removeattribute( getsetattribute ? name : propname );3724                }3725            }3726        },3727        attrhooks: {3728            type: {3729                set: function( elem, value ) {3730                    if ( !jquery.support.radiovalue && value === "radio" && jquery.nodename(elem, "input") ) {3731                        // setting the type on a radio button after the value resets the value in ie6-93732                        // reset value to default in case type is set after value during creation3733                        var val = elem.value;3734                        elem.setattribute( "type", value );3735                        if ( val ) {3736                            elem.value = val;3737                        }3738                        return value;3739                    }3740                }3741            }3742        },3743        propfix: {3744            "for": "htmlfor",3745            "class": "classname"3746        },3747        prop: function( elem, name, value ) {3748            var ret, hooks, notxml,3749                ntype = elem.nodetype;3750            // don't get/set properties on text, comment and attribute nodes3751            if ( !elem || ntype === 3 || ntype === 8 || ntype === 2 ) {3752                return;3753            }3754            notxml = ntype !== 1 || !jquery.isxmldoc( elem );3755            if ( notxml ) {3756                // fix name and attach hooks3757                name = jquery.propfix[ name ] || name;3758                hooks = jquery.prophooks[ name ];3759            }3760            if ( value !== undefined ) {3761                return hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ?3762                    ret :3763                    ( elem[ name ] = value );3764            } else {3765                return hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ?3766                    ret :3767                    elem[ name ];3768            }3769        },3770        prophooks: {3771            tabindex: {3772                get: function( elem ) {3773                    // elem.tabindex doesn't always return the correct value when it hasn't been explicitly set3774                    // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/3775                    // use proper attribute retrieval(#12072)3776                    var tabindex = jquery.find.attr( elem, "tabindex" );3777                    return tabindex ?3778                        parseint( tabindex, 10 ) :3779                            rfocusable.test( elem.nodename ) || rclickable.test( elem.nodename ) && elem.href ?3780                        0 :3781                        -1;3782                }3783            }3784        }3785    });3786// hooks for boolean attributes3787    boolhook = {3788        set: function( elem, value, name ) {3789            if ( value === false ) {3790                // remove boolean attributes when set to false3791                jquery.removeattr( elem, name );3792            } else if ( getsetinput && getsetattribute || !rusedefault.test( name ) ) {3793                // ie<8 needs the *property* name3794                elem.setattribute( !getsetattribute && jquery.propfix[ name ] || name, name );3795                // use defaultchecked and defaultselected for oldie3796            } else {3797                elem[ jquery.camelcase( "default-" + name ) ] = elem[ name ] = true;3798            }3799            return name;3800        }3801    };3802    jquery.each( jquery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {3803        var getter = jquery.expr.attrhandle[ name ] || jquery.find.attr;3804        jquery.expr.attrhandle[ name ] = getsetinput && getsetattribute || !rusedefault.test( name ) ?3805            function( elem, name, isxml ) {3806                var fn = jquery.expr.attrhandle[ name ],3807                    ret = isxml ?3808                        undefined :3809                        /* jshint eqeqeq: false */3810                            (jquery.expr.attrhandle[ name ] = undefined) !=3811                        getter( elem, name, isxml ) ?3812                        name.tolowercase() :3813                        null;3814                jquery.expr.attrhandle[ name ] = fn;3815                return ret;3816            } :3817            function( elem, name, isxml ) {3818                return isxml ?3819                    undefined :3820                    elem[ jquery.camelcase( "default-" + name ) ] ?3821                        name.tolowercase() :3822                        null;3823            };3824    });3825// fix oldie attroperties3826    if ( !getsetinput || !getsetattribute ) {3827        jquery.attrhooks.value = {3828            set: function( elem, value, name ) {3829                if ( jquery.nodename( elem, "input" ) ) {3830                    // does not return so that setattribute is also used3831                    elem.defaultvalue = value;3832                } else {3833                    // use nodehook if defined (#1954); otherwise setattribute is fine3834                    return nodehook && nodehook.set( elem, value, name );3835                }3836            }3837        };3838    }3839// ie6/7 do not support getting/setting some attributes with get/setattribute3840    if ( !getsetattribute ) {3841        // use this for any attribute in ie6/73842        // this fixes almost every ie6/7 issue3843        nodehook = {3844            set: function( elem, value, name ) {3845                // set the existing or create a new attribute node3846                var ret = elem.getattributenode( name );3847                if ( !ret ) {3848                    elem.setattributenode(3849                        (ret = elem.ownerdocument.createattribute( name ))3850                    );3851                }3852                ret.value = value += "";3853                // break association with cloned elements by also using setattribute (#9646)3854                return name === "value" || value === elem.getattribute( name ) ?3855                    value :3856                    undefined;3857            }3858        };3859        jquery.expr.attrhandle.id = jquery.expr.attrhandle.name = jquery.expr.attrhandle.coords =3860            // some attributes are constructed with empty-string values when not defined3861            function( elem, name, isxml ) {3862                var ret;3863                return isxml ?3864                    undefined :3865                        (ret = elem.getattributenode( name )) && ret.value !== "" ?3866                    ret.value :3867                    null;3868            };3869        jquery.valhooks.button = {3870            get: function( elem, name ) {3871                var ret = elem.getattributenode( name );3872                return ret && ret.specified ?3873                    ret.value :3874                    undefined;3875            },3876            set: nodehook.set3877        };3878        // set contenteditable to false on removals(#10429)3879        // setting to empty string throws an error as an invalid value3880        jquery.attrhooks.contenteditable = {3881            set: function( elem, value, name ) {3882                nodehook.set( elem, value === "" ? false : value, name );3883            }3884        };3885        // set width and height to auto instead of 0 on empty string( bug #8150 )3886        // this is for removals3887        jquery.each([ "width", "height" ], function( i, name ) {3888            jquery.attrhooks[ name ] = {3889                set: function( elem, value ) {3890                    if ( value === "" ) {3891                        elem.setattribute( name, "auto" );3892                        return value;3893                    }3894                }3895            };3896        });3897    }3898// some attributes require a special call on ie3899// http://msdn.microsoft.com/en-us/library/ms536429%28vs.85%29.aspx3900    if ( !jquery.support.hrefnormalized ) {3901        // href/src property should get the full normalized url (#10299/#12915)3902        jquery.each([ "href", "src" ], function( i, name ) {3903            jquery.prophooks[ name ] = {3904                get: function( elem ) {3905                    return elem.getattribute( name, 4 );3906                }3907            };3908        });3909    }3910    if ( !jquery.support.style ) {3911        jquery.attrhooks.style = {3912            get: function( elem ) {3913                // return undefined in the case of empty string3914                // note: ie uppercases css property names, but if we were to .tolowercase()3915                // .csstext, that would destroy case senstitivity in url's, like in "background"3916                return elem.style.csstext || undefined;3917            },3918            set: function( elem, value ) {3919                return ( elem.style.csstext = value + "" );3920            }3921        };3922    }3923// safari mis-reports the default selected property of an option3924// accessing the parent's selectedindex property fixes it3925    if ( !jquery.support.optselected ) {3926        jquery.prophooks.selected = {3927            get: function( elem ) {3928                var parent = elem.parentnode;3929                if ( parent ) {3930                    parent.selectedindex;3931                    // make sure that it also works with optgroups, see #57013932                    if ( parent.parentnode ) {3933                        parent.parentnode.selectedindex;3934                    }3935                }3936                return null;3937            }3938        };3939    }3940    jquery.each([3941        "tabindex",3942        "readonly",3943        "maxlength",3944        "cellspacing",3945        "cellpadding",3946        "rowspan",3947        "colspan",3948        "usemap",3949        "frameborder",3950        "contenteditable"3951    ], function() {3952        jquery.propfix[ this.tolowercase() ] = this;3953    });3954// ie6/7 call enctype encoding3955    if ( !jquery.support.enctype ) {3956        jquery.propfix.enctype = "encoding";3957    }3958// radios and checkboxes getter/setter3959    jquery.each([ "radio", "checkbox" ], function() {3960        jquery.valhooks[ this ] = {3961            set: function( elem, value ) {3962                if ( jquery.isarray( value ) ) {3963                    return ( elem.checked = jquery.inarray( jquery(elem).val(), value ) >= 0 );3964                }3965            }3966        };3967        if ( !jquery.support.checkon ) {3968            jquery.valhooks[ this ].get = function( elem ) {3969                // support: webkit3970                // "" is returned instead of "on" if a value isn't specified3971                return elem.getattribute("value") === null ? "on" : elem.value;3972            };3973        }3974    });3975    var rformelems = /^(?:input|select|textarea)$/i,3976        rkeyevent = /^key/,3977        rmouseevent = /^(?:mouse|contextmenu)|click/,3978        rfocusmorph = /^(?:focusinfocus|focusoutblur)$/,3979        rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;3980    function returntrue() {3981        return true;3982    }3983    function returnfalse() {3984        return false;3985    }3986    function safeactiveelement() {3987        try {3988            return document.activeelement;3989        } catch ( err ) { }3990    }3991    /*3992     * helper functions for managing events -- not part of the public interface.3993     * props to dean edwards' addevent library for many of the ideas.3994     */3995    jquery.event = {3996        global: {},3997        add: function( elem, types, handler, data, selector ) {3998            var tmp, events, t, handleobjin,3999                special, eventhandle, handleobj,4000                handlers, type, namespaces, origtype,4001                elemdata = jquery._data( elem );4002            // don't attach events to nodata or text/comment nodes (but allow plain objects)4003            if ( !elemdata ) {4004                return;4005            }4006            // caller can pass in an object of custom data in lieu of the handler4007            if ( handler.handler ) {4008                handleobjin = handler;4009                handler = handleobjin.handler;4010                selector = handleobjin.selector;4011            }4012            // make sure that the handler has a unique id, used to find/remove it later4013            if ( !handler.guid ) {4014                handler.guid = jquery.guid++;4015            }4016            // init the element's event structure and main handler, if this is the first4017            if ( !(events = elemdata.events) ) {4018                events = elemdata.events = {};4019            }4020            if ( !(eventhandle = elemdata.handle) ) {4021                eventhandle = elemdata.handle = function( e ) {4022                    // discard the second event of a jquery.event.trigger() and4023                    // when an event is called after a page has unloaded4024                    return typeof jquery !== core_strundefined && (!e || jquery.event.triggered !== e.type) ?4025                        jquery.event.dispatch.apply( eventhandle.elem, arguments ) :4026                        undefined;4027                };4028                // add elem as a property of the handle fn to prevent a memory leak with ie non-native events4029                eventhandle.elem = elem;4030            }4031            // handle multiple events separated by a space4032            types = ( types || "" ).match( core_rnotwhite ) || [""];4033            t = types.length;4034            while ( t-- ) {4035                tmp = rtypenamespace.exec( types[t] ) || [];4036                type = origtype = tmp[1];4037                namespaces = ( tmp[2] || "" ).split( "." ).sort();4038                // there *must* be a type, no attaching namespace-only handlers4039                if ( !type ) {4040                    continue;4041                }4042                // if event changes its type, use the special event handlers for the changed type4043                special = jquery.event.special[ type ] || {};4044                // if selector defined, determine special event api type, otherwise given type4045                type = ( selector ? special.delegatetype : special.bindtype ) || type;4046                // update special based on newly reset type4047                special = jquery.event.special[ type ] || {};4048                // handleobj is passed to all event handlers4049                handleobj = jquery.extend({4050                    type: type,4051                    origtype: origtype,4052                    data: data,4053                    handler: handler,4054                    guid: handler.guid,4055                    selector: selector,4056                    needscontext: selector && jquery.expr.match.needscontext.test( selector ),4057                    namespace: namespaces.join(".")4058                }, handleobjin );4059                // init the event handler queue if we're the first4060                if ( !(handlers = events[ type ]) ) {4061                    handlers = events[ type ] = [];4062                    handlers.delegatecount = 0;4063                    // only use addeventlistener/attachevent if the special events handler returns false4064                    if ( !special.setup || special.setup.call( elem, data, namespaces, eventhandle ) === false ) {4065                        // bind the global event handler to the element4066                        if ( elem.addeventlistener ) {4067                            elem.addeventlistener( type, eventhandle, false );4068                        } else if ( elem.attachevent ) {4069                            elem.attachevent( "on" + type, eventhandle );4070                        }4071                    }4072                }4073                if ( special.add ) {4074                    special.add.call( elem, handleobj );4075                    if ( !handleobj.handler.guid ) {4076                        handleobj.handler.guid = handler.guid;4077                    }4078                }4079                // add to the element's handler list, delegates in front4080                if ( selector ) {4081                    handlers.splice( handlers.delegatecount++, 0, handleobj );4082                } else {4083                    handlers.push( handleobj );4084                }4085                // keep track of which events have ever been used, for event optimization4086                jquery.event.global[ type ] = true;4087            }4088            // nullify elem to prevent memory leaks in ie4089            elem = null;4090        },4091        // detach an event or set of events from an element4092        remove: function( elem, types, handler, selector, mappedtypes ) {4093            var j, handleobj, tmp,4094                origcount, t, events,4095                special, handlers, type,4096                namespaces, origtype,4097                elemdata = jquery.hasdata( elem ) && jquery._data( elem );4098            if ( !elemdata || !(events = elemdata.events) ) {4099                return;4100            }4101            // once for each type.namespace in types; type may be omitted4102            types = ( types || "" ).match( core_rnotwhite ) || [""];4103            t = types.length;4104            while ( t-- ) {4105                tmp = rtypenamespace.exec( types[t] ) || [];4106                type = origtype = tmp[1];4107                namespaces = ( tmp[2] || "" ).split( "." ).sort();4108                // unbind all events (on this namespace, if provided) for the element4109                if ( !type ) {4110                    for ( type in events ) {4111                        jquery.event.remove( elem, type + types[ t ], handler, selector, true );4112                    }4113                    continue;4114                }4115                special = jquery.event.special[ type ] || {};4116                type = ( selector ? special.delegatetype : special.bindtype ) || type;4117                handlers = events[ type ] || [];4118                tmp = tmp[2] && new regexp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" );4119                // remove matching events4120                origcount = j = handlers.length;4121                while ( j-- ) {4122                    handleobj = handlers[ j ];4123                    if ( ( mappedtypes || origtype === handleobj.origtype ) &&4124                        ( !handler || handler.guid === handleobj.guid ) &&4125                        ( !tmp || tmp.test( handleobj.namespace ) ) &&4126                        ( !selector || selector === handleobj.selector || selector === "**" && handleobj.selector ) ) {4127                        handlers.splice( j, 1 );4128                        if ( handleobj.selector ) {4129                            handlers.delegatecount--;4130                        }4131                        if ( special.remove ) {4132                            special.remove.call( elem, handleobj );4133                        }4134                    }4135                }4136                // remove generic event handler if we removed something and no more handlers exist4137                // (avoids potential for endless recursion during removal of special event handlers)4138                if ( origcount && !handlers.length ) {4139                    if ( !special.teardown || special.teardown.call( elem, namespaces, elemdata.handle ) === false ) {4140                        jquery.removeevent( elem, type, elemdata.handle );4141                    }4142                    delete events[ type ];4143                }4144            }4145            // remove the expando if it's no longer used4146            if ( jquery.isemptyobject( events ) ) {4147                delete elemdata.handle;4148                // removedata also checks for emptiness and clears the expando if empty4149                // so use it instead of delete4150                jquery._removedata( elem, "events" );4151            }4152        },4153        trigger: function( event, data, elem, onlyhandlers ) {4154            var handle, ontype, cur,4155                bubbletype, special, tmp, i,4156                eventpath = [ elem || document ],4157                type = core_hasown.call( event, "type" ) ? event.type : event,4158                namespaces = core_hasown.call( event, "namespace" ) ? event.namespace.split(".") : [];4159            cur = tmp = elem = elem || document;4160            // don't do events on text and comment nodes4161            if ( elem.nodetype === 3 || elem.nodetype === 8 ) {4162                return;4163            }4164            // focus/blur morphs to focusin/out; ensure we're not firing them right now4165            if ( rfocusmorph.test( type + jquery.event.triggered ) ) {4166                return;4167            }4168            if ( type.indexof(".") >= 0 ) {4169                // namespaced trigger; create a regexp to match event type in handle()4170                namespaces = type.split(".");4171                type = namespaces.shift();4172                namespaces.sort();4173            }4174            ontype = type.indexof(":") < 0 && "on" + type;4175            // caller can pass in a jquery.event object, object, or just an event type string4176            event = event[ jquery.expando ] ?4177                event :4178                new jquery.event( type, typeof event === "object" && event );4179            // trigger bitmask: & 1 for native handlers; & 2 for jquery (always true)4180            event.istrigger = onlyhandlers ? 2 : 3;4181            event.namespace = namespaces.join(".");4182            event.namespace_re = event.namespace ?4183                new regexp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ) :4184                null;4185            // clean up the event in case it is being reused4186            event.result = undefined;4187            if ( !event.target ) {4188                event.target = elem;4189            }4190            // clone any incoming data and prepend the event, creating the handler arg list4191            data = data == null ?4192                [ event ] :4193                jquery.makearray( data, [ event ] );4194            // allow special events to draw outside the lines4195            special = jquery.event.special[ type ] || {};4196            if ( !onlyhandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {4197                return;4198            }4199            // determine event propagation path in advance, per w3c events spec (#9951)4200            // bubble up to document, then to window; watch for a global ownerdocument var (#9724)4201            if ( !onlyhandlers && !special.nobubble && !jquery.iswindow( elem ) ) {4202                bubbletype = special.delegatetype || type;4203                if ( !rfocusmorph.test( bubbletype + type ) ) {4204                    cur = cur.parentnode;4205                }4206                for ( ; cur; cur = cur.parentnode ) {4207                    eventpath.push( cur );4208                    tmp = cur;4209                }4210                // only add window if we got to document (e.g., not plain obj or detached dom)4211                if ( tmp === (elem.ownerdocument || document) ) {4212                    eventpath.push( tmp.defaultview || tmp.parentwindow || window );4213                }4214            }4215            // fire handlers on the event path4216            i = 0;4217            while ( (cur = eventpath[i++]) && !event.ispropagationstopped() ) {4218                event.type = i > 1 ?4219                    bubbletype :4220                    special.bindtype || type;4221                // jquery handler4222                handle = ( jquery._data( cur, "events" ) || {} )[ event.type ] && jquery._data( cur, "handle" );4223                if ( handle ) {4224                    handle.apply( cur, data );4225                }4226                // native handler4227                handle = ontype && cur[ ontype ];4228                if ( handle && jquery.acceptdata( cur ) && handle.apply && handle.apply( cur, data ) === false ) {4229                    event.preventdefault();4230                }4231            }4232            event.type = type;4233            // if nobody prevented the default action, do it now4234            if ( !onlyhandlers && !event.isdefaultprevented() ) {4235                if ( (!special._default || special._default.apply( eventpath.pop(), data ) === false) &&4236                    jquery.acceptdata( elem ) ) {4237                    // call a native dom method on the target with the same name name as the event.4238                    // can't use an .isfunction() check here because ie6/7 fails that test.4239                    // don't do default actions on window, that's where global variables be (#6170)4240                    if ( ontype && elem[ type ] && !jquery.iswindow( elem ) ) {4241                        // don't re-trigger an onfoo event when we call its foo() method4242                        tmp = elem[ ontype ];4243                        if ( tmp ) {4244                            elem[ ontype ] = null;4245                        }4246                        // prevent re-triggering of the same event, since we already bubbled it above4247                        jquery.event.triggered = type;4248                        try {4249                            elem[ type ]();4250                        } catch ( e ) {4251                            // ie<9 dies on focus/blur to hidden element (#1486,#12518)4252                            // only reproducible on winxp ie8 native, not ie9 in ie8 mode4253                        }4254                        jquery.event.triggered = undefined;4255                        if ( tmp ) {4256                            elem[ ontype ] = tmp;4257                        }4258                    }4259                }4260            }4261            return event.result;4262        },4263        dispatch: function( event ) {4264            // make a writable jquery.event from the native event object4265            event = jquery.event.fix( event );4266            var i, ret, handleobj, matched, j,4267                handlerqueue = [],4268                args = core_slice.call( arguments ),4269                handlers = ( jquery._data( this, "events" ) || {} )[ event.type ] || [],4270                special = jquery.event.special[ event.type ] || {};4271            // use the fix-ed jquery.event rather than the (read-only) native event4272            args[0] = event;4273            event.delegatetarget = this;4274            // call the predispatch hook for the mapped type, and let it bail if desired4275            if ( special.predispatch && special.predispatch.call( this, event ) === false ) {4276                return;4277            }4278            // determine handlers4279            handlerqueue = jquery.event.handlers.call( this, event, handlers );4280            // run delegates first; they may want to stop propagation beneath us4281            i = 0;4282            while ( (matched = handlerqueue[ i++ ]) && !event.ispropagationstopped() ) {4283                event.currenttarget = matched.elem;4284                j = 0;4285                while ( (handleobj = matched.handlers[ j++ ]) && !event.isimmediatepropagationstopped() ) {4286                    // triggered event must either 1) have no namespace, or4287                    // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).4288                    if ( !event.namespace_re || event.namespace_re.test( handleobj.namespace ) ) {4289                        event.handleobj = handleobj;4290                        event.data = handleobj.data;4291                        ret = ( (jquery.event.special[ handleobj.origtype ] || {}).handle || handleobj.handler )4292                            .apply( matched.elem, args );4293                        if ( ret !== undefined ) {4294                            if ( (event.result = ret) === false ) {4295                                event.preventdefault();4296                                event.stoppropagation();4297                            }4298                        }4299                    }4300                }4301            }4302            // call the postdispatch hook for the mapped type4303            if ( special.postdispatch ) {4304                special.postdispatch.call( this, event );4305            }4306            return event.result;4307        },4308        handlers: function( event, handlers ) {4309            var sel, handleobj, matches, i,4310                handlerqueue = [],4311                delegatecount = handlers.delegatecount,4312                cur = event.target;4313            // find delegate handlers4314            // black-hole svg <use> instance trees (#13180)4315            // avoid non-left-click bubbling in firefox (#3861)4316            if ( delegatecount && cur.nodetype && (!event.button || event.type !== "click") ) {4317                /* jshint eqeqeq: false */4318                for ( ; cur != this; cur = cur.parentnode || this ) {4319                    /* jshint eqeqeq: true */4320                    // don't check non-elements (#13208)4321                    // don't process clicks on disabled elements (#6911, #8165, #11382, #11764)4322                    if ( cur.nodetype === 1 && (cur.disabled !== true || event.type !== "click") ) {4323                        matches = [];4324                        for ( i = 0; i < delegatecount; i++ ) {4325                            handleobj = handlers[ i ];4326                            // don't conflict with object.prototype properties (#13203)4327                            sel = handleobj.selector + " ";4328                            if ( matches[ sel ] === undefined ) {4329                                matches[ sel ] = handleobj.needscontext ?4330                                    jquery( sel, this ).index( cur ) >= 0 :4331                                    jquery.find( sel, this, null, [ cur ] ).length;4332                            }4333                            if ( matches[ sel ] ) {4334                                matches.push( handleobj );4335                            }4336                        }4337                        if ( matches.length ) {4338                            handlerqueue.push({ elem: cur, handlers: matches });4339                        }4340                    }4341                }4342            }4343            // add the remaining (directly-bound) handlers4344            if ( delegatecount < handlers.length ) {4345                handlerqueue.push({ elem: this, handlers: handlers.slice( delegatecount ) });4346            }4347            return handlerqueue;4348        },4349        fix: function( event ) {4350            if ( event[ jquery.expando ] ) {4351                return event;4352            }4353            // create a writable copy of the event object and normalize some properties4354            var i, prop, copy,4355                type = event.type,4356                originalevent = event,4357                fixhook = this.fixhooks[ type ];4358            if ( !fixhook ) {4359                this.fixhooks[ type ] = fixhook =4360                    rmouseevent.test( type ) ? this.mousehooks :4361                        rkeyevent.test( type ) ? this.keyhooks :4362                        {};4363            }4364            copy = fixhook.props ? this.props.concat( fixhook.props ) : this.props;4365            event = new jquery.event( originalevent );4366            i = copy.length;4367            while ( i-- ) {4368                prop = copy[ i ];4369                event[ prop ] = originalevent[ prop ];4370            }4371            // support: ie<94372            // fix target property (#1925)4373            if ( !event.target ) {4374                event.target = originalevent.srcelement || document;4375            }4376            // support: chrome 23+, safari?4377            // target should not be a text node (#504, #13143)4378            if ( event.target.nodetype === 3 ) {4379                event.target = event.target.parentnode;4380            }4381            // support: ie<94382            // for mouse/key events, metakey==false if it's undefined (#3368, #11328)4383            event.metakey = !!event.metakey;4384            return fixhook.filter ? fixhook.filter( event, originalevent ) : event;4385        },4386        // includes some event props shared by keyevent and mouseevent4387        props: "altkey bubbles cancelable ctrlkey currenttarget eventphase metakey relatedtarget shiftkey target timestamp view which".split(" "),4388        fixhooks: {},4389        keyhooks: {4390            props: "char charcode key keycode".split(" "),4391            filter: function( event, original ) {4392                // add which for key events4393                if ( event.which == null ) {4394                    event.which = original.charcode != null ? original.charcode : original.keycode;4395                }4396                return event;4397            }4398        },4399        mousehooks: {4400            props: "button buttons clientx clienty fromelement offsetx offsety pagex pagey screenx screeny toelement".split(" "),4401            filter: function( event, original ) {4402                var body, eventdoc, doc,4403                    button = original.button,4404                    fromelement = original.fromelement;4405                // calculate pagex/y if missing and clientx/y available4406                if ( event.pagex == null && original.clientx != null ) {4407                    eventdoc = event.target.ownerdocument || document;4408                    doc = eventdoc.documentelement;4409                    body = eventdoc.body;4410                    event.pagex = original.clientx + ( doc && doc.scrollleft || body && body.scrollleft || 0 ) - ( doc && doc.clientleft || body && body.clientleft || 0 );4411                    event.pagey = original.clienty + ( doc && doc.scrolltop  || body && body.scrolltop  || 0 ) - ( doc && doc.clienttop  || body && body.clienttop  || 0 );4412                }4413                // add relatedtarget, if necessary4414                if ( !event.relatedtarget && fromelement ) {4415                    event.relatedtarget = fromelement === event.target ? original.toelement : fromelement;4416                }4417                // add which for click: 1 === left; 2 === middle; 3 === right4418                // note: button is not normalized, so don't use it4419                if ( !event.which && button !== undefined ) {4420                    event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );4421                }4422                return event;4423            }4424        },4425        special: {4426            load: {4427                // prevent triggered image.load events from bubbling to window.load4428                nobubble: true4429            },4430            focus: {4431                // fire native event if possible so blur/focus sequence is correct4432                trigger: function() {4433                    if ( this !== safeactiveelement() && this.focus ) {4434                        try {4435                            this.focus();4436                            return false;4437                        } catch ( e ) {4438                            // support: ie<94439                            // if we error on focus to hidden element (#1486, #12518),4440                            // let .trigger() run the handlers4441                        }4442                    }4443                },4444                delegatetype: "focusin"4445            },4446            blur: {4447                trigger: function() {4448                    if ( this === safeactiveelement() && this.blur ) {4449                        this.blur();4450                        return false;4451                    }4452                },4453                delegatetype: "focusout"4454            },4455            click: {4456                // for checkbox, fire native event so checked state will be right4457                trigger: function() {4458                    if ( jquery.nodename( this, "input" ) && this.type === "checkbox" && this.click ) {4459                        this.click();4460                        return false;4461                    }4462                },4463                // for cross-browser consistency, don't fire native .click() on links4464                _default: function( event ) {4465                    return jquery.nodename( event.target, "a" );4466                }4467            },4468            beforeunload: {4469                postdispatch: function( event ) {4470                    // even when returnvalue equals to undefined firefox will still show alert4471                    if ( event.result !== undefined ) {4472                        event.originalevent.returnvalue = event.result;4473                    }4474                }4475            }4476        },4477        simulate: function( type, elem, event, bubble ) {4478            // piggyback on a donor event to simulate a different one.4479            // fake originalevent to avoid donor's stoppropagation, but if the4480            // simulated event prevents default then we do the same on the donor.4481            var e = jquery.extend(4482                new jquery.event(),4483                event,4484                {4485                    type: type,4486                    issimulated: true,4487                    originalevent: {}4488                }4489            );4490            if ( bubble ) {4491                jquery.event.trigger( e, null, elem );4492            } else {4493                jquery.event.dispatch.call( elem, e );4494            }4495            if ( e.isdefaultprevented() ) {4496                event.preventdefault();4497            }4498        }4499    };4500    jquery.removeevent = document.removeeventlistener ?4501        function( elem, type, handle ) {4502            if ( elem.removeeventlistener ) {4503                elem.removeeventlistener( type, handle, false );4504            }4505        } :4506        function( elem, type, handle ) {4507            var name = "on" + type;4508            if ( elem.detachevent ) {4509                // #8545, #7054, preventing memory leaks for custom events in ie6-84510                // detachevent needed property on element, by name of that event, to properly expose it to gc4511                if ( typeof elem[ name ] === core_strundefined ) {4512                    elem[ name ] = null;4513                }4514                elem.detachevent( name, handle );4515            }4516        };4517    jquery.event = function( src, props ) {4518        // allow instantiation without the 'new' keyword4519        if ( !(this instanceof jquery.event) ) {4520            return new jquery.event( src, props );4521        }4522        // event object4523        if ( src && src.type ) {4524            this.originalevent = src;4525            this.type = src.type;4526            // events bubbling up the document may have been marked as prevented4527            // by a handler lower down the tree; reflect the correct value.4528            this.isdefaultprevented = ( src.defaultprevented || src.returnvalue === false ||4529                src.getpreventdefault && src.getpreventdefault() ) ? returntrue : returnfalse;4530            // event type4531        } else {4532            this.type = src;4533        }4534        // put explicitly provided properties onto the event object4535        if ( props ) {4536            jquery.extend( this, props );4537        }4538        // create a timestamp if incoming event doesn't have one4539        this.timestamp = src && src.timestamp || jquery.now();4540        // mark it as fixed4541        this[ jquery.expando ] = true;4542    };4543// jquery.event is based on dom3 events as specified by the ecmascript language binding4544// http://www.w3.org/tr/2003/wd-dom-level-3-events-20030331/ecma-script-binding.html4545    jquery.event.prototype = {4546        isdefaultprevented: returnfalse,4547        ispropagationstopped: returnfalse,4548        isimmediatepropagationstopped: returnfalse,4549        preventdefault: function() {4550            var e = this.originalevent;4551            this.isdefaultprevented = returntrue;4552            if ( !e ) {4553                return;4554            }4555            // if preventdefault exists, run it on the original event4556            if ( e.preventdefault ) {4557                e.preventdefault();4558                // support: ie4559                // otherwise set the returnvalue property of the original event to false4560            } else {4561                e.returnvalue = false;4562            }4563        },4564        stoppropagation: function() {4565            var e = this.originalevent;4566            this.ispropagationstopped = returntrue;4567            if ( !e ) {4568                return;4569            }4570            // if stoppropagation exists, run it on the original event4571            if ( e.stoppropagation ) {4572                e.stoppropagation();4573            }4574            // support: ie4575            // set the cancelbubble property of the original event to true4576            e.cancelbubble = true;4577        },4578        stopimmediatepropagation: function() {4579            this.isimmediatepropagationstopped = returntrue;4580            this.stoppropagation();4581        }4582    };4583// create mouseenter/leave events using mouseover/out and event-time checks4584    jquery.each({4585        mouseenter: "mouseover",4586        mouseleave: "mouseout"4587    }, function( orig, fix ) {4588        jquery.event.special[ orig ] = {4589            delegatetype: fix,4590            bindtype: fix,4591            handle: function( event ) {4592                var ret,4593                    target = this,4594                    related = event.relatedtarget,4595                    handleobj = event.handleobj;4596                // for mousenter/leave call the handler if related is outside the target.4597                // nb: no relatedtarget if the mouse left/entered the browser window4598                if ( !related || (related !== target && !jquery.contains( target, related )) ) {4599                    event.type = handleobj.origtype;4600                    ret = handleobj.handler.apply( this, arguments );4601                    event.type = fix;4602                }4603                return ret;4604            }4605        };4606    });4607// ie submit delegation4608    if ( !jquery.support.submitbubbles ) {4609        jquery.event.special.submit = {4610            setup: function() {4611                // only need this for delegated form submit events4612                if ( jquery.nodename( this, "form" ) ) {4613                    return false;4614                }4615                // lazy-add a submit handler when a descendant form may potentially be submitted4616                jquery.event.add( this, "click._submit keypress._submit", function( e ) {4617                    // node name check avoids a vml-related crash in ie (#9807)4618                    var elem = e.target,4619                        form = jquery.nodename( elem, "input" ) || jquery.nodename( elem, "button" ) ? elem.form : undefined;4620                    if ( form && !jquery._data( form, "submitbubbles" ) ) {4621                        jquery.event.add( form, "submit._submit", function( event ) {4622                            event._submit_bubble = true;4623                        });4624                        jquery._data( form, "submitbubbles", true );4625                    }4626                });4627                // return undefined since we don't need an event listener4628            },4629            postdispatch: function( event ) {4630                // if form was submitted by the user, bubble the event up the tree4631                if ( event._submit_bubble ) {4632                    delete event._submit_bubble;4633                    if ( this.parentnode && !event.istrigger ) {4634                        jquery.event.simulate( "submit", this.parentnode, event, true );4635                    }4636                }4637            },4638            teardown: function() {4639                // only need this for delegated form submit events4640                if ( jquery.nodename( this, "form" ) ) {4641                    return false;4642                }4643                // remove delegated handlers; cleandata eventually reaps submit handlers attached above4644                jquery.event.remove( this, "._submit" );4645            }4646        };4647    }4648// ie change delegation and checkbox/radio fix4649    if ( !jquery.support.changebubbles ) {4650        jquery.event.special.change = {4651            setup: function() {4652                if ( rformelems.test( this.nodename ) ) {4653                    // ie doesn't fire change on a check/radio until blur; trigger it on click4654                    // after a propertychange. eat the blur-change in special.change.handle.4655                    // this still fires onchange a second time for check/radio after blur.4656                    if ( this.type === "checkbox" || this.type === "radio" ) {4657                        jquery.event.add( this, "propertychange._change", function( event ) {4658                            if ( event.originalevent.propertyname === "checked" ) {4659                                this._just_changed = true;4660                            }4661                        });4662                        jquery.event.add( this, "click._change", function( event ) {4663                            if ( this._just_changed && !event.istrigger ) {4664                                this._just_changed = false;4665                            }4666                            // allow triggered, simulated change events (#11500)4667                            jquery.event.simulate( "change", this, event, true );4668                        });4669                    }4670                    return false;4671                }4672                // delegated event; lazy-add a change handler on descendant inputs4673                jquery.event.add( this, "beforeactivate._change", function( e ) {4674                    var elem = e.target;4675                    if ( rformelems.test( elem.nodename ) && !jquery._data( elem, "changebubbles" ) ) {4676                        jquery.event.add( elem, "change._change", function( event ) {4677                            if ( this.parentnode && !event.issimulated && !event.istrigger ) {4678                                jquery.event.simulate( "change", this.parentnode, event, true );4679                            }4680                        });4681                        jquery._data( elem, "changebubbles", true );4682                    }4683                });4684            },4685            handle: function( event ) {4686                var elem = event.target;4687                // swallow native change events from checkbox/radio, we already triggered them above4688                if ( this !== elem || event.issimulated || event.istrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {4689                    return event.handleobj.handler.apply( this, arguments );4690                }4691            },4692            teardown: function() {4693                jquery.event.remove( this, "._change" );4694                return !rformelems.test( this.nodename );4695            }4696        };4697    }4698// create "bubbling" focus and blur events4699    if ( !jquery.support.focusinbubbles ) {4700        jquery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {4701            // attach a single capturing handler while someone wants focusin/focusout4702            var attaches = 0,4703                handler = function( event ) {4704                    jquery.event.simulate( fix, event.target, jquery.event.fix( event ), true );4705                };4706            jquery.event.special[ fix ] = {4707                setup: function() {4708                    if ( attaches++ === 0 ) {4709                        document.addeventlistener( orig, handler, true );4710                    }4711                },4712                teardown: function() {4713                    if ( --attaches === 0 ) {4714                        document.removeeventlistener( orig, handler, true );4715                    }4716                }4717            };4718        });4719    }4720    jquery.fn.extend({4721        on: function( types, selector, data, fn, /*internal*/ one ) {4722            var type, origfn;4723            // types can be a map of types/handlers4724            if ( typeof types === "object" ) {4725                // ( types-object, selector, data )4726                if ( typeof selector !== "string" ) {4727                    // ( types-object, data )4728                    data = data || selector;4729                    selector = undefined;4730                }4731                for ( type in types ) {4732                    this.on( type, selector, data, types[ type ], one );4733                }4734                return this;4735            }4736            if ( data == null && fn == null ) {4737                // ( types, fn )4738                fn = selector;4739                data = selector = undefined;4740            } else if ( fn == null ) {4741                if ( typeof selector === "string" ) {4742                    // ( types, selector, fn )4743                    fn = data;4744                    data = undefined;4745                } else {4746                    // ( types, data, fn )4747                    fn = data;4748                    data = selector;4749                    selector = undefined;4750                }4751            }4752            if ( fn === false ) {4753                fn = returnfalse;4754            } else if ( !fn ) {4755                return this;4756            }4757            if ( one === 1 ) {4758                origfn = fn;4759                fn = function( event ) {4760                    // can use an empty set, since event contains the info4761                    jquery().off( event );4762                    return origfn.apply( this, arguments );4763                };4764                // use same guid so caller can remove using origfn4765                fn.guid = origfn.guid || ( origfn.guid = jquery.guid++ );4766            }4767            return this.each( function() {4768                jquery.event.add( this, types, fn, data, selector );4769            });4770        },4771        one: function( types, selector, data, fn ) {4772            return this.on( types, selector, data, fn, 1 );4773        },4774        off: function( types, selector, fn ) {4775            var handleobj, type;4776            if ( types && types.preventdefault && types.handleobj ) {4777                // ( event )  dispatched jquery.event4778                handleobj = types.handleobj;4779                jquery( types.delegatetarget ).off(4780                    handleobj.namespace ? handleobj.origtype + "." + handleobj.namespace : handleobj.origtype,4781                    handleobj.selector,4782                    handleobj.handler4783                );4784                return this;4785            }4786            if ( typeof types === "object" ) {4787                // ( types-object [, selector] )4788                for ( type in types ) {4789                    this.off( type, selector, types[ type ] );4790                }4791                return this;4792            }4793            if ( selector === false || typeof selector === "function" ) {4794                // ( types [, fn] )4795                fn = selector;4796                selector = undefined;4797            }4798            if ( fn === false ) {4799                fn = returnfalse;4800            }4801            return this.each(function() {4802                jquery.event.remove( this, types, fn, selector );4803            });4804        },4805        trigger: function( type, data ) {4806            return this.each(function() {4807                jquery.event.trigger( type, data, this );4808            });4809        },4810        triggerhandler: function( type, data ) {4811            var elem = this[0];4812            if ( elem ) {4813                return jquery.event.trigger( type, data, elem, true );4814            }4815        }4816    });4817    var issimple = /^.[^:#\[\.,]*$/,4818        rparentsprev = /^(?:parents|prev(?:until|all))/,4819        rneedscontext = jquery.expr.match.needscontext,4820    // methods guaranteed to produce a unique set when starting from a unique set4821        guaranteedunique = {4822            children: true,4823            contents: true,4824            next: true,4825            prev: true4826        };4827    jquery.fn.extend({4828        find: function( selector ) {4829            var i,4830                ret = [],4831                self = this,4832                len = self.length;4833            if ( typeof selector !== "string" ) {4834                return this.pushstack( jquery( selector ).filter(function() {4835                    for ( i = 0; i < len; i++ ) {4836                        if ( jquery.contains( self[ i ], this ) ) {4837                            return true;4838                        }4839                    }4840                }) );4841            }4842            for ( i = 0; i < len; i++ ) {4843                jquery.find( selector, self[ i ], ret );4844            }4845            // needed because $( selector, context ) becomes $( context ).find( selector )4846            ret = this.pushstack( len > 1 ? jquery.unique( ret ) : ret );4847            ret.selector = this.selector ? this.selector + " " + selector : selector;4848            return ret;4849        },4850        has: function( target ) {4851            var i,4852                targets = jquery( target, this ),4853                len = targets.length;4854            return this.filter(function() {4855                for ( i = 0; i < len; i++ ) {4856                    if ( jquery.contains( this, targets[i] ) ) {4857                        return true;4858                    }4859                }4860            });4861        },4862        not: function( selector ) {4863            return this.pushstack( winnow(this, selector || [], true) );4864        },4865        filter: function( selector ) {4866            return this.pushstack( winnow(this, selector || [], false) );4867        },4868        is: function( selector ) {4869            return !!winnow(4870                this,4871                // if this is a positional/relative selector, check membership in the returned set4872                // so $("p:first").is("p:last") won't return true for a doc with two "p".4873                    typeof selector === "string" && rneedscontext.test( selector ) ?4874                    jquery( selector ) :4875                    selector || [],4876                false4877            ).length;4878        },4879        closest: function( selectors, context ) {4880            var cur,4881                i = 0,4882                l = this.length,4883                ret = [],4884                pos = rneedscontext.test( selectors ) || typeof selectors !== "string" ?4885                    jquery( selectors, context || this.context ) :4886                    0;4887            for ( ; i < l; i++ ) {4888                for ( cur = this[i]; cur && cur !== context; cur = cur.parentnode ) {4889                    // always skip document fragments4890                    if ( cur.nodetype < 11 && (pos ?4891                        pos.index(cur) > -1 :4892                        // don't pass non-elements to sizzle4893                        cur.nodetype === 1 &&4894                        jquery.find.matchesselector(cur, selectors)) ) {4895                        cur = ret.push( cur );4896                        break;4897                    }4898                }4899            }4900            return this.pushstack( ret.length > 1 ? jquery.unique( ret ) : ret );4901        },4902        // determine the position of an element within4903        // the matched set of elements4904        index: function( elem ) {4905            // no argument, return index in parent4906            if ( !elem ) {4907                return ( this[0] && this[0].parentnode ) ? this.first().prevall().length : -1;4908            }4909            // index in selector4910            if ( typeof elem === "string" ) {4911                return jquery.inarray( this[0], jquery( elem ) );4912            }4913            // locate the position of the desired element4914            return jquery.inarray(4915                // if it receives a jquery object, the first element is used4916                elem.jquery ? elem[0] : elem, this );4917        },4918        add: function( selector, context ) {4919            var set = typeof selector === "string" ?4920                    jquery( selector, context ) :4921                    jquery.makearray( selector && selector.nodetype ? [ selector ] : selector ),4922                all = jquery.merge( this.get(), set );4923            return this.pushstack( jquery.unique(all) );4924        },4925        addback: function( selector ) {4926            return this.add( selector == null ?4927                    this.prevobject : this.prevobject.filter(selector)4928            );4929        }4930    });4931    function sibling( cur, dir ) {4932        do {4933            cur = cur[ dir ];4934        } while ( cur && cur.nodetype !== 1 );4935        return cur;4936    }4937    jquery.each({4938        parent: function( elem ) {4939            var parent = elem.parentnode;4940            return parent && parent.nodetype !== 11 ? parent : null;4941        },4942        parents: function( elem ) {4943            return jquery.dir( elem, "parentnode" );4944        },4945        parentsuntil: function( elem, i, until ) {4946            return jquery.dir( elem, "parentnode", until );4947        },4948        next: function( elem ) {4949            return sibling( elem, "nextsibling" );4950        },4951        prev: function( elem ) {4952            return sibling( elem, "previoussibling" );4953        },4954        nextall: function( elem ) {4955            return jquery.dir( elem, "nextsibling" );4956        },4957        prevall: function( elem ) {4958            return jquery.dir( elem, "previoussibling" );4959        },4960        nextuntil: function( elem, i, until ) {4961            return jquery.dir( elem, "nextsibling", until );4962        },4963        prevuntil: function( elem, i, until ) {4964            return jquery.dir( elem, "previoussibling", until );4965        },4966        siblings: function( elem ) {4967            return jquery.sibling( ( elem.parentnode || {} ).firstchild, elem );4968        },4969        children: function( elem ) {4970            return jquery.sibling( elem.firstchild );4971        },4972        contents: function( elem ) {4973            return jquery.nodename( elem, "iframe" ) ?4974                elem.contentdocument || elem.contentwindow.document :4975                jquery.merge( [], elem.childnodes );4976        }4977    }, function( name, fn ) {4978        jquery.fn[ name ] = function( until, selector ) {4979            var ret = jquery.map( this, fn, until );4980            if ( name.slice( -5 ) !== "until" ) {4981                selector = until;4982            }4983            if ( selector && typeof selector === "string" ) {4984                ret = jquery.filter( selector, ret );4985            }4986            if ( this.length > 1 ) {4987                // remove duplicates4988                if ( !guaranteedunique[ name ] ) {4989                    ret = jquery.unique( ret );4990                }4991                // reverse order for parents* and prev-derivatives4992                if ( rparentsprev.test( name ) ) {4993                    ret = ret.reverse();4994                }4995            }4996            return this.pushstack( ret );4997        };4998    });4999    jquery.extend({5000        filter: function( expr, elems, not ) {5001            var elem = elems[ 0 ];5002            if ( not ) {5003                expr = ":not(" + expr + ")";5004            }5005            return elems.length === 1 && elem.nodetype === 1 ?5006                jquery.find.matchesselector( elem, expr ) ? [ elem ] : [] :5007                jquery.find.matches( expr, jquery.grep( elems, function( elem ) {5008                    return elem.nodetype === 1;5009                }));5010        },5011        dir: function( elem, dir, until ) {5012            var matched = [],5013                cur = elem[ dir ];5014            while ( cur && cur.nodetype !== 9 && (until === undefined || cur.nodetype !== 1 || !jquery( cur ).is( until )) ) {5015                if ( cur.nodetype === 1 ) {5016                    matched.push( cur );5017                }5018                cur = cur[dir];5019            }5020            return matched;5021        },5022        sibling: function( n, elem ) {5023            var r = [];5024            for ( ; n; n = n.nextsibling ) {5025                if ( n.nodetype === 1 && n !== elem ) {5026                    r.push( n );5027                }5028            }5029            return r;5030        }5031    });5032// implement the identical functionality for filter and not5033    function winnow( elements, qualifier, not ) {5034        if ( jquery.isfunction( qualifier ) ) {5035            return jquery.grep( elements, function( elem, i ) {5036                /* jshint -w018 */5037                return !!qualifier.call( elem, i, elem ) !== not;5038            });5039        }5040        if ( qualifier.nodetype ) {5041            return jquery.grep( elements, function( elem ) {5042                return ( elem === qualifier ) !== not;5043            });5044        }5045        if ( typeof qualifier === "string" ) {5046            if ( issimple.test( qualifier ) ) {5047                return jquery.filter( qualifier, elements, not );5048            }5049            qualifier = jquery.filter( qualifier, elements );5050        }5051        return jquery.grep( elements, function( elem ) {5052            return ( jquery.inarray( elem, qualifier ) >= 0 ) !== not;5053        });5054    }5055    function createsafefragment( document ) {5056        var list = nodenames.split( "|" ),5057            safefrag = document.createdocumentfragment();5058        if ( safefrag.createelement ) {5059            while ( list.length ) {5060                safefrag.createelement(5061                    list.pop()5062                );5063            }5064        }5065        return safefrag;5066    }5067    var nodenames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|" +5068            "header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",5069        rinlinejquery = / jquery\d+="(?:null|\d+)"/g,5070        rnoshimcache = new regexp("<(?:" + nodenames + ")[\\s/>]", "i"),5071        rleadingwhitespace = /^\s+/,5072        rxhtmltag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,5073        rtagname = /<([\w:]+)/,5074        rtbody = /<tbody/i,5075        rhtml = /<|&#?\w+;/,5076        rnoinnerhtml = /<(?:script|style|link)/i,5077        manipulation_rcheckabletype = /^(?:checkbox|radio)$/i,5078    // checked="checked" or checked5079        rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,5080        rscripttype = /^$|\/(?:java|ecma)script/i,5081        rscripttypemasked = /^true\/(.*)/,5082        rcleanscript = /^\s*<!(?:\[cdata\[|--)|(?:\]\]|--)>\s*$/g,5083    // we have to close these tags to support xhtml (#13200)5084        wrapmap = {5085            option: [ 1, "<select multiple='multiple'>", "</select>" ],5086            legend: [ 1, "<fieldset>", "</fieldset>" ],5087            area: [ 1, "<map>", "</map>" ],5088            param: [ 1, "<object>", "</object>" ],5089            thead: [ 1, "<table>", "</table>" ],5090            tr: [ 2, "<table><tbody>", "</tbody></table>" ],5091            col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],5092            td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],5093            // ie6-8 can't serialize link, script, style, or any html5 (noscope) tags,5094            // unless wrapped in a div with non-breaking characters in front of it.5095            _default: jquery.support.htmlserialize ? [ 0, "", "" ] : [ 1, "x<div>", "</div>"  ]5096        },5097        safefragment = createsafefragment( document ),5098        fragmentdiv = safefragment.appendchild( document.createelement("div") );5099    wrapmap.optgroup = wrapmap.option;5100    wrapmap.tbody = wrapmap.tfoot = wrapmap.colgroup = wrapmap.caption = wrapmap.thead;5101    wrapmap.th = wrapmap.td;5102    jquery.fn.extend({5103        text: function( value ) {5104            return jquery.access( this, function( value ) {5105                return value === undefined ?5106                    jquery.text( this ) :5107                    this.empty().append( ( this[0] && this[0].ownerdocument || document ).createtextnode( value ) );5108            }, null, value, arguments.length );5109        },5110        append: function() {5111            return this.dommanip( arguments, function( elem ) {5112                if ( this.nodetype === 1 || this.nodetype === 11 || this.nodetype === 9 ) {5113                    var target = manipulationtarget( this, elem );5114                    target.appendchild( elem );5115                }5116            });5117        },5118        prepend: function() {5119            return this.dommanip( arguments, function( elem ) {5120                if ( this.nodetype === 1 || this.nodetype === 11 || this.nodetype === 9 ) {5121                    var target = manipulationtarget( this, elem );5122                    target.insertbefore( elem, target.firstchild );5123                }5124            });5125        },5126        before: function() {5127            return this.dommanip( arguments, function( elem ) {5128                if ( this.parentnode ) {5129                    this.parentnode.insertbefore( elem, this );5130                }5131            });5132        },5133        after: function() {5134            return this.dommanip( arguments, function( elem ) {5135                if ( this.parentnode ) {5136                    this.parentnode.insertbefore( elem, this.nextsibling );5137                }5138            });5139        },5140        // keepdata is for internal use only--do not document5141        remove: function( selector, keepdata ) {5142            var elem,5143                elems = selector ? jquery.filter( selector, this ) : this,5144                i = 0;5145            for ( ; (elem = elems[i]) != null; i++ ) {5146                if ( !keepdata && elem.nodetype === 1 ) {5147                    jquery.cleandata( getall( elem ) );5148                }5149                if ( elem.parentnode ) {5150                    if ( keepdata && jquery.contains( elem.ownerdocument, elem ) ) {5151                        setglobaleval( getall( elem, "script" ) );5152                    }5153                    elem.parentnode.removechild( elem );5154                }5155            }5156            return this;5157        },5158        empty: function() {5159            var elem,5160                i = 0;5161            for ( ; (elem = this[i]) != null; i++ ) {5162                // remove element nodes and prevent memory leaks5163                if ( elem.nodetype === 1 ) {5164                    jquery.cleandata( getall( elem, false ) );5165                }5166                // remove any remaining nodes5167                while ( elem.firstchild ) {5168                    elem.removechild( elem.firstchild );5169                }5170                // if this is a select, ensure that it displays empty (#12336)5171                // support: ie<95172                if ( elem.options && jquery.nodename( elem, "select" ) ) {5173                    elem.options.length = 0;5174                }5175            }5176            return this;5177        },5178        clone: function( dataandevents, deepdataandevents ) {5179            dataandevents = dataandevents == null ? false : dataandevents;5180            deepdataandevents = deepdataandevents == null ? dataandevents : deepdataandevents;5181            return this.map( function () {5182                return jquery.clone( this, dataandevents, deepdataandevents );5183            });5184        },5185        html: function( value ) {5186            return jquery.access( this, function( value ) {5187                var elem = this[0] || {},5188                    i = 0,5189                    l = this.length;5190                if ( value === undefined ) {5191                    return elem.nodetype === 1 ?5192                        elem.innerhtml.replace( rinlinejquery, "" ) :5193                        undefined;5194                }5195                // see if we can take a shortcut and just use innerhtml5196                if ( typeof value === "string" && !rnoinnerhtml.test( value ) &&5197                    ( jquery.support.htmlserialize || !rnoshimcache.test( value )  ) &&5198                    ( jquery.support.leadingwhitespace || !rleadingwhitespace.test( value ) ) &&5199                    !wrapmap[ ( rtagname.exec( value ) || ["", ""] )[1].tolowercase() ] ) {5200                    value = value.replace( rxhtmltag, "<$1></$2>" );5201                    try {5202                        for (; i < l; i++ ) {5203                            // remove element nodes and prevent memory leaks5204                            elem = this[i] || {};5205                            if ( elem.nodetype === 1 ) {5206                                jquery.cleandata( getall( elem, false ) );5207                                elem.innerhtml = value;5208                            }5209                        }5210                        elem = 0;5211                        // if using innerhtml throws an exception, use the fallback method5212                    } catch(e) {}5213                }5214                if ( elem ) {5215                    this.empty().append( value );5216                }5217            }, null, value, arguments.length );5218        },5219        replacewith: function() {5220            var5221            // snapshot the dom in case .dommanip sweeps something relevant into its fragment5222                args = jquery.map( this, function( elem ) {5223                    return [ elem.nextsibling, elem.parentnode ];5224                }),5225                i = 0;5226            // make the changes, replacing each context element with the new content5227            this.dommanip( arguments, function( elem ) {5228                var next = args[ i++ ],5229                    parent = args[ i++ ];5230                if ( parent ) {5231                    // don't use the snapshot next if it has moved (#13810)5232                    if ( next && next.parentnode !== parent ) {5233                        next = this.nextsibling;5234                    }5235                    jquery( this ).remove();5236                    parent.insertbefore( elem, next );5237                }5238                // allow new content to include elements from the context set5239            }, true );5240            // force removal if there was no new content (e.g., from empty arguments)5241            return i ? this : this.remove();5242        },5243        detach: function( selector ) {5244            return this.remove( selector, true );5245        },5246        dommanip: function( args, callback, allowintersection ) {5247            // flatten any nested arrays5248            args = core_concat.apply( [], args );5249            var first, node, hasscripts,5250                scripts, doc, fragment,5251                i = 0,5252                l = this.length,5253                set = this,5254                inoclone = l - 1,5255                value = args[0],5256                isfunction = jquery.isfunction( value );5257            // we can't clonenode fragments that contain checked, in webkit5258            if ( isfunction || !( l <= 1 || typeof value !== "string" || jquery.support.checkclone || !rchecked.test( value ) ) ) {5259                return this.each(function( index ) {5260                    var self = set.eq( index );5261                    if ( isfunction ) {5262                        args[0] = value.call( this, index, self.html() );5263                    }5264                    self.dommanip( args, callback, allowintersection );5265                });5266            }5267            if ( l ) {5268                fragment = jquery.buildfragment( args, this[ 0 ].ownerdocument, false, !allowintersection && this );5269                first = fragment.firstchild;5270                if ( fragment.childnodes.length === 1 ) {5271                    fragment = first;5272                }5273                if ( first ) {5274                    scripts = jquery.map( getall( fragment, "script" ), disablescript );5275                    hasscripts = scripts.length;5276                    // use the original fragment for the last item instead of the first because it can end up5277                    // being emptied incorrectly in certain situations (#8070).5278                    for ( ; i < l; i++ ) {5279                        node = fragment;5280                        if ( i !== inoclone ) {5281                            node = jquery.clone( node, true, true );5282                            // keep references to cloned scripts for later restoration5283                            if ( hasscripts ) {5284                                jquery.merge( scripts, getall( node, "script" ) );5285                            }5286                        }5287                        callback.call( this[i], node, i );5288                    }5289                    if ( hasscripts ) {5290                        doc = scripts[ scripts.length - 1 ].ownerdocument;5291                        // reenable scripts5292                        jquery.map( scripts, restorescript );5293                        // evaluate executable scripts on first document insertion5294                        for ( i = 0; i < hasscripts; i++ ) {5295                            node = scripts[ i ];5296                            if ( rscripttype.test( node.type || "" ) &&5297                                !jquery._data( node, "globaleval" ) && jquery.contains( doc, node ) ) {5298                                if ( node.src ) {5299                                    // hope ajax is available...5300                                    jquery._evalurl( node.src );5301                                } else {5302                                    jquery.globaleval( ( node.text || node.textcontent || node.innerhtml || "" ).replace( rcleanscript, "" ) );5303                                }5304                            }5305                        }5306                    }5307                    // fix #11809: avoid leaking memory5308                    fragment = first = null;5309                }5310            }5311            return this;5312        }5313    });5314// support: ie<85315// manipulating tables requires a tbody5316    function manipulationtarget( elem, content ) {5317        return jquery.nodename( elem, "table" ) &&5318            jquery.nodename( content.nodetype === 1 ? content : content.firstchild, "tr" ) ?5319            elem.getelementsbytagname("tbody")[0] ||5320            elem.appendchild( elem.ownerdocument.createelement("tbody") ) :5321            elem;5322    }5323// replace/restore the type attribute of script elements for safe dom manipulation5324    function disablescript( elem ) {5325        elem.type = (jquery.find.attr( elem, "type" ) !== null) + "/" + elem.type;5326        return elem;5327    }5328    function restorescript( elem ) {5329        var match = rscripttypemasked.exec( elem.type );5330        if ( match ) {5331            elem.type = match[1];5332        } else {5333            elem.removeattribute("type");5334        }5335        return elem;5336    }5337// mark scripts as having already been evaluated5338    function setglobaleval( elems, refelements ) {5339        var elem,5340            i = 0;5341        for ( ; (elem = elems[i]) != null; i++ ) {5342            jquery._data( elem, "globaleval", !refelements || jquery._data( refelements[i], "globaleval" ) );5343        }5344    }5345    function clonecopyevent( src, dest ) {5346        if ( dest.nodetype !== 1 || !jquery.hasdata( src ) ) {5347            return;5348        }5349        var type, i, l,5350            olddata = jquery._data( src ),5351            curdata = jquery._data( dest, olddata ),5352            events = olddata.events;5353        if ( events ) {5354            delete curdata.handle;5355            curdata.events = {};5356            for ( type in events ) {5357                for ( i = 0, l = events[ type ].length; i < l; i++ ) {5358                    jquery.event.add( dest, type, events[ type ][ i ] );5359                }5360            }5361        }5362        // make the cloned public data object a copy from the original5363        if ( curdata.data ) {5364            curdata.data = jquery.extend( {}, curdata.data );5365        }5366    }5367    function fixclonenodeissues( src, dest ) {5368        var nodename, e, data;5369        // we do not need to do anything for non-elements5370        if ( dest.nodetype !== 1 ) {5371            return;5372        }5373        nodename = dest.nodename.tolowercase();5374        // ie6-8 copies events bound via attachevent when using clonenode.5375        if ( !jquery.support.nocloneevent && dest[ jquery.expando ] ) {5376            data = jquery._data( dest );5377            for ( e in data.events ) {5378                jquery.removeevent( dest, e, data.handle );5379            }5380            // event data gets referenced instead of copied if the expando gets copied too5381            dest.removeattribute( jquery.expando );5382        }5383        // ie blanks contents when cloning scripts, and tries to evaluate newly-set text5384        if ( nodename === "script" && dest.text !== src.text ) {5385            disablescript( dest ).text = src.text;5386            restorescript( dest );5387            // ie6-10 improperly clones children of object elements using classid.5388            // ie10 throws nomodificationallowederror if parent is null, #12132.5389        } else if ( nodename === "object" ) {5390            if ( dest.parentnode ) {5391                dest.outerhtml = src.outerhtml;5392            }5393            // this path appears unavoidable for ie9. when cloning an object5394            // element in ie9, the outerhtml strategy above is not sufficient.5395            // if the src has innerhtml and the destination does not,5396            // copy the src.innerhtml into the dest.innerhtml. #103245397            if ( jquery.support.html5clone && ( src.innerhtml && !jquery.trim(dest.innerhtml) ) ) {5398                dest.innerhtml = src.innerhtml;5399            }5400        } else if ( nodename === "input" && manipulation_rcheckabletype.test( src.type ) ) {5401            // ie6-8 fails to persist the checked state of a cloned checkbox5402            // or radio button. worse, ie6-7 fail to give the cloned element5403            // a checked appearance if the defaultchecked value isn't also set5404            dest.defaultchecked = dest.checked = src.checked;5405            // ie6-7 get confused and end up setting the value of a cloned5406            // checkbox/radio button to an empty string instead of "on"5407            if ( dest.value !== src.value ) {5408                dest.value = src.value;5409            }5410            // ie6-8 fails to return the selected option to the default selected5411            // state when cloning options5412        } else if ( nodename === "option" ) {5413            dest.defaultselected = dest.selected = src.defaultselected;5414            // ie6-8 fails to set the defaultvalue to the correct value when5415            // cloning other types of input fields5416        } else if ( nodename === "input" || nodename === "textarea" ) {5417            dest.defaultvalue = src.defaultvalue;5418        }5419    }5420    jquery.each({5421        appendto: "append",5422        prependto: "prepend",5423        insertbefore: "before",5424        insertafter: "after",5425        replaceall: "replacewith"5426    }, function( name, original ) {5427        jquery.fn[ name ] = function( selector ) {5428            var elems,5429                i = 0,5430                ret = [],5431                insert = jquery( selector ),5432                last = insert.length - 1;5433            for ( ; i <= last; i++ ) {5434                elems = i === last ? this : this.clone(true);5435                jquery( insert[i] )[ original ]( elems );5436                // modern browsers can apply jquery collections as arrays, but oldie needs a .get()5437                core_push.apply( ret, elems.get() );5438            }5439            return this.pushstack( ret );5440        };5441    });5442    function getall( context, tag ) {5443        var elems, elem,5444            i = 0,5445            found = typeof context.getelementsbytagname !== core_strundefined ? context.getelementsbytagname( tag || "*" ) :5446                    typeof context.queryselectorall !== core_strundefined ? context.queryselectorall( tag || "*" ) :5447                undefined;5448        if ( !found ) {5449            for ( found = [], elems = context.childnodes || context; (elem = elems[i]) != null; i++ ) {5450                if ( !tag || jquery.nodename( elem, tag ) ) {5451                    found.push( elem );5452                } else {5453                    jquery.merge( found, getall( elem, tag ) );5454                }5455            }5456        }5457        return tag === undefined || tag && jquery.nodename( context, tag ) ?5458            jquery.merge( [ context ], found ) :5459            found;5460    }5461// used in buildfragment, fixes the defaultchecked property5462    function fixdefaultchecked( elem ) {5463        if ( manipulation_rcheckabletype.test( elem.type ) ) {5464            elem.defaultchecked = elem.checked;5465        }5466    }5467    jquery.extend({5468        clone: function( elem, dataandevents, deepdataandevents ) {5469            var destelements, node, clone, i, srcelements,5470                inpage = jquery.contains( elem.ownerdocument, elem );5471            if ( jquery.support.html5clone || jquery.isxmldoc(elem) || !rnoshimcache.test( "<" + elem.nodename + ">" ) ) {5472                clone = elem.clonenode( true );5473                // ie<=8 does not properly clone detached, unknown element nodes5474            } else {5475                fragmentdiv.innerhtml = elem.outerhtml;5476                fragmentdiv.removechild( clone = fragmentdiv.firstchild );5477            }5478            if ( (!jquery.support.nocloneevent || !jquery.support.noclonechecked) &&5479                (elem.nodetype === 1 || elem.nodetype === 11) && !jquery.isxmldoc(elem) ) {5480                // we eschew sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/25481                destelements = getall( clone );5482                srcelements = getall( elem );5483                // fix all ie cloning issues5484                for ( i = 0; (node = srcelements[i]) != null; ++i ) {5485                    // ensure that the destination node is not null; fixes #95875486                    if ( destelements[i] ) {5487                        fixclonenodeissues( node, destelements[i] );5488                    }5489                }5490            }5491            // copy the events from the original to the clone5492            if ( dataandevents ) {5493                if ( deepdataandevents ) {5494                    srcelements = srcelements || getall( elem );5495                    destelements = destelements || getall( clone );5496                    for ( i = 0; (node = srcelements[i]) != null; i++ ) {5497                        clonecopyevent( node, destelements[i] );5498                    }5499                } else {5500                    clonecopyevent( elem, clone );5501                }5502            }5503            // preserve script evaluation history5504            destelements = getall( clone, "script" );5505            if ( destelements.length > 0 ) {5506                setglobaleval( destelements, !inpage && getall( elem, "script" ) );5507            }5508            destelements = srcelements = node = null;5509            // return the cloned set5510            return clone;5511        },5512        buildfragment: function( elems, context, scripts, selection ) {5513            var j, elem, contains,5514                tmp, tag, tbody, wrap,5515                l = elems.length,5516            // ensure a safe fragment5517                safe = createsafefragment( context ),5518                nodes = [],5519                i = 0;5520            for ( ; i < l; i++ ) {5521                elem = elems[ i ];5522                if ( elem || elem === 0 ) {5523                    // add nodes directly5524                    if ( jquery.type( elem ) === "object" ) {5525                        jquery.merge( nodes, elem.nodetype ? [ elem ] : elem );5526                        // convert non-html into a text node5527                    } else if ( !rhtml.test( elem ) ) {5528                        nodes.push( context.createtextnode( elem ) );5529                        // convert html into dom nodes5530                    } else {5531                        tmp = tmp || safe.appendchild( context.createelement("div") );5532                        // deserialize a standard representation5533                        tag = ( rtagname.exec( elem ) || ["", ""] )[1].tolowercase();5534                        wrap = wrapmap[ tag ] || wrapmap._default;5535                        tmp.innerhtml = wrap[1] + elem.replace( rxhtmltag, "<$1></$2>" ) + wrap[2];5536                        // descend through wrappers to the right content5537                        j = wrap[0];5538                        while ( j-- ) {5539                            tmp = tmp.lastchild;5540                        }5541                        // manually add leading whitespace removed by ie5542                        if ( !jquery.support.leadingwhitespace && rleadingwhitespace.test( elem ) ) {5543                            nodes.push( context.createtextnode( rleadingwhitespace.exec( elem )[0] ) );5544                        }5545                        // remove ie's autoinserted <tbody> from table fragments5546                        if ( !jquery.support.tbody ) {5547                            // string was a <table>, *may* have spurious <tbody>5548                            elem = tag === "table" && !rtbody.test( elem ) ?5549                                tmp.firstchild :5550                                // string was a bare <thead> or <tfoot>5551                                    wrap[1] === "<table>" && !rtbody.test( elem ) ?5552                                tmp :5553                                0;5554                            j = elem && elem.childnodes.length;5555                            while ( j-- ) {5556                                if ( jquery.nodename( (tbody = elem.childnodes[j]), "tbody" ) && !tbody.childnodes.length ) {5557                                    elem.removechild( tbody );5558                                }5559                            }5560                        }5561                        jquery.merge( nodes, tmp.childnodes );5562                        // fix #12392 for webkit and ie > 95563                        tmp.textcontent = "";5564                        // fix #12392 for oldie5565                        while ( tmp.firstchild ) {5566                            tmp.removechild( tmp.firstchild );5567                        }5568                        // remember the top-level container for proper cleanup5569                        tmp = safe.lastchild;5570                    }5571                }5572            }5573            // fix #11356: clear elements from fragment5574            if ( tmp ) {5575                safe.removechild( tmp );5576            }5577            // reset defaultchecked for any radios and checkboxes5578            // about to be appended to the dom in ie 6/7 (#8060)5579            if ( !jquery.support.appendchecked ) {5580                jquery.grep( getall( nodes, "input" ), fixdefaultchecked );5581            }5582            i = 0;5583            while ( (elem = nodes[ i++ ]) ) {5584                // #4087 - if origin and destination elements are the same, and this is5585                // that element, do not do anything5586                if ( selection && jquery.inarray( elem, selection ) !== -1 ) {5587                    continue;5588                }5589                contains = jquery.contains( elem.ownerdocument, elem );5590                // append to fragment5591                tmp = getall( safe.appendchild( elem ), "script" );5592                // preserve script evaluation history5593                if ( contains ) {5594                    setglobaleval( tmp );5595                }5596                // capture executables5597                if ( scripts ) {5598                    j = 0;5599                    while ( (elem = tmp[ j++ ]) ) {5600                        if ( rscripttype.test( elem.type || "" ) ) {5601                            scripts.push( elem );5602                        }5603                    }5604                }5605            }5606            tmp = null;5607            return safe;5608        },5609        cleandata: function( elems, /* internal */ acceptdata ) {5610            var elem, type, id, data,5611                i = 0,5612                internalkey = jquery.expando,5613                cache = jquery.cache,5614                deleteexpando = jquery.support.deleteexpando,5615                special = jquery.event.special;5616            for ( ; (elem = elems[i]) != null; i++ ) {5617                if ( acceptdata || jquery.acceptdata( elem ) ) {5618                    id = elem[ internalkey ];5619                    data = id && cache[ id ];5620                    if ( data ) {5621                        if ( data.events ) {5622                            for ( type in data.events ) {5623                                if ( special[ type ] ) {5624                                    jquery.event.remove( elem, type );5625                                    // this is a shortcut to avoid jquery.event.remove's overhead5626                                } else {5627                                    jquery.removeevent( elem, type, data.handle );5628                                }5629                            }5630                        }5631                        // remove cache only if it was not already removed by jquery.event.remove5632                        if ( cache[ id ] ) {5633                            delete cache[ id ];5634                            // ie does not allow us to delete expando properties from nodes,5635                            // nor does it have a removeattribute function on document nodes;5636                            // we must handle all of these cases5637                            if ( deleteexpando ) {5638                                delete elem[ internalkey ];5639                            } else if ( typeof elem.removeattribute !== core_strundefined ) {5640                                elem.removeattribute( internalkey );5641                            } else {5642                                elem[ internalkey ] = null;5643                            }5644                            core_deletedids.push( id );5645                        }5646                    }5647                }5648            }5649        },5650        _evalurl: function( url ) {5651            return jquery.ajax({5652                url: url,5653                type: "get",5654                datatype: "script",5655                async: false,5656                global: false,5657                "throws": true5658            });5659        }5660    });5661    jquery.fn.extend({5662        wrapall: function( html ) {5663            if ( jquery.isfunction( html ) ) {5664                return this.each(function(i) {5665                    jquery(this).wrapall( html.call(this, i) );5666                });5667            }5668            if ( this[0] ) {5669                // the elements to wrap the target around5670                var wrap = jquery( html, this[0].ownerdocument ).eq(0).clone(true);5671                if ( this[0].parentnode ) {5672                    wrap.insertbefore( this[0] );5673                }5674                wrap.map(function() {5675                    var elem = this;5676                    while ( elem.firstchild && elem.firstchild.nodetype === 1 ) {5677                        elem = elem.firstchild;5678                    }5679                    return elem;5680                }).append( this );5681            }5682            return this;5683        },5684        wrapinner: function( html ) {5685            if ( jquery.isfunction( html ) ) {5686                return this.each(function(i) {5687                    jquery(this).wrapinner( html.call(this, i) );5688                });5689            }5690            return this.each(function() {5691                var self = jquery( this ),5692                    contents = self.contents();5693                if ( contents.length ) {5694                    contents.wrapall( html );5695                } else {5696                    self.append( html );5697                }5698            });5699        },5700        wrap: function( html ) {5701            var isfunction = jquery.isfunction( html );5702            return this.each(function(i) {5703                jquery( this ).wrapall( isfunction ? html.call(this, i) : html );5704            });5705        },5706        unwrap: function() {5707            return this.parent().each(function() {5708                if ( !jquery.nodename( this, "body" ) ) {5709                    jquery( this ).replacewith( this.childnodes );5710                }5711            }).end();5712        }5713    });5714    var iframe, getstyles, curcss,5715        ralpha = /alpha\([^)]*\)/i,5716        ropacity = /opacity\s*=\s*([^)]*)/,5717        rposition = /^(top|right|bottom|left)$/,5718    // swappable if display is none or starts with table except "table", "table-cell", or "table-caption"5719    // see here for display values: https://developer.mozilla.org/en-us/docs/css/display5720        rdisplayswap = /^(none|table(?!-c[ea]).+)/,5721        rmargin = /^margin/,5722        rnumsplit = new regexp( "^(" + core_pnum + ")(.*)$", "i" ),5723        rnumnonpx = new regexp( "^(" + core_pnum + ")(?!px)[a-z%]+$", "i" ),5724        rrelnum = new regexp( "^([+-])=(" + core_pnum + ")", "i" ),5725        elemdisplay = { body: "block" },5726        cssshow = { position: "absolute", visibility: "hidden", display: "block" },5727        cssnormaltransform = {5728            letterspacing: 0,5729            fontweight: 4005730        },5731        cssexpand = [ "top", "right", "bottom", "left" ],5732        cssprefixes = [ "webkit", "o", "moz", "ms" ];5733// return a css property mapped to a potentially vendor prefixed property5734    function vendorpropname( style, name ) {5735        // shortcut for names that are not vendor prefixed5736        if ( name in style ) {5737            return name;5738        }5739        // check for vendor prefixed names5740        var capname = name.charat(0).touppercase() + name.slice(1),5741            origname = name,5742            i = cssprefixes.length;5743        while ( i-- ) {5744            name = cssprefixes[ i ] + capname;5745            if ( name in style ) {5746                return name;5747            }5748        }5749        return origname;5750    }5751    function ishidden( elem, el ) {5752        // ishidden might be called from jquery#filter function;5753        // in that case, element will be second argument5754        elem = el || elem;5755        return jquery.css( elem, "display" ) === "none" || !jquery.contains( elem.ownerdocument, elem );5756    }5757    function showhide( elements, show ) {5758        var display, elem, hidden,5759            values = [],5760            index = 0,5761            length = elements.length;5762        for ( ; index < length; index++ ) {5763            elem = elements[ index ];5764            if ( !elem.style ) {5765                continue;5766            }5767            values[ index ] = jquery._data( elem, "olddisplay" );5768            display = elem.style.display;5769            if ( show ) {5770                // reset the inline display of this element to learn if it is5771                // being hidden by cascaded rules or not5772                if ( !values[ index ] && display === "none" ) {5773                    elem.style.display = "";5774                }5775                // set elements which have been overridden with display: none5776                // in a stylesheet to whatever the default browser style is5777                // for such an element5778                if ( elem.style.display === "" && ishidden( elem ) ) {5779                    values[ index ] = jquery._data( elem, "olddisplay", css_defaultdisplay(elem.nodename) );5780                }5781            } else {5782                if ( !values[ index ] ) {5783                    hidden = ishidden( elem );5784                    if ( display && display !== "none" || !hidden ) {5785                        jquery._data( elem, "olddisplay", hidden ? display : jquery.css( elem, "display" ) );5786                    }5787                }5788            }5789        }5790        // set the display of most of the elements in a second loop5791        // to avoid the constant reflow5792        for ( index = 0; index < length; index++ ) {5793            elem = elements[ index ];5794            if ( !elem.style ) {5795                continue;5796            }5797            if ( !show || elem.style.display === "none" || elem.style.display === "" ) {5798                elem.style.display = show ? values[