Changeset 22176


Ignore:
Timestamp:
04/12/13 21:59:09 (7 years ago)
Author:
rvelices
Message:

upgrade jquery to 1.9.1

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

Legend:

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

    r19682 r22176  
    11/*! 
    2  * jQuery JavaScript Library v1.8.3 
     2 * jQuery JavaScript Library v1.9.1 
    33 * http://jquery.com/ 
    44 * 
     
    66 * http://sizzlejs.com/ 
    77 * 
    8  * Copyright 2012 jQuery Foundation and other contributors 
     8 * Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors 
    99 * Released under the MIT license 
    1010 * http://jquery.org/license 
    1111 * 
    12  * Date: Tue Nov 13 2012 08:20:33 GMT-0500 (Eastern Standard Time) 
     12 * Date: 2013-2-4 
    1313 */ 
    1414(function( window, undefined ) { 
     15 
     16// Can't do this because several apps including ASP.NET trace 
     17// the stack via arguments.caller.callee and Firefox dies if 
     18// you try to trace through "use strict" call chains. (#13335) 
     19// Support: Firefox 18+ 
     20//"use strict"; 
    1521var 
     22        // The deferred used on DOM ready 
     23        readyList, 
     24 
    1625        // A central reference to the root jQuery(document) 
    1726        rootjQuery, 
    1827 
    19         // The deferred used on DOM ready 
    20         readyList, 
     28        // Support: IE<9 
     29        // For `typeof node.method` instead of `node.method !== undefined` 
     30        core_strundefined = typeof undefined, 
    2131 
    2232        // Use the correct document accordingly with window argument (sandbox) 
    2333        document = window.document, 
    2434        location = window.location, 
    25         navigator = window.navigator, 
    2635 
    2736        // Map over jQuery in case of overwrite 
     
    3140        _$ = window.$, 
    3241 
     42        // [[Class]] -> type pairs 
     43        class2type = {}, 
     44 
     45        // List of deleted data cache ids, so we can reuse them 
     46        core_deletedIds = [], 
     47 
     48        core_version = "1.9.1", 
     49 
    3350        // Save a reference to some core methods 
    34         core_push = Array.prototype.push, 
    35         core_slice = Array.prototype.slice, 
    36         core_indexOf = Array.prototype.indexOf, 
    37         core_toString = Object.prototype.toString, 
    38         core_hasOwn = Object.prototype.hasOwnProperty, 
    39         core_trim = String.prototype.trim, 
     51        core_concat = core_deletedIds.concat, 
     52        core_push = core_deletedIds.push, 
     53        core_slice = core_deletedIds.slice, 
     54        core_indexOf = core_deletedIds.indexOf, 
     55        core_toString = class2type.toString, 
     56        core_hasOwn = class2type.hasOwnProperty, 
     57        core_trim = core_version.trim, 
    4058 
    4159        // Define a local copy of jQuery 
     
    4664 
    4765        // Used for matching numbers 
    48         core_pnum = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source, 
    49  
    50         // Used for detecting and trimming whitespace 
    51         core_rnotwhite = /\S/, 
    52         core_rspace = /\s+/, 
     66        core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source, 
     67 
     68        // Used for splitting on whitespace 
     69        core_rnotwhite = /\S+/g, 
    5370 
    5471        // Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE) 
     
    5774        // A simple way to check for HTML strings 
    5875        // Prioritize #id over <tag> to avoid XSS via location.hash (#9521) 
    59         rquickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/, 
     76        // Strict HTML recognition (#11290: must start with <) 
     77        rquickExpr = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/, 
    6078 
    6179        // Match a standalone tag 
     
    6684        rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g, 
    6785        rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g, 
    68         rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d\d*\.|)\d+(?:[eE][\-+]?\d+|)/g, 
     86        rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g, 
    6987 
    7088        // Matches dashed string for camelizing 
     
    7492        // Used by jQuery.camelCase as callback to replace() 
    7593        fcamelCase = function( all, letter ) { 
    76                 return ( letter + "" ).toUpperCase(); 
    77         }, 
    78  
    79         // The ready event handler and self cleanup method 
    80         DOMContentLoaded = function() { 
     94                return letter.toUpperCase(); 
     95        }, 
     96 
     97        // The ready event handler 
     98        completed = function( event ) { 
     99 
     100                // readyState === "complete" is good enough for us to call the dom ready in oldIE 
     101                if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) { 
     102                        detach(); 
     103                        jQuery.ready(); 
     104                } 
     105        }, 
     106        // Clean-up method for dom ready events 
     107        detach = function() { 
    81108                if ( document.addEventListener ) { 
    82                         document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false ); 
    83                         jQuery.ready(); 
    84                 } else if ( document.readyState === "complete" ) { 
    85                         // we're here because readyState === "complete" in oldIE 
    86                         // which is good enough for us to call the dom ready! 
    87                         document.detachEvent( "onreadystatechange", DOMContentLoaded ); 
    88                         jQuery.ready(); 
    89                 } 
    90         }, 
    91  
    92         // [[Class]] -> type pairs 
    93         class2type = {}; 
     109                        document.removeEventListener( "DOMContentLoaded", completed, false ); 
     110                        window.removeEventListener( "load", completed, false ); 
     111 
     112                } else { 
     113                        document.detachEvent( "onreadystatechange", completed ); 
     114                        window.detachEvent( "onload", completed ); 
     115                } 
     116        }; 
    94117 
    95118jQuery.fn = jQuery.prototype = { 
     119        // The current version of jQuery being used 
     120        jquery: core_version, 
     121 
    96122        constructor: jQuery, 
    97123        init: function( selector, context, rootjQuery ) { 
    98                 var match, elem, ret, doc; 
    99  
    100                 // Handle $(""), $(null), $(undefined), $(false) 
     124                var match, elem; 
     125 
     126                // HANDLE: $(""), $(null), $(undefined), $(false) 
    101127                if ( !selector ) { 
    102                         return this; 
    103                 } 
    104  
    105                 // Handle $(DOMElement) 
    106                 if ( selector.nodeType ) { 
    107                         this.context = this[0] = selector; 
    108                         this.length = 1; 
    109128                        return this; 
    110129                } 
     
    126145                                if ( match[1] ) { 
    127146                                        context = context instanceof jQuery ? context[0] : context; 
    128                                         doc = ( context && context.nodeType ? context.ownerDocument || context : document ); 
    129147 
    130148                                        // scripts is true for back-compat 
    131                                         selector = jQuery.parseHTML( match[1], doc, true ); 
     149                                        jQuery.merge( this, jQuery.parseHTML( 
     150                                                match[1], 
     151                                                context && context.nodeType ? context.ownerDocument || context : document, 
     152                                                true 
     153                                        ) ); 
     154 
     155                                        // HANDLE: $(html, props) 
    132156                                        if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) { 
    133                                                 this.attr.call( selector, context, true ); 
     157                                                for ( match in context ) { 
     158                                                        // Properties of context are called as methods if possible 
     159                                                        if ( jQuery.isFunction( this[ match ] ) ) { 
     160                                                                this[ match ]( context[ match ] ); 
     161 
     162                                                        // ...and otherwise set as attributes 
     163                                                        } else { 
     164                                                                this.attr( match, context[ match ] ); 
     165                                                        } 
     166                                                } 
    134167                                        } 
    135168 
    136                                         return jQuery.merge( this, selector ); 
     169                                        return this; 
    137170 
    138171                                // HANDLE: $(#id) 
     
    169202                        } 
    170203 
     204                // HANDLE: $(DOMElement) 
     205                } else if ( selector.nodeType ) { 
     206                        this.context = this[0] = selector; 
     207                        this.length = 1; 
     208                        return this; 
     209 
    171210                // HANDLE: $(function) 
    172211                // Shortcut for document ready 
     
    186225        selector: "", 
    187226 
    188         // The current version of jQuery being used 
    189         jquery: "1.8.3", 
    190  
    191227        // The default length of a jQuery object is 0 
    192228        length: 0, 
     
    215251        // Take an array of elements and push it onto the stack 
    216252        // (returning the new matched element set) 
    217         pushStack: function( elems, name, selector ) { 
     253        pushStack: function( elems ) { 
    218254 
    219255                // Build a new jQuery matched element set 
     
    222258                // Add the old object onto the stack (as a reference) 
    223259                ret.prevObject = this; 
    224  
    225260                ret.context = this.context; 
    226  
    227                 if ( name === "find" ) { 
    228                         ret.selector = this.selector + ( this.selector ? " " : "" ) + selector; 
    229                 } else if ( name ) { 
    230                         ret.selector = this.selector + "." + name + "(" + selector + ")"; 
    231                 } 
    232261 
    233262                // Return the newly-formed element set 
     
    249278        }, 
    250279 
    251         eq: function( i ) { 
    252                 i = +i; 
    253                 return i === -1 ? 
    254                         this.slice( i ) : 
    255                         this.slice( i, i + 1 ); 
     280        slice: function() { 
     281                return this.pushStack( core_slice.apply( this, arguments ) ); 
    256282        }, 
    257283 
     
    264290        }, 
    265291 
    266         slice: function() { 
    267                 return this.pushStack( core_slice.apply( this, arguments ), 
    268                         "slice", core_slice.call(arguments).join(",") ); 
     292        eq: function( i ) { 
     293                var len = this.length, 
     294                        j = +i + ( i < 0 ? len : 0 ); 
     295                return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] ); 
    269296        }, 
    270297 
     
    290317 
    291318jQuery.extend = jQuery.fn.extend = function() { 
    292         var options, name, src, copy, copyIsArray, clone, 
     319        var src, copyIsArray, copy, name, options, clone, 
    293320                target = arguments[0] || {}, 
    294321                i = 1, 
     
    392419                // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). 
    393420                if ( !document.body ) { 
    394                         return setTimeout( jQuery.ready, 1 ); 
     421                        return setTimeout( jQuery.ready ); 
    395422                } 
    396423 
     
    432459 
    433460        type: function( obj ) { 
    434                 return obj == null ? 
    435                         String( obj ) : 
    436                         class2type[ core_toString.call(obj) ] || "object"; 
     461                if ( obj == null ) { 
     462                        return String( obj ); 
     463                } 
     464                return typeof obj === "object" || typeof obj === "function" ? 
     465                        class2type[ core_toString.call(obj) ] || "object" : 
     466                        typeof obj; 
    437467        }, 
    438468 
     
    480510        // data: string of html 
    481511        // context (optional): If specified, the fragment will be created in this context, defaults to document 
    482         // scripts (optional): If true, will include scripts passed in the html string 
    483         parseHTML: function( data, context, scripts ) { 
    484                 var parsed; 
     512        // keepScripts (optional): If true, will include scripts passed in the html string 
     513        parseHTML: function( data, context, keepScripts ) { 
    485514                if ( !data || typeof data !== "string" ) { 
    486515                        return null; 
    487516                } 
    488517                if ( typeof context === "boolean" ) { 
    489                         scripts = context; 
    490                         context = 0; 
     518                        keepScripts = context; 
     519                        context = false; 
    491520                } 
    492521                context = context || document; 
    493522 
     523                var parsed = rsingleTag.exec( data ), 
     524                        scripts = !keepScripts && []; 
     525 
    494526                // Single tag 
    495                 if ( (parsed = rsingleTag.exec( data )) ) { 
     527                if ( parsed ) { 
    496528                        return [ context.createElement( parsed[1] ) ]; 
    497529                } 
    498530 
    499                 parsed = jQuery.buildFragment( [ data ], context, scripts ? null : [] ); 
    500                 return jQuery.merge( [], 
    501                         (parsed.cacheable ? jQuery.clone( parsed.fragment ) : parsed.fragment).childNodes ); 
     531                parsed = jQuery.buildFragment( [ data ], context, scripts ); 
     532                if ( scripts ) { 
     533                        jQuery( scripts ).remove(); 
     534                } 
     535                return jQuery.merge( [], parsed.childNodes ); 
    502536        }, 
    503537 
    504538        parseJSON: function( data ) { 
    505                 if ( !data || typeof data !== "string") { 
    506                         return null; 
    507                 } 
    508  
    509                 // Make sure leading/trailing whitespace is removed (IE can't handle it) 
    510                 data = jQuery.trim( data ); 
    511  
    512539                // Attempt to parse using the native JSON parser first 
    513540                if ( window.JSON && window.JSON.parse ) { 
     
    515542                } 
    516543 
    517                 // Make sure the incoming data is actual JSON 
    518                 // Logic borrowed from http://json.org/json2.js 
    519                 if ( rvalidchars.test( data.replace( rvalidescape, "@" ) 
    520                         .replace( rvalidtokens, "]" ) 
    521                         .replace( rvalidbraces, "")) ) { 
    522  
    523                         return ( new Function( "return " + data ) )(); 
    524  
    525                 } 
     544                if ( data === null ) { 
     545                        return data; 
     546                } 
     547 
     548                if ( typeof data === "string" ) { 
     549 
     550                        // Make sure leading/trailing whitespace is removed (IE can't handle it) 
     551                        data = jQuery.trim( data ); 
     552 
     553                        if ( data ) { 
     554                                // Make sure the incoming data is actual JSON 
     555                                // Logic borrowed from http://json.org/json2.js 
     556                                if ( rvalidchars.test( data.replace( rvalidescape, "@" ) 
     557                                        .replace( rvalidtokens, "]" ) 
     558                                        .replace( rvalidbraces, "")) ) { 
     559 
     560                                        return ( new Function( "return " + data ) )(); 
     561                                } 
     562                        } 
     563                } 
     564 
    526565                jQuery.error( "Invalid JSON: " + data ); 
    527566        }, 
     
    557596        // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context 
    558597        globalEval: function( data ) { 
    559                 if ( data && core_rnotwhite.test( data ) ) { 
     598                if ( data && jQuery.trim( data ) ) { 
    560599                        // We use execScript on Internet Explorer 
    561600                        // We use an anonymous function so that context is window 
     
    579618        // args is for internal usage only 
    580619        each: function( obj, callback, args ) { 
    581                 var name, 
     620                var value, 
    582621                        i = 0, 
    583622                        length = obj.length, 
    584                         isObj = length === undefined || jQuery.isFunction( obj ); 
     623                        isArray = isArraylike( obj ); 
    585624 
    586625                if ( args ) { 
    587                         if ( isObj ) { 
    588                                 for ( name in obj ) { 
    589                                         if ( callback.apply( obj[ name ], args ) === false ) { 
     626                        if ( isArray ) { 
     627                                for ( ; i < length; i++ ) { 
     628                                        value = callback.apply( obj[ i ], args ); 
     629 
     630                                        if ( value === false ) { 
    590631                                                break; 
    591632                                        } 
    592633                                } 
    593634                        } else { 
    594                                 for ( ; i < length; ) { 
    595                                         if ( callback.apply( obj[ i++ ], args ) === false ) { 
     635                                for ( i in obj ) { 
     636                                        value = callback.apply( obj[ i ], args ); 
     637 
     638                                        if ( value === false ) { 
    596639                                                break; 
    597640                                        } 
     
    601644                // A special, fast, case for the most common use of each 
    602645                } else { 
    603                         if ( isObj ) { 
    604                                 for ( name in obj ) { 
    605                                         if ( callback.call( obj[ name ], name, obj[ name ] ) === false ) { 
     646                        if ( isArray ) { 
     647                                for ( ; i < length; i++ ) { 
     648                                        value = callback.call( obj[ i ], i, obj[ i ] ); 
     649 
     650                                        if ( value === false ) { 
    606651                                                break; 
    607652                                        } 
    608653                                } 
    609654                        } else { 
    610                                 for ( ; i < length; ) { 
    611                                         if ( callback.call( obj[ i ], i, obj[ i++ ] ) === false ) { 
     655                                for ( i in obj ) { 
     656                                        value = callback.call( obj[ i ], i, obj[ i ] ); 
     657 
     658                                        if ( value === false ) { 
    612659                                                break; 
    613660                                        } 
     
    636683        // results is for internal usage only 
    637684        makeArray: function( arr, results ) { 
    638                 var type, 
    639                         ret = results || []; 
     685                var ret = results || []; 
    640686 
    641687                if ( arr != null ) { 
    642                         // The window, strings (and functions) also have 'length' 
    643                         // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930 
    644                         type = jQuery.type( arr ); 
    645  
    646                         if ( arr.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( arr ) ) { 
     688                        if ( isArraylike( Object(arr) ) ) { 
     689                                jQuery.merge( ret, 
     690                                        typeof arr === "string" ? 
     691                                        [ arr ] : arr 
     692                                ); 
     693                        } else { 
    647694                                core_push.call( ret, arr ); 
    648                         } else { 
    649                                 jQuery.merge( ret, arr ); 
    650695                        } 
    651696                } 
     
    685730                                first[ i++ ] = second[ j ]; 
    686731                        } 
    687  
    688732                } else { 
    689733                        while ( second[j] !== undefined ) { 
     
    718762        // arg is for internal usage only 
    719763        map: function( elems, callback, arg ) { 
    720                 var value, key, 
    721                         ret = [], 
     764                var value, 
    722765                        i = 0, 
    723766                        length = elems.length, 
    724                         // jquery objects are treated as arrays 
    725                         isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ; 
     767                        isArray = isArraylike( elems ), 
     768                        ret = []; 
    726769 
    727770                // Go through the array, translating each of the items to their 
     
    737780                // Go through every key on the object, 
    738781                } else { 
    739                         for ( key in elems ) { 
    740                                 value = callback( elems[ key ], key, arg ); 
     782                        for ( i in elems ) { 
     783                                value = callback( elems[ i ], i, arg ); 
    741784 
    742785                                if ( value != null ) { 
     
    747790 
    748791                // Flatten any nested arrays 
    749                 return ret.concat.apply( [], ret ); 
     792                return core_concat.apply( [], ret ); 
    750793        }, 
    751794 
     
    756799        // arguments. 
    757800        proxy: function( fn, context ) { 
    758                 var tmp, args, proxy; 
     801                var args, proxy, tmp; 
    759802 
    760803                if ( typeof context === "string" ) { 
     
    773816                args = core_slice.call( arguments, 2 ); 
    774817                proxy = function() { 
    775                         return fn.apply( context, args.concat( core_slice.call( arguments ) ) ); 
     818                        return fn.apply( context || this, args.concat( core_slice.call( arguments ) ) ); 
    776819                }; 
    777820 
     
    784827        // Multifunctional method to get and set values of a collection 
    785828        // The value/s can optionally be executed if it's a function 
    786         access: function( elems, fn, key, value, chainable, emptyGet, pass ) { 
    787                 var exec, 
    788                         bulk = key == null, 
    789                         i = 0, 
    790                         length = elems.length; 
     829        access: function( elems, fn, key, value, chainable, emptyGet, raw ) { 
     830                var i = 0, 
     831                        length = elems.length, 
     832                        bulk = key == null; 
    791833 
    792834                // Sets many values 
    793                 if ( key && typeof key === "object" ) { 
     835                if ( jQuery.type( key ) === "object" ) { 
     836                        chainable = true; 
    794837                        for ( i in key ) { 
    795                                 jQuery.access( elems, fn, i, key[i], 1, emptyGet, value ); 
    796                         } 
    797                         chainable = 1; 
     838                                jQuery.access( elems, fn, i, key[i], true, emptyGet, raw ); 
     839                        } 
    798840 
    799841                // Sets one value 
    800842                } else if ( value !== undefined ) { 
    801                         // Optionally, function values get executed if exec is true 
    802                         exec = pass === undefined && jQuery.isFunction( value ); 
     843                        chainable = true; 
     844 
     845                        if ( !jQuery.isFunction( value ) ) { 
     846                                raw = true; 
     847                        } 
    803848 
    804849                        if ( bulk ) { 
    805                                 // Bulk operations only iterate when executing function values 
    806                                 if ( exec ) { 
    807                                         exec = fn; 
    808                                         fn = function( elem, key, value ) { 
    809                                                 return exec.call( jQuery( elem ), value ); 
    810                                         }; 
    811  
    812                                 // Otherwise they run against the entire set 
    813                                 } else { 
     850                                // Bulk operations run against the entire set 
     851                                if ( raw ) { 
    814852                                        fn.call( elems, value ); 
    815853                                        fn = null; 
     854 
     855                                // ...except when executing function values 
     856                                } else { 
     857                                        bulk = fn; 
     858                                        fn = function( elem, key, value ) { 
     859                                                return bulk.call( jQuery( elem ), value ); 
     860                                        }; 
    816861                                } 
    817862                        } 
    818863 
    819864                        if ( fn ) { 
    820                                 for (; i < length; i++ ) { 
    821                                         fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass ); 
    822                                 } 
    823                         } 
    824  
    825                         chainable = 1; 
     865                                for ( ; i < length; i++ ) { 
     866                                        fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) ); 
     867                                } 
     868                        } 
    826869                } 
    827870 
     
    850893                if ( document.readyState === "complete" ) { 
    851894                        // Handle it asynchronously to allow scripts the opportunity to delay ready 
    852                         setTimeout( jQuery.ready, 1 ); 
     895                        setTimeout( jQuery.ready ); 
    853896 
    854897                // Standards-based browsers support DOMContentLoaded 
    855898                } else if ( document.addEventListener ) { 
    856899                        // Use the handy event callback 
    857                         document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false ); 
     900                        document.addEventListener( "DOMContentLoaded", completed, false ); 
    858901 
    859902                        // A fallback to window.onload, that will always work 
    860                         window.addEventListener( "load", jQuery.ready, false ); 
     903                        window.addEventListener( "load", completed, false ); 
    861904 
    862905                // If IE event model is used 
    863906                } else { 
    864907                        // Ensure firing before onload, maybe late but safe also for iframes 
    865                         document.attachEvent( "onreadystatechange", DOMContentLoaded ); 
     908                        document.attachEvent( "onreadystatechange", completed ); 
    866909 
    867910                        // A fallback to window.onload, that will always work 
    868                         window.attachEvent( "onload", jQuery.ready ); 
     911                        window.attachEvent( "onload", completed ); 
    869912 
    870913                        // If IE and not a frame 
     
    888931                                                } 
    889932 
     933                                                // detach all dom ready events 
     934                                                detach(); 
     935 
    890936                                                // and execute any waiting functions 
    891937                                                jQuery.ready(); 
     
    899945 
    900946// Populate the class2type map 
    901 jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) { 
     947jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) { 
    902948        class2type[ "[object " + name + "]" ] = name.toLowerCase(); 
    903949}); 
     950 
     951function isArraylike( obj ) { 
     952        var length = obj.length, 
     953                type = jQuery.type( obj ); 
     954 
     955        if ( jQuery.isWindow( obj ) ) { 
     956                return false; 
     957        } 
     958 
     959        if ( obj.nodeType === 1 && length ) { 
     960                return true; 
     961        } 
     962 
     963        return type === "array" || type !== "function" && 
     964                ( length === 0 || 
     965                typeof length === "number" && length > 0 && ( length - 1 ) in obj ); 
     966} 
    904967 
    905968// All jQuery objects should point back to these 
     
    911974function createOptions( options ) { 
    912975        var object = optionsCache[ options ] = {}; 
    913         jQuery.each( options.split( core_rspace ), function( _, flag ) { 
     976        jQuery.each( options.match( core_rnotwhite ) || [], function( _, flag ) { 
    914977                object[ flag ] = true; 
    915978        }); 
     
    9471010                jQuery.extend( {}, options ); 
    9481011 
    949         var // Last fire value (for non-forgettable lists) 
     1012        var // Flag to know if list is currently firing 
     1013                firing, 
     1014                // Last fire value (for non-forgettable lists) 
    9501015                memory, 
    9511016                // Flag to know if list was already fired 
    9521017                fired, 
    953                 // Flag to know if list is currently firing 
    954                 firing, 
    955                 // First callback to fire (used internally by add and fireWith) 
    956                 firingStart, 
    9571018                // End of the loop when firing 
    9581019                firingLength, 
    9591020                // Index of currently firing callback (modified by remove if needed) 
    9601021                firingIndex, 
     1022                // First callback to fire (used internally by add and fireWith) 
     1023                firingStart, 
    9611024                // Actual callback list 
    9621025                list = [], 
     
    10441107                                return this; 
    10451108                        }, 
    1046                         // Control if a given callback is in the list 
     1109                        // Check if a given callback is in the list. 
     1110                        // If no argument is given, return whether or not list has callbacks attached. 
    10471111                        has: function( fn ) { 
    1048                                 return jQuery.inArray( fn, list ) > -1; 
     1112                                return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length ); 
    10491113                        }, 
    10501114                        // Remove all callbacks from the list 
     
    11231187                                                jQuery.each( tuples, function( i, tuple ) { 
    11241188                                                        var action = tuple[ 0 ], 
    1125                                                                 fn = fns[ i ]; 
     1189                                                                fn = jQuery.isFunction( fns[ i ] ) && fns[ i ]; 
    11261190                                                        // deferred[ done | fail | progress ] for forwarding actions to newDefer 
    1127                                                         deferred[ tuple[1] ]( jQuery.isFunction( fn ) ? 
    1128                                                                 function() { 
    1129                                                                         var returned = fn.apply( this, arguments ); 
    1130                                                                         if ( returned && jQuery.isFunction( returned.promise ) ) { 
    1131                                                                                 returned.promise() 
    1132                                                                                         .done( newDefer.resolve ) 
    1133                                                                                         .fail( newDefer.reject ) 
    1134                                                                                         .progress( newDefer.notify ); 
    1135                                                                         } else { 
    1136                                                                                 newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] ); 
    1137                                                                         } 
    1138                                                                 } : 
    1139                                                                 newDefer[ action ] 
    1140                                                         ); 
     1191                                                        deferred[ tuple[1] ](function() { 
     1192                                                                var returned = fn && fn.apply( this, arguments ); 
     1193                                                                if ( returned && jQuery.isFunction( returned.promise ) ) { 
     1194                                                                        returned.promise() 
     1195                                                                                .done( newDefer.resolve ) 
     1196                                                                                .fail( newDefer.reject ) 
     1197                                                                                .progress( newDefer.notify ); 
     1198                                                                } else { 
     1199                                                                        newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments ); 
     1200                                                                } 
     1201                                                        }); 
    11411202                                                }); 
    11421203                                                fns = null; 
     
    11721233                        } 
    11731234 
    1174                         // deferred[ resolve | reject | notify ] = list.fire 
    1175                         deferred[ tuple[0] ] = list.fire; 
     1235                        // deferred[ resolve | reject | notify ] 
     1236                        deferred[ tuple[0] ] = function() { 
     1237                                deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments ); 
     1238                                return this; 
     1239                        }; 
    11761240                        deferred[ tuple[0] + "With" ] = list.fireWith; 
    11771241                }); 
     
    12431307jQuery.support = (function() { 
    12441308 
    1245         var support, 
    1246                 all, 
    1247                 a, 
    1248                 select, 
    1249                 opt, 
    1250                 input, 
    1251                 fragment, 
    1252                 eventName, 
    1253                 i, 
    1254                 isSupported, 
    1255                 clickFn, 
     1309        var support, all, a, 
     1310                input, select, fragment, 
     1311                opt, eventName, isSupported, i, 
    12561312                div = document.createElement("div"); 
    12571313 
     
    12741330        a.style.cssText = "top:1px;float:left;opacity:.5"; 
    12751331        support = { 
     1332                // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7) 
     1333                getSetAttribute: div.className !== "t", 
     1334 
    12761335                // IE strips leading whitespace when .innerHTML is used 
    1277                 leadingWhitespace: ( div.firstChild.nodeType === 3 ), 
     1336                leadingWhitespace: div.firstChild.nodeType === 3, 
    12781337 
    12791338                // Make sure that tbody elements aren't automatically inserted 
     
    12911350                // Make sure that URLs aren't manipulated 
    12921351                // (IE normalizes it by default) 
    1293                 hrefNormalized: ( a.getAttribute("href") === "/a" ), 
     1352                hrefNormalized: a.getAttribute("href") === "/a", 
    12941353 
    12951354                // Make sure that element opacity exists 
     
    13021361                cssFloat: !!a.style.cssFloat, 
    13031362 
    1304                 // Make sure that if no value is specified for a checkbox 
    1305                 // that it defaults to "on". 
    1306                 // (WebKit defaults to "" instead) 
    1307                 checkOn: ( input.value === "on" ), 
     1363                // Check the default checkbox/radio value ("" on WebKit; "on" elsewhere) 
     1364                checkOn: !!input.value, 
    13081365 
    13091366                // Make sure that a selected-by-default option has a working selected property. 
     
    13111368                optSelected: opt.selected, 
    13121369 
    1313                 // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7) 
    1314                 getSetAttribute: div.className !== "t", 
    1315  
    13161370                // Tests for enctype support on a form (#6743) 
    13171371                enctype: !!document.createElement("form").enctype, 
     
    13221376 
    13231377                // jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode 
    1324                 boxModel: ( document.compatMode === "CSS1Compat" ), 
     1378                boxModel: document.compatMode === "CSS1Compat", 
    13251379 
    13261380                // Will be defined later 
    1327                 submitBubbles: true, 
    1328                 changeBubbles: true, 
    1329                 focusinBubbles: false, 
    13301381                deleteExpando: true, 
    13311382                noCloneEvent: true, 
     
    13461397        support.optDisabled = !opt.disabled; 
    13471398 
    1348         // Test to see if it's possible to delete an expando from an element 
    1349         // Fails in Internet Explorer 
     1399        // Support: IE<9 
    13501400        try { 
    13511401                delete div.test; 
     
    13541404        } 
    13551405 
    1356         if ( !div.addEventListener && div.attachEvent && div.fireEvent ) { 
    1357                 div.attachEvent( "onclick", clickFn = function() { 
    1358                         // Cloning a node shouldn't copy over any 
    1359                         // bound event handlers (IE does this) 
    1360                         support.noCloneEvent = false; 
    1361                 }); 
    1362                 div.cloneNode( true ).fireEvent("onclick"); 
    1363                 div.detachEvent( "onclick", clickFn ); 
    1364         } 
    1365  
    1366         // Check if a radio maintains its value 
    1367         // after being appended to the DOM 
     1406        // Check if we can trust getAttribute("value") 
    13681407        input = document.createElement("input"); 
     1408        input.setAttribute( "value", "" ); 
     1409        support.input = input.getAttribute( "value" ) === ""; 
     1410 
     1411        // Check if an input maintains its value after becoming a radio 
    13691412        input.value = "t"; 
    13701413        input.setAttribute( "type", "radio" ); 
    13711414        support.radioValue = input.value === "t"; 
    13721415 
    1373         input.setAttribute( "checked", "checked" ); 
    1374  
    13751416        // #11217 - WebKit loses check when the name is after the checked attribute 
     1417        input.setAttribute( "checked", "t" ); 
    13761418        input.setAttribute( "name", "t" ); 
    13771419 
    1378         div.appendChild( input ); 
    13791420        fragment = document.createDocumentFragment(); 
    1380         fragment.appendChild( div.lastChild ); 
    1381  
    1382         // WebKit doesn't clone checked state correctly in fragments 
    1383         support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked; 
     1421        fragment.appendChild( input ); 
    13841422 
    13851423        // Check if a disconnected checkbox will retain its checked 
     
    13871425        support.appendChecked = input.checked; 
    13881426 
    1389         fragment.removeChild( input ); 
    1390         fragment.appendChild( div ); 
    1391  
    1392         // Technique from Juriy Zaytsev 
    1393         // http://perfectionkills.com/detecting-event-support-without-browser-sniffing/ 
    1394         // We only care about the case where non-standard event systems 
    1395         // are used, namely in IE. Short-circuiting here helps us to 
    1396         // avoid an eval call (in setAttribute) which can cause CSP 
    1397         // to go haywire. See: https://developer.mozilla.org/en/Security/CSP 
     1427        // WebKit doesn't clone checked state correctly in fragments 
     1428        support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked; 
     1429 
     1430        // Support: IE<9 
     1431        // Opera does not clone events (and typeof div.attachEvent === undefined). 
     1432        // IE9-10 clones events bound via attachEvent, but they don't trigger with .click() 
    13981433        if ( div.attachEvent ) { 
    1399                 for ( i in { 
    1400                         submit: true, 
    1401                         change: true, 
    1402                         focusin: true 
    1403                 }) { 
    1404                         eventName = "on" + i; 
    1405                         isSupported = ( eventName in div ); 
    1406                         if ( !isSupported ) { 
    1407                                 div.setAttribute( eventName, "return;" ); 
    1408                                 isSupported = ( typeof div[ eventName ] === "function" ); 
    1409                         } 
    1410                         support[ i + "Bubbles" ] = isSupported; 
    1411                 } 
    1412         } 
     1434                div.attachEvent( "onclick", function() { 
     1435                        support.noCloneEvent = false; 
     1436                }); 
     1437 
     1438                div.cloneNode( true ).click(); 
     1439        } 
     1440 
     1441        // Support: IE<9 (lack submit/change bubble), Firefox 17+ (lack focusin event) 
     1442        // Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP), test/csp.php 
     1443        for ( i in { submit: true, change: true, focusin: true }) { 
     1444                div.setAttribute( eventName = "on" + i, "t" ); 
     1445 
     1446                support[ i + "Bubbles" ] = eventName in window || div.attributes[ eventName ].expando === false; 
     1447        } 
     1448 
     1449        div.style.backgroundClip = "content-box"; 
     1450        div.cloneNode( true ).style.backgroundClip = ""; 
     1451        support.clearCloneStyle = div.style.backgroundClip === "content-box"; 
    14131452 
    14141453        // Run tests that need a body at doc ready 
    14151454        jQuery(function() { 
    1416                 var container, div, tds, marginDiv, 
    1417                         divReset = "padding:0;margin:0;border:0;display:block;overflow:hidden;", 
     1455                var container, marginDiv, tds, 
     1456                        divReset = "padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;", 
    14181457                        body = document.getElementsByTagName("body")[0]; 
    14191458 
     
    14241463 
    14251464                container = document.createElement("div"); 
    1426                 container.style.cssText = "visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px"; 
    1427                 body.insertBefore( container, body.firstChild ); 
    1428  
    1429                 // Construct the test element 
    1430                 div = document.createElement("div"); 
    1431                 container.appendChild( div ); 
    1432  
     1465                container.style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px"; 
     1466 
     1467                body.appendChild( container ).appendChild( div ); 
     1468 
     1469                // Support: IE8 
    14331470                // Check if table cells still have offsetWidth/Height when they are set 
    14341471                // to display:none and there are still other visible table cells in a 
     
    14371474                // display:none (it is still safe to use offsets if a parent element is 
    14381475                // hidden; don safety goggles and see bug #4512 for more information). 
    1439                 // (only IE 8 fails this test) 
    14401476                div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>"; 
    14411477                tds = div.getElementsByTagName("td"); 
     
    14461482                tds[ 1 ].style.display = "none"; 
    14471483 
     1484                // Support: IE8 
    14481485                // Check if empty table cells still have offsetWidth/Height 
    1449                 // (IE <= 8 fail this test) 
    14501486                support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 ); 
    14511487 
     
    14561492                support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 ); 
    14571493 
    1458                 // NOTE: To any future maintainer, we've window.getComputedStyle 
    1459                 // because jsdom on node.js will break without it. 
     1494                // Use window.getComputedStyle because jsdom on node.js will break without it. 
    14601495                if ( window.getComputedStyle ) { 
    14611496                        support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%"; 
     
    14631498 
    14641499                        // Check if div with explicit width and no margin-right incorrectly 
    1465                         // gets computed margin-right based on width of container. For more 
    1466                         // info see bug #3333 
     1500                        // gets computed margin-right based on width of container. (#3333) 
    14671501                        // Fails in WebKit before Feb 2011 nightlies 
    14681502                        // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right 
    1469                         marginDiv = document.createElement("div"); 
     1503                        marginDiv = div.appendChild( document.createElement("div") ); 
    14701504                        marginDiv.style.cssText = div.style.cssText = divReset; 
    14711505                        marginDiv.style.marginRight = marginDiv.style.width = "0"; 
    14721506                        div.style.width = "1px"; 
    1473                         div.appendChild( marginDiv ); 
     1507 
    14741508                        support.reliableMarginRight = 
    14751509                                !parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight ); 
    14761510                } 
    14771511 
    1478                 if ( typeof div.style.zoom !== "undefined" ) { 
     1512                if ( typeof div.style.zoom !== core_strundefined ) { 
     1513                        // Support: IE<8 
    14791514                        // Check if natively block-level elements act like inline-block 
    14801515                        // elements when setting their display to 'inline' and giving 
    14811516                        // them layout 
    1482                         // (IE < 8 does this) 
    14831517                        div.innerHTML = ""; 
    14841518                        div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1"; 
    14851519                        support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 ); 
    14861520 
     1521                        // Support: IE6 
    14871522                        // Check if elements with layout shrink-wrap their children 
    1488                         // (IE 6 does this) 
    14891523                        div.style.display = "block"; 
    1490                         div.style.overflow = "visible"; 
    14911524                        div.innerHTML = "<div></div>"; 
    14921525                        div.firstChild.style.width = "5px"; 
    14931526                        support.shrinkWrapBlocks = ( div.offsetWidth !== 3 ); 
    14941527 
    1495                         container.style.zoom = 1; 
    1496                 } 
     1528                        if ( support.inlineBlockNeedsLayout ) { 
     1529                                // Prevent IE 6 from affecting layout for positioned elements #11048 
     1530                                // Prevent IE from shrinking the body in IE 7 mode #12869 
     1531                                // Support: IE<8 
     1532                                body.style.zoom = 1; 
     1533                        } 
     1534                } 
     1535 
     1536                body.removeChild( container ); 
    14971537 
    14981538                // Null elements to avoid leaks in IE 
    1499                 body.removeChild( container ); 
    15001539                container = div = tds = marginDiv = null; 
    15011540        }); 
    15021541 
    15031542        // Null elements to avoid leaks in IE 
    1504         fragment.removeChild( div ); 
    1505         all = a = select = opt = input = fragment = div = null; 
     1543        all = select = fragment = opt = a = input = null; 
    15061544 
    15071545        return support; 
    15081546})(); 
     1547 
    15091548var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/, 
    15101549        rmultiDash = /([A-Z])/g; 
    15111550 
     1551function internalData( elem, name, data, pvt /* Internal Use Only */ ){ 
     1552        if ( !jQuery.acceptData( elem ) ) { 
     1553                return; 
     1554        } 
     1555 
     1556        var thisCache, ret, 
     1557                internalKey = jQuery.expando, 
     1558                getByName = typeof name === "string", 
     1559 
     1560                // We have to handle DOM nodes and JS objects differently because IE6-7 
     1561                // can't GC object references properly across the DOM-JS boundary 
     1562                isNode = elem.nodeType, 
     1563 
     1564                // Only DOM nodes need the global jQuery cache; JS object data is 
     1565                // attached directly to the object so GC can occur automatically 
     1566                cache = isNode ? jQuery.cache : elem, 
     1567 
     1568                // Only defining an ID for JS objects if its cache already exists allows 
     1569                // the code to shortcut on the same path as a DOM node with no cache 
     1570                id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey; 
     1571 
     1572        // Avoid doing any more work than we need to when trying to get data on an 
     1573        // object that has no data at all 
     1574        if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) { 
     1575                return; 
     1576        } 
     1577 
     1578        if ( !id ) { 
     1579                // Only DOM nodes need a new unique ID for each element since their data 
     1580                // ends up in the global cache 
     1581                if ( isNode ) { 
     1582                        elem[ internalKey ] = id = core_deletedIds.pop() || jQuery.guid++; 
     1583                } else { 
     1584                        id = internalKey; 
     1585                } 
     1586        } 
     1587 
     1588        if ( !cache[ id ] ) { 
     1589                cache[ id ] = {}; 
     1590 
     1591                // Avoids exposing jQuery metadata on plain JS objects when the object 
     1592                // is serialized using JSON.stringify 
     1593                if ( !isNode ) { 
     1594                        cache[ id ].toJSON = jQuery.noop; 
     1595                } 
     1596        } 
     1597 
     1598        // An object can be passed to jQuery.data instead of a key/value pair; this gets 
     1599        // shallow copied over onto the existing cache 
     1600        if ( typeof name === "object" || typeof name === "function" ) { 
     1601                if ( pvt ) { 
     1602                        cache[ id ] = jQuery.extend( cache[ id ], name ); 
     1603                } else { 
     1604                        cache[ id ].data = jQuery.extend( cache[ id ].data, name ); 
     1605                } 
     1606        } 
     1607 
     1608        thisCache = cache[ id ]; 
     1609 
     1610        // jQuery data() is stored in a separate object inside the object's internal data 
     1611        // cache in order to avoid key collisions between internal data and user-defined 
     1612        // data. 
     1613        if ( !pvt ) { 
     1614                if ( !thisCache.data ) { 
     1615                        thisCache.data = {}; 
     1616                } 
     1617 
     1618                thisCache = thisCache.data; 
     1619        } 
     1620 
     1621        if ( data !== undefined ) { 
     1622                thisCache[ jQuery.camelCase( name ) ] = data; 
     1623        } 
     1624 
     1625        // Check for both converted-to-camel and non-converted data property names 
     1626        // If a data property was specified 
     1627        if ( getByName ) { 
     1628 
     1629                // First Try to find as-is property data 
     1630                ret = thisCache[ name ]; 
     1631 
     1632                // Test for null|undefined property data 
     1633                if ( ret == null ) { 
     1634 
     1635                        // Try to find the camelCased property 
     1636                        ret = thisCache[ jQuery.camelCase( name ) ]; 
     1637                } 
     1638        } else { 
     1639                ret = thisCache; 
     1640        } 
     1641 
     1642        return ret; 
     1643} 
     1644 
     1645function internalRemoveData( elem, name, pvt ) { 
     1646        if ( !jQuery.acceptData( elem ) ) { 
     1647                return; 
     1648        } 
     1649 
     1650        var i, l, thisCache, 
     1651                isNode = elem.nodeType, 
     1652 
     1653                // See jQuery.data for more information 
     1654                cache = isNode ? jQuery.cache : elem, 
     1655                id = isNode ? elem[ jQuery.expando ] : jQuery.expando; 
     1656 
     1657        // If there is already no cache entry for this object, there is no 
     1658        // purpose in continuing 
     1659        if ( !cache[ id ] ) { 
     1660                return; 
     1661        } 
     1662 
     1663        if ( name ) { 
     1664 
     1665                thisCache = pvt ? cache[ id ] : cache[ id ].data; 
     1666 
     1667                if ( thisCache ) { 
     1668 
     1669                        // Support array or space separated string names for data keys 
     1670                        if ( !jQuery.isArray( name ) ) { 
     1671 
     1672                                // try the string as a key before any manipulation 
     1673                                if ( name in thisCache ) { 
     1674                                        name = [ name ]; 
     1675                                } else { 
     1676 
     1677                                        // split the camel cased version by spaces unless a key with the spaces exists 
     1678                                        name = jQuery.camelCase( name ); 
     1679                                        if ( name in thisCache ) { 
     1680                                                name = [ name ]; 
     1681                                        } else { 
     1682                                                name = name.split(" "); 
     1683                                        } 
     1684                                } 
     1685                        } else { 
     1686                                // If "name" is an array of keys... 
     1687                                // When data is initially created, via ("key", "val") signature, 
     1688                                // keys will be converted to camelCase. 
     1689                                // Since there is no way to tell _how_ a key was added, remove 
     1690                                // both plain key and camelCase key. #12786 
     1691                                // This will only penalize the array argument path. 
     1692                                name = name.concat( jQuery.map( name, jQuery.camelCase ) ); 
     1693                        } 
     1694 
     1695                        for ( i = 0, l = name.length; i < l; i++ ) { 
     1696                                delete thisCache[ name[i] ]; 
     1697                        } 
     1698 
     1699                        // If there is no data left in the cache, we want to continue 
     1700                        // and let the cache object itself get destroyed 
     1701                        if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) { 
     1702                                return; 
     1703                        } 
     1704                } 
     1705        } 
     1706 
     1707        // See jQuery.data for more information 
     1708        if ( !pvt ) { 
     1709                delete cache[ id ].data; 
     1710 
     1711                // Don't destroy the parent cache unless the internal data object 
     1712                // had been the only thing left in it 
     1713                if ( !isEmptyDataObject( cache[ id ] ) ) { 
     1714                        return; 
     1715                } 
     1716        } 
     1717 
     1718        // Destroy the cache 
     1719        if ( isNode ) { 
     1720                jQuery.cleanData( [ elem ], true ); 
     1721 
     1722        // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080) 
     1723        } else if ( jQuery.support.deleteExpando || cache != cache.window ) { 
     1724                delete cache[ id ]; 
     1725 
     1726        // When all else fails, null 
     1727        } else { 
     1728                cache[ id ] = null; 
     1729        } 
     1730} 
     1731 
    15121732jQuery.extend({ 
    15131733        cache: {}, 
    15141734 
    1515         deletedIds: [], 
    1516  
    1517         // Remove at next major release (1.9/2.0) 
    1518         uuid: 0, 
    1519  
    15201735        // Unique for each copy of jQuery on the page 
    15211736        // Non-digits removed to match rinlinejQuery 
    1522         expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ), 
     1737        expando: "jQuery" + ( core_version + Math.random() ).replace( /\D/g, "" ), 
    15231738 
    15241739        // The following elements throw uncatchable exceptions if you 
     
    15361751        }, 
    15371752 
    1538         data: function( elem, name, data, pvt /* Internal Use Only */ ) { 
    1539                 if ( !jQuery.acceptData( elem ) ) { 
    1540                         return; 
    1541                 } 
    1542  
    1543                 var thisCache, ret, 
    1544                         internalKey = jQuery.expando, 
    1545                         getByName = typeof name === "string", 
    1546  
    1547                         // We have to handle DOM nodes and JS objects differently because IE6-7 
    1548                         // can't GC object references properly across the DOM-JS boundary 
    1549                         isNode = elem.nodeType, 
    1550  
    1551                         // Only DOM nodes need the global jQuery cache; JS object data is 
    1552                         // attached directly to the object so GC can occur automatically 
    1553                         cache = isNode ? jQuery.cache : elem, 
    1554  
    1555                         // Only defining an ID for JS objects if its cache already exists allows 
    1556                         // the code to shortcut on the same path as a DOM node with no cache 
    1557                         id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey; 
    1558  
    1559                 // Avoid doing any more work than we need to when trying to get data on an 
    1560                 // object that has no data at all 
    1561                 if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) { 
    1562                         return; 
    1563                 } 
    1564  
    1565                 if ( !id ) { 
    1566                         // Only DOM nodes need a new unique ID for each element since their data 
    1567                         // ends up in the global cache 
    1568                         if ( isNode ) { 
    1569                                 elem[ internalKey ] = id = jQuery.deletedIds.pop() || jQuery.guid++; 
    1570                         } else { 
    1571                                 id = internalKey; 
    1572                         } 
    1573                 } 
    1574  
    1575                 if ( !cache[ id ] ) { 
    1576                         cache[ id ] = {}; 
    1577  
    1578                         // Avoids exposing jQuery metadata on plain JS objects when the object 
    1579                         // is serialized using JSON.stringify 
    1580                         if ( !isNode ) { 
    1581                                 cache[ id ].toJSON = jQuery.noop; 
    1582                         } 
    1583                 } 
    1584  
    1585                 // An object can be passed to jQuery.data instead of a key/value pair; this gets 
    1586                 // shallow copied over onto the existing cache 
    1587                 if ( typeof name === "object" || typeof name === "function" ) { 
    1588                         if ( pvt ) { 
    1589                                 cache[ id ] = jQuery.extend( cache[ id ], name ); 
    1590                         } else { 
    1591                                 cache[ id ].data = jQuery.extend( cache[ id ].data, name ); 
    1592                         } 
    1593                 } 
    1594  
    1595                 thisCache = cache[ id ]; 
    1596  
    1597                 // jQuery data() is stored in a separate object inside the object's internal data 
    1598                 // cache in order to avoid key collisions between internal data and user-defined 
    1599                 // data. 
    1600                 if ( !pvt ) { 
    1601                         if ( !thisCache.data ) { 
    1602                                 thisCache.data = {}; 
    1603                         } 
    1604  
    1605                         thisCache = thisCache.data; 
    1606                 } 
    1607  
    1608                 if ( data !== undefined ) { 
    1609                         thisCache[ jQuery.camelCase( name ) ] = data; 
    1610                 } 
    1611  
    1612                 // Check for both converted-to-camel and non-converted data property names 
    1613                 // If a data property was specified 
    1614                 if ( getByName ) { 
    1615  
    1616                         // First Try to find as-is property data 
    1617                         ret = thisCache[ name ]; 
    1618  
    1619                         // Test for null|undefined property data 
    1620                         if ( ret == null ) { 
    1621  
    1622                                 // Try to find the camelCased property 
    1623                                 ret = thisCache[ jQuery.camelCase( name ) ]; 
    1624                         } 
    1625                 } else { 
    1626                         ret = thisCache; 
    1627                 } 
    1628  
    1629                 return ret; 
    1630         }, 
    1631  
    1632         removeData: function( elem, name, pvt /* Internal Use Only */ ) { 
    1633                 if ( !jQuery.acceptData( elem ) ) { 
    1634                         return; 
    1635                 } 
    1636  
    1637                 var thisCache, i, l, 
    1638  
    1639                         isNode = elem.nodeType, 
    1640  
    1641                         // See jQuery.data for more information 
    1642                         cache = isNode ? jQuery.cache : elem, 
    1643                         id = isNode ? elem[ jQuery.expando ] : jQuery.expando; 
    1644  
    1645                 // If there is already no cache entry for this object, there is no 
    1646                 // purpose in continuing 
    1647                 if ( !cache[ id ] ) { 
    1648                         return; 
    1649                 } 
    1650  
    1651                 if ( name ) { 
    1652  
    1653                         thisCache = pvt ? cache[ id ] : cache[ id ].data; 
    1654  
    1655                         if ( thisCache ) { 
    1656  
    1657                                 // Support array or space separated string names for data keys 
    1658                                 if ( !jQuery.isArray( name ) ) { 
    1659  
    1660                                         // try the string as a key before any manipulation 
    1661                                         if ( name in thisCache ) { 
    1662                                                 name = [ name ]; 
    1663                                         } else { 
    1664  
    1665                                                 // split the camel cased version by spaces unless a key with the spaces exists 
    1666                                                 name = jQuery.camelCase( name ); 
    1667                                                 if ( name in thisCache ) { 
    1668                                                         name = [ name ]; 
    1669                                                 } else { 
    1670                                                         name = name.split(" "); 
    1671                                                 } 
    1672                                         } 
    1673                                 } 
    1674  
    1675                                 for ( i = 0, l = name.length; i < l; i++ ) { 
    1676                                         delete thisCache[ name[i] ]; 
    1677                                 } 
    1678  
    1679                                 // If there is no data left in the cache, we want to continue 
    1680                                 // and let the cache object itself get destroyed 
    1681                                 if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) { 
    1682                                         return; 
    1683                                 } 
    1684                         } 
    1685                 } 
    1686  
    1687                 // See jQuery.data for more information 
    1688                 if ( !pvt ) { 
    1689                         delete cache[ id ].data; 
    1690  
    1691                         // Don't destroy the parent cache unless the internal data object 
    1692                         // had been the only thing left in it 
    1693                         if ( !isEmptyDataObject( cache[ id ] ) ) { 
    1694                                 return; 
    1695                         } 
    1696                 } 
    1697  
    1698                 // Destroy the cache 
    1699                 if ( isNode ) { 
    1700                         jQuery.cleanData( [ elem ], true ); 
    1701  
    1702                 // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080) 
    1703                 } else if ( jQuery.support.deleteExpando || cache != cache.window ) { 
    1704                         delete cache[ id ]; 
    1705  
    1706                 // When all else fails, null 
    1707                 } else { 
    1708                         cache[ id ] = null; 
    1709                 } 
     1753        data: function( elem, name, data ) { 
     1754                return internalData( elem, name, data ); 
     1755        }, 
     1756 
     1757        removeData: function( elem, name ) { 
     1758                return internalRemoveData( elem, name ); 
    17101759        }, 
    17111760 
    17121761        // For internal use only. 
    17131762        _data: function( elem, name, data ) { 
    1714                 return jQuery.data( elem, name, data, true ); 
     1763                return internalData( elem, name, data, true ); 
     1764        }, 
     1765 
     1766        _removeData: function( elem, name ) { 
     1767                return internalRemoveData( elem, name, true ); 
    17151768        }, 
    17161769 
    17171770        // A method for determining if a DOM node can handle the data expando 
    17181771        acceptData: function( elem ) { 
     1772                // Do not set data on non-element because it will not be cleared (#8335). 
     1773                if ( elem.nodeType && elem.nodeType !== 1 && elem.nodeType !== 9 ) { 
     1774                        return false; 
     1775                } 
     1776 
    17191777                var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ]; 
    17201778 
     
    17261784jQuery.fn.extend({ 
    17271785        data: function( key, value ) { 
    1728                 var parts, part, attr, name, l, 
     1786                var attrs, name, 
    17291787                        elem = this[0], 
    17301788                        i = 0, 
     
    17371795 
    17381796                                if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) { 
    1739                                         attr = elem.attributes; 
    1740                                         for ( l = attr.length; i < l; i++ ) { 
    1741                                                 name = attr[i].name; 
     1797                                        attrs = elem.attributes; 
     1798                                        for ( ; i < attrs.length; i++ ) { 
     1799                                                name = attrs[i].name; 
    17421800 
    17431801                                                if ( !name.indexOf( "data-" ) ) { 
    1744                                                         name = jQuery.camelCase( name.substring(5) ); 
     1802                                                        name = jQuery.camelCase( name.slice(5) ); 
    17451803 
    17461804                                                        dataAttr( elem, name, data[ name ] ); 
     
    17611819                } 
    17621820 
    1763                 parts = key.split( ".", 2 ); 
    1764                 parts[1] = parts[1] ? "." + parts[1] : ""; 
    1765                 part = parts[1] + "!"; 
    1766  
    17671821                return jQuery.access( this, function( value ) { 
    17681822 
    17691823                        if ( value === undefined ) { 
    1770                                 data = this.triggerHandler( "getData" + part, [ parts[0] ] ); 
    1771  
    17721824                                // Try to fetch any internally stored data first 
    1773                                 if ( data === undefined && elem ) { 
    1774                                         data = jQuery.data( elem, key ); 
    1775                                         data = dataAttr( elem, key, data ); 
    1776                                 } 
    1777  
    1778                                 return data === undefined && parts[1] ? 
    1779                                         this.data( parts[0] ) : 
    1780                                         data; 
    1781                         } 
    1782  
    1783                         parts[1] = value; 
     1825                                return elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : null; 
     1826                        } 
     1827 
    17841828                        this.each(function() { 
    1785                                 var self = jQuery( this ); 
    1786  
    1787                                 self.triggerHandler( "setData" + part, parts ); 
    17881829                                jQuery.data( this, key, value ); 
    1789                                 self.triggerHandler( "changeData" + part, parts ); 
    17901830                        }); 
    1791                 }, null, value, arguments.length > 1, null, false ); 
     1831                }, null, value, arguments.length > 1, null, true ); 
    17921832        }, 
    17931833 
     
    18111851                        try { 
    18121852                                data = data === "true" ? true : 
    1813                                 data === "false" ? false : 
    1814                                 data === "null" ? null : 
    1815                                 // Only convert to a number if it doesn't change the string 
    1816                                 +data + "" === data ? +data : 
    1817                                 rbrace.test( data ) ? jQuery.parseJSON( data ) : 
    1818                                         data; 
     1853                                        data === "false" ? false : 
     1854                                        data === "null" ? null : 
     1855                                        // Only convert to a number if it doesn't change the string 
     1856                                        +data + "" === data ? +data : 
     1857                                        rbrace.test( data ) ? jQuery.parseJSON( data ) : 
     1858                                                data; 
    18191859                        } catch( e ) {} 
    18201860 
     
    18831923                } 
    18841924 
     1925                hooks.cur = fn; 
    18851926                if ( fn ) { 
    18861927 
     
    19061947                return jQuery._data( elem, key ) || jQuery._data( elem, key, { 
    19071948                        empty: jQuery.Callbacks("once memory").add(function() { 
    1908                                 jQuery.removeData( elem, type + "queue", true ); 
    1909                                 jQuery.removeData( elem, key, true ); 
     1949                                jQuery._removeData( elem, type + "queue" ); 
     1950                                jQuery._removeData( elem, key ); 
    19101951                        }) 
    19111952                }); 
     
    19922033        } 
    19932034}); 
    1994 var nodeHook, boolHook, fixSpecified, 
     2035var nodeHook, boolHook, 
    19952036        rclass = /[\t\r\n]/g, 
    19962037        rreturn = /\r/g, 
    1997         rtype = /^(?:button|input)$/i, 
    1998         rfocusable = /^(?:button|input|object|select|textarea)$/i, 
    1999         rclickable = /^a(?:rea|)$/i, 
    2000         rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i, 
    2001         getSetAttribute = jQuery.support.getSetAttribute; 
     2038        rfocusable = /^(?:input|select|textarea|button|object)$/i, 
     2039        rclickable = /^(?:a|area)$/i, 
     2040        rboolean = /^(?:checked|selected|autofocus|autoplay|async|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped)$/i, 
     2041        ruseDefault = /^(?:checked|selected)$/i, 
     2042        getSetAttribute = jQuery.support.getSetAttribute, 
     2043        getSetInput = jQuery.support.input; 
    20022044 
    20032045jQuery.fn.extend({ 
     
    20282070 
    20292071        addClass: function( value ) { 
    2030                 var classNames, i, l, elem, 
    2031                         setClass, c, cl; 
     2072                var classes, elem, cur, clazz, j, 
     2073                        i = 0, 
     2074                        len = this.length, 
     2075                        proceed = typeof value === "string" && value; 
    20322076 
    20332077                if ( jQuery.isFunction( value ) ) { 
    20342078                        return this.each(function( j ) { 
    2035                                 jQuery( this ).addClass( value.call(this, j, this.className) ); 
     2079                                jQuery( this ).addClass( value.call( this, j, this.className ) ); 
    20362080                        }); 
    20372081                } 
    20382082 
    2039                 if ( value && typeof value === "string" ) { 
    2040                         classNames = value.split( core_rspace ); 
    2041  
    2042                         for ( i = 0, l = this.length; i < l; i++ ) { 
     2083                if ( proceed ) { 
     2084                        // The disjunction here is for better compressibility (see removeClass) 
     2085                        classes = ( value || "" ).match( core_rnotwhite ) || []; 
     2086 
     2087                        for ( ; i < len; i++ ) { 
    20432088                                elem = this[ i ]; 
    2044  
    2045                                 if ( elem.nodeType === 1 ) { 
    2046                                         if ( !elem.className && classNames.length === 1 ) { 
    2047                                                 elem.className = value; 
    2048  
    2049                                         } else { 
    2050                                                 setClass = " " + elem.className + " "; 
    2051  
    2052                                                 for ( c = 0, cl = classNames.length; c < cl; c++ ) { 
    2053                                                         if ( setClass.indexOf( " " + classNames[ c ] + " " ) < 0 ) { 
    2054                                                                 setClass += classNames[ c ] + " "; 
    2055                                                         } 
     2089                                cur = elem.nodeType === 1 && ( elem.className ? 
     2090                                        ( " " + elem.className + " " ).replace( rclass, " " ) : 
     2091                                        " " 
     2092                                ); 
     2093 
     2094                                if ( cur ) { 
     2095                                        j = 0; 
     2096                                        while ( (clazz = classes[j++]) ) { 
     2097                                                if ( cur.indexOf( " " + clazz + " " ) < 0 ) { 
     2098                                                        cur += clazz + " "; 
    20562099                                                } 
    2057                                                 elem.className = jQuery.trim( setClass ); 
    20582100                                        } 
     2101                                        elem.className = jQuery.trim( cur ); 
     2102 
    20592103                                } 
    20602104                        } 
     
    20652109 
    20662110        removeClass: function( value ) { 
    2067                 var removes, className, elem, c, cl, i, l; 
     2111                var classes, elem, cur, clazz, j, 
     2112                        i = 0, 
     2113                        len = this.length, 
     2114                        proceed = arguments.length === 0 || typeof value === "string" && value; 
    20682115 
    20692116                if ( jQuery.isFunction( value ) ) { 
    20702117                        return this.each(function( j ) { 
    2071                                 jQuery( this ).removeClass( value.call(this, j, this.className) ); 
     2118                                jQuery( this ).removeClass( value.call( this, j, this.className ) ); 
    20722119                        }); 
    20732120                } 
    2074                 if ( (value && typeof value === "string") || value === undefined ) { 
    2075                         removes = ( value || "" ).split( core_rspace ); 
    2076  
    2077                         for ( i = 0, l = this.length; i < l; i++ ) { 
     2121                if ( proceed ) { 
     2122                        classes = ( value || "" ).match( core_rnotwhite ) || []; 
     2123 
     2124                        for ( ; i < len; i++ ) { 
    20782125                                elem = this[ i ]; 
    2079                                 if ( elem.nodeType === 1 && elem.className ) { 
    2080  
    2081                                         className = (" " + elem.className + " ").replace( rclass, " " ); 
    2082  
    2083                                         // loop over each item in the removal list 
    2084                                         for ( c = 0, cl = removes.length; c < cl; c++ ) { 
    2085                                                 // Remove until there is nothing to remove, 
    2086                                                 while ( className.indexOf(" " + removes[ c ] + " ") >= 0 ) { 
    2087                                                         className = className.replace( " " + removes[ c ] + " " , " " ); 
     2126                                // This expression is here for better compressibility (see addClass) 
     2127                                cur = elem.nodeType === 1 && ( elem.className ? 
     2128                                        ( " " + elem.className + " " ).replace( rclass, " " ) : 
     2129                                        "" 
     2130                                ); 
     2131 
     2132                                if ( cur ) { 
     2133                                        j = 0; 
     2134                                        while ( (clazz = classes[j++]) ) { 
     2135                                                // Remove *all* instances 
     2136                                                while ( cur.indexOf( " " + clazz + " " ) >= 0 ) { 
     2137                                                        cur = cur.replace( " " + clazz + " ", " " ); 
    20882138                                                } 
    20892139                                        } 
    2090                                         elem.className = value ? jQuery.trim( className ) : ""; 
     2140                                        elem.className = value ? jQuery.trim( cur ) : ""; 
    20912141                                } 
    20922142                        } 
     
    21132163                                        self = jQuery( this ), 
    21142164                                        state = stateVal, 
    2115                                         classNames = value.split( core_rspace ); 
     2165                                        classNames = value.match( core_rnotwhite ) || []; 
    21162166 
    21172167                                while ( (className = classNames[ i++ ]) ) { 
     
    21212171                                } 
    21222172 
    2123                         } else if ( type === "undefined" || type === "boolean" ) { 
     2173                        // Toggle whole class name 
     2174                        } else if ( type === core_strundefined || type === "boolean" ) { 
    21242175                                if ( this.className ) { 
    21252176                                        // store className if set 
     
    21272178                                } 
    21282179 
    2129                                 // toggle whole className 
     2180                                // If the element has a class name or if we're passed "false", 
     2181                                // then remove the whole classname (if there was one, the above saved it). 
     2182                                // Otherwise bring back whatever was previously saved (if anything), 
     2183                                // falling back to the empty string if nothing was stored. 
    21302184                                this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || ""; 
    21312185                        } 
     
    21472201 
    21482202        val: function( value ) { 
    2149                 var hooks, ret, isFunction, 
     2203                var ret, hooks, isFunction, 
    21502204                        elem = this[0]; 
    21512205 
     
    22702324        }, 
    22712325 
    2272         // Unused in 1.8, left in so attrFn-stabbers won't die; remove in 1.9 
    2273         attrFn: {}, 
    2274  
    2275         attr: function( elem, name, value, pass ) { 
    2276                 var ret, hooks, notxml, 
     2326        attr: function( elem, name, value ) { 
     2327                var hooks, notxml, ret, 
    22772328                        nType = elem.nodeType; 
    22782329 
     
    22822333                } 
    22832334 
    2284                 if ( pass && jQuery.isFunction( jQuery.fn[ name ] ) ) { 
    2285                         return jQuery( elem )[ name ]( value ); 
    2286                 } 
    2287  
    22882335                // Fallback to prop when attributes are not supported 
    2289                 if ( typeof elem.getAttribute === "undefined" ) { 
     2336                if ( typeof elem.getAttribute === core_strundefined ) { 
    22902337                        return jQuery.prop( elem, name, value ); 
    22912338                } 
     
    23042351                        if ( value === null ) { 
    23052352                                jQuery.removeAttr( elem, name ); 
    2306                                 return; 
    2307  
    2308                         } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) { 
     2353 
     2354                        } else if ( hooks && notxml && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) { 
    23092355                                return ret; 
    23102356 
     
    23142360                        } 
    23152361 
    2316                 } else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) { 
     2362                } else if ( hooks && notxml && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) { 
    23172363                        return ret; 
    23182364 
    23192365                } else { 
    23202366 
    2321                         ret = elem.getAttribute( name ); 
     2367                        // In IE9+, Flash objects don't have .getAttribute (#12945) 
     2368                        // Support: IE9+ 
     2369                        if ( typeof elem.getAttribute !== core_strundefined ) { 
     2370                                ret =  elem.getAttribute( name ); 
     2371                        } 
    23222372 
    23232373                        // Non-existent attributes return null, we normalize to undefined 
    2324                         return ret === null ? 
     2374                        return ret == null ? 
    23252375                                undefined : 
    23262376                                ret; 
     
    23292379 
    23302380        removeAttr: function( elem, value ) { 
    2331                 var propName, attrNames, name, isBool, 
    2332                         i = 0; 
    2333  
    2334                 if ( value && elem.nodeType === 1 ) { 
    2335  
    2336                         attrNames = value.split( core_rspace ); 
    2337  
    2338                         for ( ; i < attrNames.length; i++ ) { 
    2339                                 name = attrNames[ i ]; 
    2340  
    2341                                 if ( name ) { 
    2342                                         propName = jQuery.propFix[ name ] || name; 
    2343                                         isBool = rboolean.test( name ); 
    2344  
    2345                                         // See #9699 for explanation of this approach (setting first, then removal) 
    2346                                         // Do not do this for boolean attributes (see #10870) 
    2347                                         if ( !isBool ) { 
    2348                                                 jQuery.attr( elem, name, "" ); 
    2349                                         } 
    2350                                         elem.removeAttribute( getSetAttribute ? name : propName ); 
    2351  
     2381                var name, propName, 
     2382                        i = 0, 
     2383                        attrNames = value && value.match( core_rnotwhite ); 
     2384 
     2385                if ( attrNames && elem.nodeType === 1 ) { 
     2386                        while ( (name = attrNames[i++]) ) { 
     2387                                propName = jQuery.propFix[ name ] || name; 
     2388 
     2389                                // Boolean attributes get special treatment (#10870) 
     2390                                if ( rboolean.test( name ) ) { 
    23522391                                        // Set corresponding property to false for boolean attributes 
    2353                                         if ( isBool && propName in elem ) { 
     2392                                        // Also clear defaultChecked/defaultSelected (if appropriate) for IE<8 
     2393                                        if ( !getSetAttribute && ruseDefault.test( name ) ) { 
     2394                                                elem[ jQuery.camelCase( "default-" + name ) ] = 
     2395                                                        elem[ propName ] = false; 
     2396                                        } else { 
    23542397                                                elem[ propName ] = false; 
    23552398                                        } 
    2356                                 } 
     2399 
     2400                                // See #9699 for explanation of this approach (setting first, then removal) 
     2401                                } else { 
     2402                                        jQuery.attr( elem, name, "" ); 
     2403                                } 
     2404 
     2405                                elem.removeAttribute( getSetAttribute ? name : propName ); 
    23572406                        } 
    23582407                } 
     
    23622411                type: { 
    23632412                        set: function( elem, value ) { 
    2364                                 // We can't allow the type property to be changed (since it causes problems in IE) 
    2365                                 if ( rtype.test( elem.nodeName ) && elem.parentNode ) { 
    2366                                         jQuery.error( "type property can't be changed" ); 
    2367                                 } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) { 
     2413                                if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) { 
    23682414                                        // Setting the type on a radio button after the value resets the value in IE6-9 
    2369                                         // Reset value to it's default in case type is set after value 
    2370                                         // This is for element creation 
     2415                                        // Reset value to default in case type is set after value during creation 
    23712416                                        var val = elem.value; 
    23722417                                        elem.setAttribute( "type", value ); 
     
    23762421                                        return value; 
    23772422                                } 
    2378                         } 
    2379                 }, 
    2380                 // Use the value property for back compat 
    2381                 // Use the nodeHook for button elements in IE6/7 (#1954) 
    2382                 value: { 
    2383                         get: function( elem, name ) { 
    2384                                 if ( nodeHook && jQuery.nodeName( elem, "button" ) ) { 
    2385                                         return nodeHook.get( elem, name ); 
    2386                                 } 
    2387                                 return name in elem ? 
    2388                                         elem.value : 
    2389                                         null; 
    2390                         }, 
    2391                         set: function( elem, value, name ) { 
    2392                                 if ( nodeHook && jQuery.nodeName( elem, "button" ) ) { 
    2393                                         return nodeHook.set( elem, value, name ); 
    2394                                 } 
    2395                                 // Does not return so that setAttribute is also used 
    2396                                 elem.value = value; 
    23972423                        } 
    23982424                } 
     
    24692495boolHook = { 
    24702496        get: function( elem, name ) { 
    2471                 // Align boolean attributes with corresponding properties 
    2472                 // Fall back to attribute presence where some booleans are not supported 
    2473                 var attrNode, 
    2474                         property = jQuery.prop( elem, name ); 
    2475                 return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ? 
     2497                var 
     2498                        // Use .prop to determine if this attribute is understood as boolean 
     2499                        prop = jQuery.prop( elem, name ), 
     2500 
     2501                        // Fetch it accordingly 
     2502                        attr = typeof prop === "boolean" && elem.getAttribute( name ), 
     2503                        detail = typeof prop === "boolean" ? 
     2504 
     2505                                getSetInput && getSetAttribute ? 
     2506                                        attr != null : 
     2507                                        // oldIE fabricates an empty string for missing boolean attributes 
     2508                                        // and conflates checked/selected into attroperties 
     2509                                        ruseDefault.test( name ) ? 
     2510                                                elem[ jQuery.camelCase( "default-" + name ) ] : 
     2511                                                !!attr : 
     2512 
     2513                                // fetch an attribute node for properties not recognized as boolean 
     2514                                elem.getAttributeNode( name ); 
     2515 
     2516                return detail && detail.value !== false ? 
    24762517                        name.toLowerCase() : 
    24772518                        undefined; 
    24782519        }, 
    24792520        set: function( elem, value, name ) { 
    2480                 var propName; 
    24812521                if ( value === false ) { 
    24822522                        // Remove boolean attributes when set to false 
    24832523                        jQuery.removeAttr( elem, name ); 
     2524                } else if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) { 
     2525                        // IE<8 needs the *property* name 
     2526                        elem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name ); 
     2527 
     2528                // Use defaultChecked and defaultSelected for oldIE 
    24842529                } else { 
    2485                         // value is true since we know at this point it's type boolean and not false 
    2486                         // Set boolean attributes to the same name and set the DOM property 
    2487                         propName = jQuery.propFix[ name ] || name; 
    2488                         if ( propName in elem ) { 
    2489                                 // Only set the IDL specifically if it already exists on the element 
    2490                                 elem[ propName ] = true; 
    2491                         } 
    2492  
    2493                         elem.setAttribute( name, name.toLowerCase() ); 
    2494                 } 
     2530                        elem[ jQuery.camelCase( "default-" + name ) ] = elem[ name ] = true; 
     2531                } 
     2532 
    24952533                return name; 
    24962534        } 
    24972535}; 
     2536 
     2537// fix oldIE value attroperty 
     2538if ( !getSetInput || !getSetAttribute ) { 
     2539        jQuery.attrHooks.value = { 
     2540                get: function( elem, name ) { 
     2541                        var ret = elem.getAttributeNode( name ); 
     2542                        return jQuery.nodeName( elem, "input" ) ? 
     2543 
     2544                                // Ignore the value *property* by using defaultValue 
     2545                                elem.defaultValue : 
     2546 
     2547                                ret && ret.specified ? ret.value : undefined; 
     2548                }, 
     2549                set: function( elem, value, name ) { 
     2550                        if ( jQuery.nodeName( elem, "input" ) ) { 
     2551                                // Does not return so that setAttribute is also used 
     2552                                elem.defaultValue = value; 
     2553                        } else { 
     2554                                // Use nodeHook if defined (#1954); otherwise setAttribute is fine 
     2555                                return nodeHook && nodeHook.set( elem, value, name ); 
     2556                        } 
     2557                } 
     2558        }; 
     2559} 
    24982560 
    24992561// IE6/7 do not support getting/setting some attributes with get/setAttribute 
    25002562if ( !getSetAttribute ) { 
    2501  
    2502         fixSpecified = { 
    2503                 name: true, 
    2504                 id: true, 
    2505                 coords: true 
    2506         }; 
    25072563 
    25082564        // Use this for any attribute in IE6/7 
     
    25102566        nodeHook = jQuery.valHooks.button = { 
    25112567                get: function( elem, name ) { 
    2512                         var ret; 
    2513                         ret = elem.getAttributeNode( name ); 
    2514                         return ret && ( fixSpecified[ name ] ? ret.value !== "" : ret.specified ) ? 
     2568                        var ret = elem.getAttributeNode( name ); 
     2569                        return ret && ( name === "id" || name === "name" || name === "coords" ? ret.value !== "" : ret.specified ) ? 
    25152570                                ret.value : 
    25162571                                undefined; 
     
    25202575                        var ret = elem.getAttributeNode( name ); 
    25212576                        if ( !ret ) { 
    2522                                 ret = document.createAttribute( name ); 
    2523                                 elem.setAttributeNode( ret ); 
    2524                         } 
    2525                         return ( ret.value = value + "" ); 
     2577                                elem.setAttributeNode( 
     2578                                        (ret = elem.ownerDocument.createAttribute( name )) 
     2579                                ); 
     2580                        } 
     2581 
     2582                        ret.value = value += ""; 
     2583 
     2584                        // Break association with cloned elements by also using setAttribute (#9646) 
     2585                        return name === "value" || value === elem.getAttribute( name ) ? 
     2586                                value : 
     2587                                undefined; 
     2588                } 
     2589        }; 
     2590 
     2591        // Set contenteditable to false on removals(#10429) 
     2592        // Setting to empty string throws an error as an invalid value 
     2593        jQuery.attrHooks.contenteditable = { 
     2594                get: nodeHook.get, 
     2595                set: function( elem, value, name ) { 
     2596                        nodeHook.set( elem, value === "" ? false : value, name ); 
    25262597                } 
    25272598        }; 
     
    25392610                }); 
    25402611        }); 
    2541  
    2542         // Set contenteditable to false on removals(#10429) 
    2543         // Setting to empty string throws an error as an invalid value 
    2544         jQuery.attrHooks.contenteditable = { 
    2545                 get: nodeHook.get, 
    2546                 set: function( elem, value, name ) { 
    2547                         if ( value === "" ) { 
    2548                                 value = "false"; 
    2549                         } 
    2550                         nodeHook.set( elem, value, name ); 
    2551                 } 
    2552         }; 
    25532612} 
    25542613 
    25552614 
    25562615// Some attributes require a special call on IE 
     2616// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx 
    25572617if ( !jQuery.support.hrefNormalized ) { 
    25582618        jQuery.each([ "href", "src", "width", "height" ], function( i, name ) { 
     
    25602620                        get: function( elem ) { 
    25612621                                var ret = elem.getAttribute( name, 2 ); 
    2562                                 return ret === null ? undefined : ret; 
     2622                                return ret == null ? undefined : ret; 
    25632623                        } 
    25642624                }); 
     2625        }); 
     2626 
     2627        // href/src property should get the full normalized URL (#10299/#12915) 
     2628        jQuery.each([ "href", "src" ], function( i, name ) { 
     2629                jQuery.propHooks[ name ] = { 
     2630                        get: function( elem ) { 
     2631                                return elem.getAttribute( name, 4 ); 
     2632                        } 
     2633                }; 
    25652634        }); 
    25662635} 
     
    25702639                get: function( elem ) { 
    25712640                        // Return undefined in the case of empty string 
    2572                         // Normalize to lowercase since IE uppercases css property names 
    2573                         return elem.style.cssText.toLowerCase() || undefined; 
     2641                        // Note: IE uppercases css property names, but if we were to .toLowerCase() 
     2642                        // .cssText, that would destroy case senstitivity in URL's, like in "background" 
     2643                        return elem.style.cssText || undefined; 
    25742644                }, 
    25752645                set: function( elem, value ) { 
     
    26242694        }); 
    26252695}); 
    2626 var rformElems = /^(?:textarea|input|select)$/i, 
    2627         rtypenamespace = /^([^\.]*|)(?:\.(.+)|)$/, 
    2628         rhoverHack = /(?:^|\s)hover(\.\S+|)\b/, 
     2696var rformElems = /^(?:input|select|textarea)$/i, 
    26292697        rkeyEvent = /^key/, 
    26302698        rmouseEvent = /^(?:mouse|contextmenu)|click/, 
    26312699        rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, 
    2632         hoverHack = function( events ) { 
    2633                 return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" ); 
    2634         }; 
     2700        rtypenamespace = /^([^.]*)(?:\.(.+)|)$/; 
     2701 
     2702function returnTrue() { 
     2703        return true; 
     2704} 
     2705 
     2706function returnFalse() { 
     2707        return false; 
     2708} 
    26352709 
    26362710/* 
     
    26402714jQuery.event = { 
    26412715 
     2716        global: {}, 
     2717 
    26422718        add: function( elem, types, handler, data, selector ) { 
    2643  
    2644                 var elemData, eventHandle, events, 
    2645                         t, tns, type, namespaces, handleObj, 
    2646                         handleObjIn, handlers, special; 
    2647  
    2648                 // Don't attach events to noData or text/comment nodes (allow plain objects tho) 
    2649                 if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) { 
     2719                var tmp, events, t, handleObjIn, 
     2720                        special, eventHandle, handleObj, 
     2721                        handlers, type, namespaces, origType, 
     2722                        elemData = jQuery._data( elem ); 
     2723 
     2724                // Don't attach events to noData or text/comment nodes (but allow plain objects) 
     2725                if ( !elemData ) { 
    26502726                        return; 
    26512727                } 
     
    26642740 
    26652741                // Init the element's event structure and main handler, if this is the first 
    2666                 events = elemData.events; 
    2667                 if ( !events ) { 
    2668                         elemData.events = events = {}; 
    2669                 } 
    2670                 eventHandle = elemData.handle; 
    2671                 if ( !eventHandle ) { 
    2672                         elemData.handle = eventHandle = function( e ) { 
     2742                if ( !(events = elemData.events) ) { 
     2743                        events = elemData.events = {}; 
     2744                } 
     2745                if ( !(eventHandle = elemData.handle) ) { 
     2746                        eventHandle = elemData.handle = function( e ) { 
    26732747                                // Discard the second event of a jQuery.event.trigger() and 
    26742748                                // when an event is called after a page has unloaded 
    2675                                 return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ? 
     2749                                return typeof jQuery !== core_strundefined && (!e || jQuery.event.triggered !== e.type) ? 
    26762750                                        jQuery.event.dispatch.apply( eventHandle.elem, arguments ) : 
    26772751                                        undefined; 
     
    26832757                // Handle multiple events separated by a space 
    26842758                // jQuery(...).bind("mouseover mouseout", fn); 
    2685                 types = jQuery.trim( hoverHack(types) ).split( " " ); 
    2686                 for ( t = 0; t < types.length; t++ ) { 
    2687  
    2688                         tns = rtypenamespace.exec( types[t] ) || []; 
    2689                         type = tns[1]; 
    2690                         namespaces = ( tns[2] || "" ).split( "." ).sort(); 
     2759                types = ( types || "" ).match( core_rnotwhite ) || [""]; 
     2760                t = types.length; 
     2761                while ( t-- ) { 
     2762                        tmp = rtypenamespace.exec( types[t] ) || []; 
     2763                        type = origType = tmp[1]; 
     2764                        namespaces = ( tmp[2] || "" ).split( "." ).sort(); 
    26912765 
    26922766                        // If event changes its type, use the special event handlers for the changed type 
     
    27022776                        handleObj = jQuery.extend({ 
    27032777                                type: type, 
    2704                                 origType: tns[1], 
     2778                                origType: origType, 
    27052779                                data: data, 
    27062780                                handler: handler, 
     
    27122786 
    27132787                        // Init the event handler queue if we're the first 
    2714                         handlers = events[ type ]; 
    2715                         if ( !handlers ) { 
     2788                        if ( !(handlers = events[ type ]) ) { 
    27162789                                handlers = events[ type ] = []; 
    27172790                                handlers.delegateCount = 0; 
     
    27522825        }, 
    27532826 
    2754         global: {}, 
    2755  
    27562827        // Detach an event or set of events from an element 
    27572828        remove: function( elem, types, handler, selector, mappedTypes ) { 
    2758  
    2759                 var t, tns, type, origType, namespaces, origCount, 
    2760                         j, events, special, eventType, handleObj, 
     2829                var j, handleObj, tmp, 
     2830                        origCount, t, events, 
     2831                        special, handlers, type, 
     2832                        namespaces, origType, 
    27612833                        elemData = jQuery.hasData( elem ) && jQuery._data( elem ); 
    27622834 
     
    27662838 
    27672839                // Once for each type.namespace in types; type may be omitted 
    2768                 types = jQuery.trim( hoverHack( types || "" ) ).split(" "); 
    2769                 for ( t = 0; t < types.length; t++ ) { 
    2770                         tns = rtypenamespace.exec( types[t] ) || []; 
    2771                         type = origType = tns[1]; 
    2772                         namespaces = tns[2]; 
     2840                types = ( types || "" ).match( core_rnotwhite ) || [""]; 
     2841                t = types.length; 
     2842                while ( t-- ) { 
     2843                        tmp = rtypenamespace.exec( types[t] ) || []; 
     2844                        type = origType = tmp[1]; 
     2845                        namespaces = ( tmp[2] || "" ).split( "." ).sort(); 
    27732846 
    27742847                        // Unbind all events (on this namespace, if provided) for the element 
     
    27812854 
    27822855                        special = jQuery.event.special[ type ] || {}; 
    2783                         type = ( selector? special.delegateType : special.bindType ) || type; 
    2784                         eventType = events[ type ] || []; 
    2785                         origCount = eventType.length; 
    2786                         namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.|)") + "(\\.|$)") : null; 
     2856                        type = ( selector ? special.delegateType : special.bindType ) || type; 
     2857                        handlers = events[ type ] || []; 
     2858                        tmp = tmp[2] && new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ); 
    27872859 
    27882860                        // Remove matching events 
    2789                         for ( j = 0; j < eventType.length; j++ ) { 
    2790                                 handleObj = eventType[ j ]; 
     2861                        origCount = j = handlers.length; 
     2862                        while ( j-- ) { 
     2863                                handleObj = handlers[ j ]; 
    27912864 
    27922865                                if ( ( mappedTypes || origType === handleObj.origType ) && 
    2793                                          ( !handler || handler.guid === handleObj.guid ) && 
    2794                                          ( !namespaces || namespaces.test( handleObj.namespace ) ) && 
    2795                                          ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) { 
    2796                                         eventType.splice( j--, 1 ); 
     2866                                        ( !handler || handler.guid === handleObj.guid ) && 
     2867                                        ( !tmp || tmp.test( handleObj.namespace ) ) && 
     2868                                        ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) { 
     2869                                        handlers.splice( j, 1 ); 
    27972870 
    27982871                                        if ( handleObj.selector ) { 
    2799                                                 eventType.delegateCount--; 
     2872                                                handlers.delegateCount--; 
    28002873                                        } 
    28012874                                        if ( special.remove ) { 
     
    28072880                        // Remove generic event handler if we removed something and no more handlers exist 
    28082881                        // (avoids potential for endless recursion during removal of special event handlers) 
    2809                         if ( eventType.length === 0 && origCount !== eventType.length ) { 
     2882                        if ( origCount && !handlers.length ) { 
    28102883                                if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) { 
    28112884                                        jQuery.removeEvent( elem, type, elemData.handle ); 
     
    28222895                        // removeData also checks for emptiness and clears the expando if empty 
    28232896                        // so use it instead of delete 
    2824                         jQuery.removeData( elem, "events", true ); 
    2825                 } 
    2826         }, 
    2827  
    2828         // Events that are safe to short-circuit if no handlers are attached. 
    2829         // Native DOM events should not be added, they may have inline handlers. 
    2830         customEvent: { 
    2831                 "getData": true, 
    2832                 "setData": true, 
    2833                 "changeData": true 
     2897                        jQuery._removeData( elem, "events" ); 
     2898                } 
    28342899        }, 
    28352900 
    28362901        trigger: function( event, data, elem, onlyHandlers ) { 
     2902                var handle, ontype, cur, 
     2903                        bubbleType, special, tmp, i, 
     2904                        eventPath = [ elem || document ], 
     2905                        type = core_hasOwn.call( event, "type" ) ? event.type : event, 
     2906                        namespaces = core_hasOwn.call( event, "namespace" ) ? event.namespace.split(".") : []; 
     2907 
     2908                cur = tmp = elem = elem || document; 
     2909 
    28372910                // Don't do events on text and comment nodes 
    2838                 if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) { 
     2911                if ( elem.nodeType === 3 || elem.nodeType === 8 ) { 
    28392912                        return; 
    28402913                } 
    2841  
    2842                 // Event object or event type 
    2843                 var cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType, 
    2844                         type = event.type || event, 
    2845                         namespaces = []; 
    28462914 
    28472915                // focus/blur morphs to focusin/out; ensure we're not firing them right now 
     
    28502918                } 
    28512919 
    2852                 if ( type.indexOf( "!" ) >= 0 ) { 
    2853                         // Exclusive events trigger only for the exact event (no namespaces) 
    2854                         type = type.slice(0, -1); 
    2855                         exclusive = true; 
    2856                 } 
    2857  
    2858                 if ( type.indexOf( "." ) >= 0 ) { 
     2920                if ( type.indexOf(".") >= 0 ) { 
    28592921                        // Namespaced trigger; create a regexp to match event type in handle() 
    28602922                        namespaces = type.split("."); 
     
    28622924                        namespaces.sort(); 
    28632925                } 
    2864  
    2865                 if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) { 
    2866                         // No jQuery handlers for this event type, and it can't have inline handlers 
    2867                         return; 
    2868                 } 
    2869  
    2870                 // Caller can pass in an Event, Object, or just an event type string 
    2871                 event = typeof event === "object" ? 
    2872                         // jQuery.Event object 
    2873                         event[ jQuery.expando ] ? event : 
    2874                         // Object literal 
    2875                         new jQuery.Event( type, event ) : 
    2876                         // Just the event type (string) 
    2877                         new jQuery.Event( type ); 
    2878  
    2879                 event.type = type; 
     2926                ontype = type.indexOf(":") < 0 && "on" + type; 
     2927 
     2928                // Caller can pass in a jQuery.Event object, Object, or just an event type string 
     2929                event = event[ jQuery.expando ] ? 
     2930                        event : 
     2931                        new jQuery.Event( type, typeof event === "object" && event ); 
     2932 
    28802933                event.isTrigger = true; 
    2881                 event.exclusive = exclusive; 
    2882                 event.namespace = namespaces.join( "." ); 
    2883                 event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null; 
    2884                 ontype = type.indexOf( ":" ) < 0 ? "on" + type : ""; 
    2885  
    2886                 // Handle a global trigger 
    2887                 if ( !elem ) { 
    2888  
    2889                         // TODO: Stop taunting the data cache; remove global events and always attach to document 
    2890                         cache = jQuery.cache; 
    2891                         for ( i in cache ) { 
    2892                                 if ( cache[ i ].events && cache[ i ].events[ type ] ) { 
    2893                                         jQuery.event.trigger( event, data, cache[ i ].handle.elem, true ); 
    2894                                 } 
    2895                         } 
    2896                         return; 
    2897                 } 
     2934                event.namespace = namespaces.join("."); 
     2935                event.namespace_re = event.namespace ? 
     2936                        new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ) : 
     2937                        null; 
    28982938 
    28992939                // Clean up the event in case it is being reused 
     
    29042944 
    29052945                // Clone any incoming data and prepend the event, creating the handler arg list 
    2906                 data = data != null ? jQuery.makeArray( data ) : []; 
    2907                 data.unshift( event ); 
     2946                data = data == null ? 
     2947                        [ event ] : 
     2948                        jQuery.makeArray( data, [ event ] ); 
    29082949 
    29092950                // Allow special events to draw outside the lines 
    29102951                special = jQuery.event.special[ type ] || {}; 
    2911                 if ( special.trigger && special.trigger.apply( elem, data ) === false ) { 
     2952                if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { 
    29122953                        return; 
    29132954                } 
     
    29152956                // Determine event propagation path in advance, per W3C events spec (#9951) 
    29162957                // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) 
    2917                 eventPath = [[ elem, special.bindType || type ]]; 
    29182958                if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) { 
    29192959 
    29202960                        bubbleType = special.delegateType || type; 
    2921                         cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode; 
    2922                         for ( old = elem; cur; cur = cur.parentNode ) { 
    2923                                 eventPath.push([ cur, bubbleType ]); 
    2924                                 old = cur; 
     2961                        if ( !rfocusMorph.test( bubbleType + type ) ) { 
     2962                                cur = cur.parentNode; 
     2963                        } 
     2964                        for ( ; cur; cur = cur.parentNode ) { 
     2965                                eventPath.push( cur ); 
     2966                                tmp = cur; 
    29252967                        } 
    29262968 
    29272969                        // Only add window if we got to document (e.g., not plain obj or detached DOM) 
    2928                         if ( old === (elem.ownerDocument || document) ) { 
    2929                                 eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]); 
     2970                        if ( tmp === (elem.ownerDocument || document) ) { 
     2971                                eventPath.push( tmp.defaultView || tmp.parentWindow || window ); 
    29302972                        } 
    29312973                } 
    29322974 
    29332975                // Fire handlers on the event path 
    2934                 for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) { 
    2935  
    2936                         cur = eventPath[i][0]; 
    2937                         event.type = eventPath[i][1]; 
    2938  
     2976                i = 0; 
     2977                while ( (cur = eventPath[i++]) && !event.isPropagationStopped() ) { 
     2978 
     2979                        event.type = i > 1 ? 
     2980                                bubbleType : 
     2981                                special.bindType || type; 
     2982 
     2983                        // jQuery handler 
    29392984                        handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" ); 
    29402985                        if ( handle ) { 
    29412986                                handle.apply( cur, data ); 
    29422987                        } 
    2943                         // Note that this is a bare JS function and not a jQuery handler 
     2988 
     2989                        // Native handler 
    29442990                        handle = ontype && cur[ ontype ]; 
    29452991                        if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === false ) { 
     
    29583004                                // Can't use an .isFunction() check here because IE6/7 fails that test. 
    29593005                                // Don't do default actions on window, that's where global variables be (#6170) 
    2960                                 // IE<9 dies on focus/blur to hidden element (#1486) 
    2961                                 if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) { 
     3006                                if ( ontype && elem[ type ] && !jQuery.isWindow( elem ) ) { 
    29623007 
    29633008                                        // Don't re-trigger an onFOO event when we call its FOO() method 
    2964                                         old = elem[ ontype ]; 
    2965  
    2966                                         if ( old ) { 
     3009                                        tmp = elem[ ontype ]; 
     3010 
     3011                                        if ( tmp ) { 
    29673012                                                elem[ ontype ] = null; 
    29683013                                        } 
     
    29703015                                        // Prevent re-triggering of the same event, since we already bubbled it above 
    29713016                                        jQuery.event.triggered = type; 
    2972                                         elem[ type ](); 
     3017                                        try { 
     3018                                                elem[ type ](); 
     3019                                        } catch ( e ) { 
     3020                                                // IE<9 dies on focus/blur to hidden element (#1486,#12518) 
     3021                                                // only reproducible on winXP IE8 native, not IE9 in IE8 mode 
     3022                                        } 
    29733023                                        jQuery.event.triggered = undefined; 
    29743024 
    2975                                         if ( old ) { 
    2976                                                 elem[ ontype ] = old; 
     3025                                        if ( tmp ) { 
     3026                                                elem[ ontype ] = tmp; 
    29773027                                        } 
    29783028                                } 
     
    29863036 
    29873037                // Make a writable jQuery.Event from the native event object 
    2988                 event = jQuery.event.fix( event || window.event ); 
    2989  
    2990                 var i, j, cur, ret, selMatch, matched, matches, handleObj, sel, related, 
    2991                         handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []), 
    2992                         delegateCount = handlers.delegateCount, 
     3038                event = jQuery.event.fix( event ); 
     3039 
     3040                var i, ret, handleObj, matched, j, 
     3041                        handlerQueue = [], 
    29933042                        args = core_slice.call( arguments ), 
    2994                         run_all = !event.exclusive && !event.namespace, 
    2995                         special = jQuery.event.special[ event.type ] || {}, 
    2996                         handlerQueue = []; 
     3043                        handlers = ( jQuery._data( this, "events" ) || {} )[ event.type ] || [], 
     3044                        special = jQuery.event.special[ event.type ] || {}; 
    29973045 
    29983046                // Use the fix-ed jQuery.Event rather than the (read-only) native event 
     
    30053053                } 
    30063054 
    3007                 // Determine handlers that should run if there are delegated events 
     3055                // Determine handlers 
     3056                handlerQueue = jQuery.event.handlers.call( this, event, handlers ); 
     3057 
     3058                // Run delegates first; they may want to stop propagation beneath us 
     3059                i = 0; 
     3060                while ( (matched = handlerQueue[ i++ ]) && !event.isPropagationStopped() ) { 
     3061                        event.currentTarget = matched.elem; 
     3062 
     3063                        j = 0; 
     3064                        while ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) { 
     3065 
     3066                                // Triggered event must either 1) have no namespace, or 
     3067                                // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace). 
     3068                                if ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) { 
     3069 
     3070                                        event.handleObj = handleObj; 
     3071                                        event.data = handleObj.data; 
     3072 
     3073                                        ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler ) 
     3074                                                        .apply( matched.elem, args ); 
     3075 
     3076                                        if ( ret !== undefined ) { 
     3077                                                if ( (event.result = ret) === false ) { 
     3078                                                        event.preventDefault(); 
     3079                                                        event.stopPropagation(); 
     3080                                                } 
     3081                                        } 
     3082                                } 
     3083                        } 
     3084                } 
     3085 
     3086                // Call the postDispatch hook for the mapped type 
     3087                if ( special.postDispatch ) { 
     3088                        special.postDispatch.call( this, event ); 
     3089                } 
     3090 
     3091                return event.result; 
     3092        }, 
     3093 
     3094        handlers: function( event, handlers ) { 
     3095                var sel, handleObj, matches, i, 
     3096                        handlerQueue = [], 
     3097                        delegateCount = handlers.delegateCount, 
     3098                        cur = event.target; 
     3099 
     3100                // Find delegate handlers 
     3101                // Black-hole SVG <use> instance trees (#13180) 
    30083102                // Avoid non-left-click bubbling in Firefox (#3861) 
    3009                 if ( delegateCount && !(event.button && event.type === "click") ) { 
    3010  
    3011                         for ( cur = event.target; cur != this; cur = cur.parentNode || this ) { 
    3012  
    3013                                 // Don't process clicks (ONLY) on disabled elements (#6911, #8165, #11382, #11764) 
    3014                                 if ( cur.disabled !== true || event.type !== "click" ) { 
    3015                                         selMatch = {}; 
     3103                if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) { 
     3104 
     3105                        for ( ; cur != this; cur = cur.parentNode || this ) { 
     3106 
     3107                                // Don't check non-elements (#13208) 
     3108                                // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764) 
     3109                                if ( cur.nodeType === 1 && (cur.disabled !== true || event.type !== "click") ) { 
    30163110                                        matches = []; 
    30173111                                        for ( i = 0; i < delegateCount; i++ ) { 
    30183112                                                handleObj = handlers[ i ]; 
    3019                                                 sel = handleObj.selector; 
    3020  
    3021                                                 if ( selMatch[ sel ] === undefined ) { 
    3022                                                         selMatch[ sel ] = handleObj.needsContext ? 
     3113 
     3114                                                // Don't conflict with Object.prototype properties (#13203) 
     3115                                                sel = handleObj.selector + " "; 
     3116 
     3117                                                if ( matches[ sel ] === undefined ) { 
     3118                                                        matches[ sel ] = handleObj.needsContext ? 
    30233119                                                                jQuery( sel, this ).index( cur ) >= 0 : 
    30243120                                                                jQuery.find( sel, this, null, [ cur ] ).length; 
    30253121                                                } 
    3026                                                 if ( selMatch[ sel ] ) { 
     3122                                                if ( matches[ sel ] ) { 
    30273123                                                        matches.push( handleObj ); 
    30283124                                                } 
    30293125                                        } 
    30303126                                        if ( matches.length ) { 
    3031                                                 handlerQueue.push({ elem: cur, matches: matches }); 
     3127                                                handlerQueue.push({ elem: cur, handlers: matches }); 
    30323128                                        } 
    30333129                                } 
     
    30363132 
    30373133                // Add the remaining (directly-bound) handlers 
    3038                 if ( handlers.length > delegateCount ) { 
    3039                         handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) }); 
    3040                 } 
    3041  
    3042                 // Run delegates first; they may want to stop propagation beneath us 
    3043                 for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) { 
    3044                         matched = handlerQueue[ i ]; 
    3045                         event.currentTarget = matched.elem; 
    3046  
    3047                         for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) { 
    3048                                 handleObj = matched.matches[ j ]; 
    3049  
    3050                                 // Triggered event must either 1) be non-exclusive and have no namespace, or 
    3051                                 // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace). 
    3052                                 if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) { 
    3053  
    3054                                         event.data = handleObj.data; 
    3055                                         event.handleObj = handleObj; 
    3056  
    3057                                         ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler ) 
    3058                                                         .apply( matched.elem, args ); 
    3059  
    3060                                         if ( ret !== undefined ) { 
    3061                                                 event.result = ret; 
    3062                                                 if ( ret === false ) { 
    3063                                                         event.preventDefault(); 
    3064                                                         event.stopPropagation(); 
    3065                                                 } 
    3066                                         } 
    3067                                 } 
    3068                         } 
    3069                 } 
    3070  
    3071                 // Call the postDispatch hook for the mapped type 
    3072                 if ( special.postDispatch ) { 
    3073                         special.postDispatch.call( this, event ); 
    3074                 } 
    3075  
    3076                 return event.result; 
     3134                if ( delegateCount < handlers.length ) { 
     3135                        handlerQueue.push({ elem: this, handlers: handlers.slice( delegateCount ) }); 
     3136                } 
     3137 
     3138                return handlerQueue; 
     3139        }, 
     3140 
     3141        fix: function( event ) { 
     3142                if ( event[ jQuery.expando ] ) { 
     3143                        return event; 
     3144                } 
     3145 
     3146                // Create a writable copy of the event object and normalize some properties 
     3147                var i, prop, copy, 
     3148                        type = event.type, 
     3149                        originalEvent = event, 
     3150                        fixHook = this.fixHooks[ type ]; 
     3151 
     3152                if ( !fixHook ) { 
     3153                        this.fixHooks[ type ] = fixHook = 
     3154                                rmouseEvent.test( type ) ? this.mouseHooks : 
     3155                                rkeyEvent.test( type ) ? this.keyHooks : 
     3156                                {}; 
     3157                } 
     3158                copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props; 
     3159 
     3160                event = new jQuery.Event( originalEvent ); 
     3161 
     3162                i = copy.length; 
     3163                while ( i-- ) { 
     3164                        prop = copy[ i ]; 
     3165                        event[ prop ] = originalEvent[ prop ]; 
     3166                } 
     3167 
     3168                // Support: IE<9 
     3169                // Fix target property (#1925) 
     3170                if ( !event.target ) { 
     3171                        event.target = originalEvent.srcElement || document; 
     3172                } 
     3173 
     3174                // Support: Chrome 23+, Safari? 
     3175                // Target should not be a text node (#504, #13143) 
     3176                if ( event.target.nodeType === 3 ) { 
     3177                        event.target = event.target.parentNode; 
     3178                } 
     3179 
     3180                // Support: IE<9 
     3181                // For mouse/key events, metaKey==false if it's undefined (#3368, #11328) 
     3182                event.metaKey = !!event.metaKey; 
     3183 
     3184                return fixHook.filter ? fixHook.filter( event, originalEvent ) : event; 
    30773185        }, 
    30783186 
    30793187        // Includes some event props shared by KeyEvent and MouseEvent 
    3080         // *** attrChange attrName relatedNode srcElement  are not normalized, non-W3C, deprecated, will be removed in 1.8 *** 
    3081         props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "), 
     3188        props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "), 
    30823189 
    30833190        fixHooks: {}, 
     
    30993206                props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "), 
    31003207                filter: function( event, original ) { 
    3101                         var eventDoc, doc, body, 
     3208                        var body, eventDoc, doc, 
    31023209                                button = original.button, 
    31033210                                fromElement = original.fromElement; 
     
    31283235        }, 
    31293236 
    3130         fix: function( event ) { 
    3131                 if ( event[ jQuery.expando ] ) { 
    3132                         return event; 
    3133                 } 
    3134  
    3135                 // Create a writable copy of the event object and normalize some properties 
    3136                 var i, prop, 
    3137                         originalEvent = event, 
    3138                         fixHook = jQuery.event.fixHooks[ event.type ] || {}, 
    3139                         copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props; 
    3140  
    3141                 event = jQuery.Event( originalEvent ); 
    3142  
    3143                 for ( i = copy.length; i; ) { 
    3144                         prop = copy[ --i ]; 
    3145                         event[ prop ] = originalEvent[ prop ]; 
    3146                 } 
    3147  
    3148                 // Fix target property, if necessary (#1925, IE 6/7/8 & Safari2) 
    3149                 if ( !event.target ) { 
    3150                         event.target = originalEvent.srcElement || document; 
    3151                 } 
    3152  
    3153                 // Target should not be a text node (#504, Safari) 
    3154                 if ( event.target.nodeType === 3 ) { 
    3155                         event.target = event.target.parentNode; 
    3156                 } 
    3157  
    3158                 // For mouse/key events, metaKey==false if it's undefined (#3368, #11328; IE6/7/8) 
    3159                 event.metaKey = !!event.metaKey; 
    3160  
    3161                 return fixHook.filter? fixHook.filter( event, originalEvent ) : event; 
    3162         }, 
    3163  
    31643237        special: { 
    31653238                load: { 
     
    31673240                        noBubble: true 
    31683241                }, 
    3169  
     3242                click: { 
     3243                        // For checkbox, fire native event so checked state will be right 
     3244                        trigger: function() { 
     3245                                if ( jQuery.nodeName( this, "input" ) && this.type === "checkbox" && this.click ) { 
     3246                                        this.click(); 
     3247                                        return false; 
     3248                                } 
     3249                        } 
     3250                }, 
    31703251                focus: { 
     3252                        // Fire native event if possible so blur/focus sequence is correct 
     3253                        trigger: function() { 
     3254                                if ( this !== document.activeElement && this.focus ) { 
     3255                                        try { 
     3256                                                this.focus(); 
     3257                                                return false; 
     3258                                        } catch ( e ) { 
     3259                                                // Support: IE<9 
     3260                                                // If we error on focus to hidden element (#1486, #12518), 
     3261                                                // let .trigger() run the handlers 
     3262                                        } 
     3263                                } 
     3264                        }, 
    31713265                        delegateType: "focusin" 
    31723266                }, 
    31733267                blur: { 
     3268                        trigger: function() { 
     3269                                if ( this === document.activeElement && this.blur ) { 
     3270                                        this.blur(); 
     3271                                        return false; 
     3272                                } 
     3273                        }, 
    31743274                        delegateType: "focusout" 
    31753275                }, 
    31763276 
    31773277                beforeunload: { 
    3178                         setup: function( data, namespaces, eventHandle ) { 
    3179                                 // We only want to do this special case on windows 
    3180                                 if ( jQuery.isWindow( this ) ) { 
    3181                                         this.onbeforeunload = eventHandle; 
    3182                                 } 
    3183                         }, 
    3184  
    3185                         teardown: function( namespaces, eventHandle ) { 
    3186                                 if ( this.onbeforeunload === eventHandle ) { 
    3187                                         this.onbeforeunload = null; 
     3278                        postDispatch: function( event ) { 
     3279 
     3280                                // Even when returnValue equals to undefined Firefox will still show alert 
     3281                                if ( event.result !== undefined ) { 
     3282                                        event.originalEvent.returnValue = event.result; 
    31883283                                } 
    31893284                        } 
     
    32143309}; 
    32153310 
    3216 // Some plugins are using, but it's undocumented/deprecated and will be removed. 
    3217 // The 1.7 special event interface should provide all the hooks needed now. 
    3218 jQuery.event.handle = jQuery.event.dispatch; 
    3219  
    32203311jQuery.removeEvent = document.removeEventListener ? 
    32213312        function( elem, type, handle ) { 
     
    32313322                        // #8545, #7054, preventing memory leaks for custom events in IE6-8 
    32323323                        // detachEvent needed property on element, by name of that event, to properly expose it to GC 
    3233                         if ( typeof elem[ name ] === "undefined" ) { 
     3324                        if ( typeof elem[ name ] === core_strundefined ) { 
    32343325                                elem[ name ] = null; 
    32353326                        } 
     
    32723363}; 
    32733364 
    3274 function returnFalse() { 
    3275         return false; 
    3276 } 
    3277 function returnTrue() { 
    3278         return true; 
    3279 } 
    3280  
    32813365// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding 
    32823366// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html 
    32833367jQuery.Event.prototype = { 
     3368        isDefaultPrevented: returnFalse, 
     3369        isPropagationStopped: returnFalse, 
     3370        isImmediatePropagationStopped: returnFalse, 
     3371 
    32843372        preventDefault: function() { 
     3373                var e = this.originalEvent; 
     3374 
    32853375                this.isDefaultPrevented = returnTrue; 
    3286  
    3287                 var e = this.originalEvent; 
    32883376                if ( !e ) { 
    32893377                        return; 
    32903378                } 
    32913379 
    3292                 // if preventDefault exists run it on the original event 
     3380                // If preventDefault exists, run it on the original event 
    32933381                if ( e.preventDefault ) { 
    32943382                        e.preventDefault(); 
    32953383 
    3296                 // otherwise set the returnValue property of the original event to false (IE) 
     3384                // Support: IE 
     3385                // Otherwise set the returnValue property of the original event to false 
    32973386                } else { 
    32983387                        e.returnValue = false; 
     
    33003389        }, 
    33013390        stopPropagation: function() { 
     3391                var e = this.originalEvent; 
     3392 
    33023393                this.isPropagationStopped = returnTrue; 
    3303  
    3304                 var e = this.originalEvent; 
    33053394                if ( !e ) { 
    33063395                        return; 
    33073396                } 
    3308                 // if stopPropagation exists run it on the original event 
     3397                // If stopPropagation exists, run it on the original event 
    33093398                if ( e.stopPropagation ) { 
    33103399                        e.stopPropagation(); 
    33113400                } 
    3312                 // otherwise set the cancelBubble property of the original event to true (IE) 
     3401 
     3402                // Support: IE 
     3403                // Set the cancelBubble property of the original event to true 
    33133404                e.cancelBubble = true; 
    33143405        }, 
     
    33163407                this.isImmediatePropagationStopped = returnTrue; 
    33173408                this.stopPropagation(); 
    3318         }, 
    3319         isDefaultPrevented: returnFalse, 
    3320         isPropagationStopped: returnFalse, 
    3321         isImmediatePropagationStopped: returnFalse 
     3409        } 
    33223410}; 
    33233411 
     
    33353423                                target = this, 
    33363424                                related = event.relatedTarget, 
    3337                                 handleObj = event.handleObj, 
    3338                                 selector = handleObj.selector; 
     3425                                handleObj = event.handleObj; 
    33393426 
    33403427                        // For mousenter/leave call the handler if related is outside the target. 
     
    33653452                                var elem = e.target, 
    33663453                                        form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined; 
    3367                                 if ( form && !jQuery._data( form, "_submit_attached" ) ) { 
     3454                                if ( form && !jQuery._data( form, "submitBubbles" ) ) { 
    33683455                                        jQuery.event.add( form, "submit._submit", function( event ) { 
    33693456                                                event._submit_bubble = true; 
    33703457                                        }); 
    3371                                         jQuery._data( form, "_submit_attached", true ); 
     3458                                        jQuery._data( form, "submitBubbles", true ); 
    33723459                                } 
    33733460                        }); 
     
    34283515                                var elem = e.target; 
    34293516 
    3430                                 if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "_change_attached" ) ) { 
     3517                                if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "changeBubbles" ) ) { 
    34313518                                        jQuery.event.add( elem, "change._change", function( event ) { 
    34323519                                                if ( this.parentNode && !event.isSimulated && !event.isTrigger ) { 
     
    34343521                                                } 
    34353522                                        }); 
    3436                                         jQuery._data( elem, "_change_attached", true ); 
     3523                                        jQuery._data( elem, "changeBubbles", true ); 
    34373524                                } 
    34383525                        }); 
     
    34843571 
    34853572        on: function( types, selector, data, fn, /*INTERNAL*/ one ) { 
    3486                 var origFn, type; 
     3573                var type, origFn; 
    34873574 
    34883575                // Types can be a map of types/handlers 
    34893576                if ( typeof types === "object" ) { 
    34903577                        // ( types-Object, selector, data ) 
    3491                         if ( typeof selector !== "string" ) { // && selector != null 
     3578                        if ( typeof selector !== "string" ) { 
    34923579                                // ( types-Object, data ) 
    34933580                                data = data || selector; 
     
    35783665        }, 
    35793666 
    3580         live: function( types, data, fn ) { 
    3581                 jQuery( this.context ).on( types, this.selector, data, fn ); 
    3582                 return this; 
    3583         }, 
    3584         die: function( types, fn ) { 
    3585                 jQuery( this.context ).off( types, this.selector || "**", fn ); 
    3586                 return this; 
    3587         }, 
    3588  
    35893667        delegate: function( selector, types, data, fn ) { 
    35903668                return this.on( types, selector, data, fn ); 
     
    36013679        }, 
    36023680        triggerHandler: function( type, data ) { 
    3603                 if ( this[0] ) { 
    3604                         return jQuery.event.trigger( type, data, this[0], true ); 
    3605                 } 
    3606         }, 
    3607  
    3608         toggle: function( fn ) { 
    3609                 // Save reference to arguments for access in closure 
    3610                 var args = arguments, 
    3611                         guid = fn.guid || jQuery.guid++, 
    3612                         i = 0, 
    3613                         toggler = function( event ) { 
    3614                                 // Figure out which function to execute 
    3615                                 var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i; 
    3616                                 jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 ); 
    3617  
    3618                                 // Make sure that clicks stop 
    3619                                 event.preventDefault(); 
    3620  
    3621                                 // and execute the function 
    3622                                 return args[ lastToggle ].apply( this, arguments ) || false; 
    3623                         }; 
    3624  
    3625                 // link all the functions, so any of them can unbind this click handler 
    3626                 toggler.guid = guid; 
    3627                 while ( i < args.length ) { 
    3628                         args[ i++ ].guid = guid; 
    3629                 } 
    3630  
    3631                 return this.click( toggler ); 
    3632         }, 
    3633  
    3634         hover: function( fnOver, fnOut ) { 
    3635                 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver ); 
    3636         } 
    3637 }); 
    3638  
    3639 jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " + 
    3640         "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + 
    3641         "change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) { 
    3642  
    3643         // Handle event binding 
    3644         jQuery.fn[ name ] = function( data, fn ) { 
    3645                 if ( fn == null ) { 
    3646                         fn = data; 
    3647                         data = null; 
    3648                 } 
    3649  
    3650                 return arguments.length > 0 ? 
    3651                         this.on( name, null, data, fn ) : 
    3652                         this.trigger( name ); 
    3653         }; 
    3654  
    3655         if ( rkeyEvent.test( name ) ) { 
    3656                 jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks; 
    3657         } 
    3658  
    3659         if ( rmouseEvent.test( name ) ) { 
    3660                 jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks; 
     3681                var elem = this[0]; 
     3682                if ( elem ) { 
     3683                        return jQuery.event.trigger( type, data, elem, true ); 
     3684                } 
    36613685        } 
    36623686}); 
     
    36693693(function( window, undefined ) { 
    36703694 
    3671 var cachedruns, 
    3672         assertGetIdNotName, 
     3695var i, 
     3696        cachedruns, 
    36733697        Expr, 
    36743698        getText, 
    36753699        isXML, 
    3676         contains, 
    36773700        compile, 
    3678         sortOrder, 
    36793701        hasDuplicate, 
    36803702        outermostContext, 
    36813703 
    3682         baseHasDuplicate = true, 
    3683         strundefined = "undefined", 
    3684  
    3685         expando = ( "sizcache" + Math.random() ).replace( ".", "" ), 
    3686  
    3687         Token = String, 
    3688         document = window.document, 
    3689         docElem = document.documentElement, 
     3704        // Local document vars 
     3705        setDocument, 
     3706        document, 
     3707        docElem, 
     3708        documentIsXML, 
     3709        rbuggyQSA, 
     3710        rbuggyMatches, 
     3711        matches, 
     3712        contains, 
     3713        sortOrder, 
     3714 
     3715        // Instance-specific data 
     3716        expando = "sizzle" + -(new Date()), 
     3717        preferredDoc = window.document, 
     3718        support = {}, 
    36903719        dirruns = 0, 
    36913720        done = 0, 
    3692         pop = [].pop, 
    3693         push = [].push, 
    3694         slice = [].slice, 
    3695         // Use a stripped-down indexOf if a native one is unavailable 
    3696         indexOf = [].indexOf || function( elem ) { 
     3721        classCache = createCache(), 
     3722        tokenCache = createCache(), 
     3723        compilerCache = createCache(), 
     3724 
     3725        // General-purpose constants 
     3726        strundefined = typeof undefined, 
     3727        MAX_NEGATIVE = 1 << 31, 
     3728 
     3729        // Array methods 
     3730        arr = [], 
     3731        pop = arr.pop, 
     3732        push = arr.push, 
     3733        slice = arr.slice, 
     3734        // Use a stripped-down indexOf if we can't use a native one 
     3735        indexOf = arr.indexOf || function( elem ) { 
    36973736                var i = 0, 
    36983737                        len = this.length; 
     
    37053744        }, 
    37063745 
    3707         // Augment a function for special use by Sizzle 
    3708         markFunction = function( fn, value ) { 
    3709                 fn[ expando ] = value == null || value; 
    3710                 return fn; 
    3711         }, 
    3712  
    3713         createCache = function() { 
    3714                 var cache = {}, 
    3715                         keys = []; 
    3716  
    3717                 return markFunction(function( key, value ) { 
    3718                         // Only keep the most recent entries 
    3719                         if ( keys.push( key ) > Expr.cacheLength ) { 
    3720                                 delete cache[ keys.shift() ]; 
    3721                         } 
    3722  
    3723                         // Retrieve with (key + " ") to avoid collision with native Object.prototype properties (see Issue #157) 
    3724                         return (cache[ key + " " ] = value); 
    3725                 }, cache ); 
    3726         }, 
    3727  
    3728         classCache = createCache(), 
    3729         tokenCache = createCache(), 
    3730         compilerCache = createCache(), 
    3731  
    3732         // Regex 
     3746 
     3747        // Regular expressions 
    37333748 
    37343749        // Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace 
    37353750        whitespace = "[\\x20\\t\\r\\n\\f]", 
    37363751        // http://www.w3.org/TR/css3-syntax/#characters 
    3737         characterEncoding = "(?:\\\\.|[-\\w]|[^\\x00-\\xa0])+", 
     3752        characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+", 
    37383753 
    37393754        // Loosely modeled on CSS identifier characters 
    3740         // An unquoted value should be a CSS identifier (http://www.w3.org/TR/css3-selectors/#attribute-selectors) 
     3755        // An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors 
    37413756        // Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier 
    37423757        identifier = characterEncoding.replace( "w", "w#" ), 
     
    37473762                "*(?:" + operators + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]", 
    37483763 
    3749         // Prefer arguments not in parens/brackets, 
    3750         //   then attribute selectors and non-pseudos (denoted by :), 
     3764        // Prefer arguments quoted, 
     3765        //   then not containing pseudos/brackets, 
     3766        //   then attribute selectors/non-parenthetical expressions, 
    37513767        //   then anything else 
    37523768        // These preferences are here to reduce the number of selectors 
    37533769        //   needing tokenize in the PSEUDO preFilter 
    3754         pseudos = ":(" + characterEncoding + ")(?:\\((?:(['\"])((?:\\\\.|[^\\\\])*?)\\2|([^()[\\]]*|(?:(?:" + attributes + ")|[^:]|\\\\.)*|.*))\\)|)", 
    3755  
    3756         // For matchExpr.POS and matchExpr.needsContext 
    3757         pos = ":(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + 
    3758                 "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", 
     3770        pseudos = ":(" + characterEncoding + ")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" + attributes.replace( 3, 8 ) + ")*)|.*)\\)|)", 
    37593771 
    37603772        // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter 
     
    37643776        rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ), 
    37653777        rpseudo = new RegExp( pseudos ), 
    3766  
    3767         // Easily-parseable/retrievable ID or TAG or CLASS selectors 
    3768         rquickExpr = /^(?:#([\w\-]+)|(\w+)|\.([\w\-]+))$/, 
    3769  
    3770         rnot = /^:not/, 
    3771         rsibling = /[\x20\t\r\n\f]*[+~]/, 
    3772         rendsWithNot = /:not\($/, 
    3773  
    3774         rheader = /h\d/i, 
    3775         rinputs = /input|select|textarea|button/i, 
    3776  
    3777         rbackslash = /\\(?!\\)/g, 
     3778        ridentifier = new RegExp( "^" + identifier + "$" ), 
    37783779 
    37793780        matchExpr = { 
     
    37843785                "ATTR": new RegExp( "^" + attributes ), 
    37853786                "PSEUDO": new RegExp( "^" + pseudos ), 
    3786                 "POS": new RegExp( pos, "i" ), 
    3787                 "CHILD": new RegExp( "^:(only|nth|first|last)-child(?:\\(" + whitespace + 
     3787                "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + 
    37883788                        "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + 
    37893789                        "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), 
    37903790                // For use in libraries implementing .is() 
    3791                 "needsContext": new RegExp( "^" + whitespace + "*[>+~]|" + pos, "i" ) 
    3792         }, 
    3793  
    3794         // Support 
    3795  
    3796         // Used for testing something on an element 
    3797         assert = function( fn ) { 
    3798                 var div = document.createElement("div"); 
    3799  
    3800                 try { 
    3801                         return fn( div ); 
    3802                 } catch (e) { 
    3803                         return false; 
    3804                 } finally { 
    3805                         // release memory in IE 
    3806                         div = null; 
    3807                 } 
    3808         }, 
    3809  
    3810         // Check if getElementsByTagName("*") returns only elements 
    3811         assertTagNameNoComments = assert(function( div ) { 
    3812                 div.appendChild( document.createComment("") ); 
    3813                 return !div.getElementsByTagName("*").length; 
    3814         }), 
    3815  
    3816         // Check if getAttribute returns normalized href attributes 
    3817         assertHrefNotNormalized = assert(function( div ) { 
    3818                 div.innerHTML = "<a href='#'></a>"; 
    3819                 return div.firstChild && typeof div.firstChild.getAttribute !== strundefined && 
    3820                         div.firstChild.getAttribute("href") === "#"; 
    3821         }), 
    3822  
    3823         // Check if attributes should be retrieved by attribute nodes 
    3824         assertAttributes = assert(function( div ) { 
    3825                 div.innerHTML = "<select></select>"; 
    3826                 var type = typeof div.lastChild.getAttribute("multiple"); 
    3827                 // IE8 returns a string for some attributes even when not present 
    3828                 return type !== "boolean" && type !== "string"; 
    3829         }), 
    3830  
    3831         // Check if getElementsByClassName can be trusted 
    3832         assertUsableClassName = assert(function( div ) { 
    3833                 // Opera can't find a second classname (in 9.6) 
    3834                 div.innerHTML = "<div class='hidden e'></div><div class='hidden'></div>"; 
    3835                 if ( !div.getElementsByClassName || !div.getElementsByClassName("e").length ) { 
    3836                         return false; 
    3837                 } 
    3838  
    3839                 // Safari 3.2 caches class attributes and doesn't catch changes 
    3840                 div.lastChild.className = "e"; 
    3841                 return div.getElementsByClassName("e").length === 2; 
    3842         }), 
    3843  
    3844         // Check if getElementById returns elements by name 
    3845         // Check if getElementsByName privileges form controls or returns elements by ID 
    3846         assertUsableName = assert(function( div ) { 
    3847                 // Inject content 
    3848                 div.id = expando + 0; 
    3849                 div.innerHTML = "<a name='" + expando + "'></a><div name='" + expando + "'></div>"; 
    3850                 docElem.insertBefore( div, docElem.firstChild ); 
    3851  
    3852                 // Test 
    3853                 var pass = document.getElementsByName && 
    3854                         // buggy browsers will return fewer than the correct 2 
    3855                         document.getElementsByName( expando ).length === 2 + 
    3856                         // buggy browsers will return more than the correct 0 
    3857                         document.getElementsByName( expando + 0 ).length; 
    3858                 assertGetIdNotName = !document.getElementById( expando ); 
    3859  
    3860                 // Cleanup 
    3861                 docElem.removeChild( div ); 
    3862  
    3863                 return pass; 
    3864         }); 
    3865  
    3866 // If slice is not available, provide a backup 
     3791                // We use this for POS matching in `select` 
     3792                "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + 
     3793                        whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) 
     3794        }, 
     3795 
     3796        rsibling = /[\x20\t\r\n\f]*[+~]/, 
     3797 
     3798        rnative = /^[^{]+\{\s*\[native code/, 
     3799 
     3800        // Easily-parseable/retrievable ID or TAG or CLASS selectors 
     3801        rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, 
     3802 
     3803        rinputs = /^(?:input|select|textarea|button)$/i, 
     3804        rheader = /^h\d$/i, 
     3805 
     3806        rescape = /'|\\/g, 
     3807        rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g, 
     3808 
     3809        // CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters 
     3810        runescape = /\\([\da-fA-F]{1,6}[\x20\t\r\n\f]?|.)/g, 
     3811        funescape = function( _, escaped ) { 
     3812                var high = "0x" + escaped - 0x10000; 
     3813                // NaN means non-codepoint 
     3814                return high !== high ? 
     3815                        escaped : 
     3816                        // BMP codepoint 
     3817                        high < 0 ? 
     3818                                String.fromCharCode( high + 0x10000 ) : 
     3819                                // Supplemental Plane codepoint (surrogate pair) 
     3820                                String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); 
     3821        }; 
     3822 
     3823// Use a stripped-down slice if we can't use a native one 
    38673824try { 
    3868         slice.call( docElem.childNodes, 0 )[0].nodeType; 
     3825        slice.call( preferredDoc.documentElement.childNodes, 0 )[0].nodeType; 
    38693826} catch ( e ) { 
    38703827        slice = function( i ) { 
    38713828                var elem, 
    38723829                        results = []; 
    3873                 for ( ; (elem = this[i]); i++ ) { 
     3830                while ( (elem = this[i++]) ) { 
    38743831                        results.push( elem ); 
    38753832                } 
     
    38783835} 
    38793836 
     3837/** 
     3838 * For feature detection 
     3839 * @param {Function} fn The function to test for native support 
     3840 */ 
     3841function isNative( fn ) { 
     3842        return rnative.test( fn + "" ); 
     3843} 
     3844 
     3845/** 
     3846 * Create key-value caches of limited size 
     3847 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with 
     3848 *      property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) 
     3849 *      deleting the oldest entry 
     3850 */ 
     3851function createCache() { 
     3852        var cache, 
     3853                keys = []; 
     3854 
     3855        return (cache = function( key, value ) { 
     3856                // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) 
     3857                if ( keys.push( key += " " ) > Expr.cacheLength ) { 
     3858                        // Only keep the most recent entries 
     3859                        delete cache[ keys.shift() ]; 
     3860                } 
     3861                return (cache[ key ] = value); 
     3862        }); 
     3863} 
     3864 
     3865/** 
     3866 * Mark a function for special use by Sizzle 
     3867 * @param {Function} fn The function to mark 
     3868 */ 
     3869function markFunction( fn ) { 
     3870        fn[ expando ] = true; 
     3871        return fn; 
     3872} 
     3873 
     3874/** 
     3875 * Support testing using an element 
     3876 * @param {Function} fn Passed the created div and expects a boolean result 
     3877 */ 
     3878function assert( fn ) { 
     3879        var div = document.createElement("div"); 
     3880 
     3881        try { 
     3882                return fn( div ); 
     3883        } catch (e) { 
     3884                return false; 
     3885        } finally { 
     3886                // release memory in IE 
     3887                div = null; 
     3888        } 
     3889} 
     3890 
    38803891function Sizzle( selector, context, results, seed ) { 
     3892        var match, elem, m, nodeType, 
     3893                // QSA vars 
     3894                i, groups, old, nid, newContext, newSelector; 
     3895 
     3896        if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) { 
     3897                setDocument( context ); 
     3898        } 
     3899 
     3900        context = context || document; 
    38813901        results = results || []; 
    3882         context = context || document; 
    3883         var match, elem, xml, m, 
    3884                 nodeType = context.nodeType; 
    38853902 
    38863903        if ( !selector || typeof selector !== "string" ) { 
     
    38883905        } 
    38893906 
    3890         if ( nodeType !== 1 && nodeType !== 9 ) { 
     3907        if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) { 
    38913908                return []; 
    38923909        } 
    38933910 
    3894         xml = isXML( context ); 
    3895  
    3896         if ( !xml && !seed ) { 
     3911        if ( !documentIsXML && !seed ) { 
     3912 
     3913                // Shortcuts 
    38973914                if ( (match = rquickExpr.exec( selector )) ) { 
    38983915                        // Speed-up: Sizzle("#ID") 
     
    39273944 
    39283945                        // Speed-up: Sizzle(".CLASS") 
    3929                         } else if ( (m = match[3]) && assertUsableClassName && context.getElementsByClassName ) { 
     3946                        } else if ( (m = match[3]) && support.getByClassName && context.getElementsByClassName ) { 
    39303947                                push.apply( results, slice.call(context.getElementsByClassName( m ), 0) ); 
    39313948                                return results; 
    39323949                        } 
    39333950                } 
     3951 
     3952                // QSA path 
     3953                if ( support.qsa && !rbuggyQSA.test(selector) ) { 
     3954                        old = true; 
     3955                        nid = expando; 
     3956                        newContext = context; 
     3957                        newSelector = nodeType === 9 && selector; 
     3958 
     3959                        // qSA works strangely on Element-rooted queries 
     3960                        // We can work around this by specifying an extra ID on the root 
     3961                        // and working up from there (Thanks to Andrew Dupont for the technique) 
     3962                        // IE 8 doesn't work on object elements 
     3963                        if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) { 
     3964                                groups = tokenize( selector ); 
     3965 
     3966                                if ( (old = context.getAttribute("id")) ) { 
     3967                                        nid = old.replace( rescape, "\\$&" ); 
     3968                                } else { 
     3969                                        context.setAttribute( "id", nid ); 
     3970                                } 
     3971                                nid = "[id='" + nid + "'] "; 
     3972 
     3973                                i = groups.length; 
     3974                                while ( i-- ) { 
     3975                                        groups[i] = nid + toSelector( groups[i] ); 
     3976                                } 
     3977                                newContext = rsibling.test( selector ) && context.parentNode || context; 
     3978                                newSelector = groups.join(","); 
     3979                        } 
     3980 
     3981                        if ( newSelector ) { 
     3982                                try { 
     3983                                        push.apply( results, slice.call( newContext.querySelectorAll( 
     3984                                                newSelector 
     3985                                        ), 0 ) ); 
     3986                                        return results; 
     3987                                } catch(qsaError) { 
     3988                                } finally { 
     3989                                        if ( !old ) { 
     3990                                                context.removeAttribute("id"); 
     3991                                        } 
     3992                                } 
     3993                        } 
     3994                } 
    39343995        } 
    39353996 
    39363997        // All others 
    3937         return select( selector.replace( rtrim, "$1" ), context, results, seed, xml ); 
     3998        return select( selector.replace( rtrim, "$1" ), context, results, seed ); 
    39383999} 
     4000 
     4001/** 
     4002 * Detect xml 
     4003 * @param {Element|Object} elem An element or a document 
     4004 */ 
     4005isXML = Sizzle.isXML = function( elem ) { 
     4006        // documentElement is verified for cases where it doesn't yet exist 
     4007        // (such as loading iframes in IE - #4833) 
     4008        var documentElement = elem && (elem.ownerDocument || elem).documentElement; 
     4009        return documentElement ? documentElement.nodeName !== "HTML" : false; 
     4010}; 
     4011 
     4012/** 
     4013 * Sets document-related variables once based on the current document 
     4014 * @param {Element|Object} [doc] An element or document object to use to set the document 
     4015 * @returns {Object} Returns the current document 
     4016 */ 
     4017setDocument = Sizzle.setDocument = function( node ) { 
     4018        var doc = node ? node.ownerDocument || node : preferredDoc; 
     4019 
     4020        // If no document and documentElement is available, return 
     4021        if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) { 
     4022                return document; 
     4023        } 
     4024 
     4025        // Set our document 
     4026        document = doc; 
     4027        docElem = doc.documentElement; 
     4028 
     4029        // Support tests 
     4030        documentIsXML = isXML( doc ); 
     4031 
     4032        // Check if getElementsByTagName("*") returns only elements 
     4033        support.tagNameNoComments = assert(function( div ) { 
     4034                div.appendChild( doc.createComment("") ); 
     4035                return !div.getElementsByTagName("*").length; 
     4036        }); 
     4037 
     4038        // Check if attributes should be retrieved by attribute nodes 
     4039        support.attributes = assert(function( div ) { 
     4040                div.innerHTML = "<select></select>"; 
     4041                var type = typeof div.lastChild.getAttribute("multiple"); 
     4042                // IE8 returns a string for some attributes even when not present 
     4043                return type !== "boolean" && type !== "string"; 
     4044        }); 
     4045 
     4046        // Check if getElementsByClassName can be trusted 
     4047        support.getByClassName = assert(function( div ) { 
     4048                // Opera can't find a second classname (in 9.6) 
     4049                div.innerHTML = "<div class='hidden e'></div><div class='hidden'></div>"; 
     4050                if ( !div.getElementsByClassName || !div.getElementsByClassName("e").length ) { 
     4051                        return false; 
     4052                } 
     4053 
     4054                // Safari 3.2 caches class attributes and doesn't catch changes 
     4055                div.lastChild.className = "e"; 
     4056                return div.getElementsByClassName("e").length === 2; 
     4057        }); 
     4058 
     4059        // Check if getElementById returns elements by name 
     4060        // Check if getElementsByName privileges form controls or returns elements by ID 
     4061        support.getByName = assert(function( div ) { 
     4062                // Inject content 
     4063                div.id = expando + 0; 
     4064                div.innerHTML = "<a name='" + expando + "'></a><div name='" + expando + "'></div>"; 
     4065                docElem.insertBefore( div, docElem.firstChild ); 
     4066 
     4067                // Test 
     4068                var pass = doc.getElementsByName && 
     4069                        // buggy browsers will return fewer than the correct 2 
     4070                        doc.getElementsByName( expando ).length === 2 + 
     4071                        // buggy browsers will return more than the correct 0 
     4072                        doc.getElementsByName( expando + 0 ).length; 
     4073                support.getIdNotName = !doc.getElementById( expando ); 
     4074 
     4075                // Cleanup 
     4076                docElem.removeChild( div ); 
     4077 
     4078                return pass; 
     4079        }); 
     4080 
     4081        // IE6/7 return modified attributes 
     4082        Expr.attrHandle = assert(function( div ) { 
     4083                div.innerHTML = "<a href='#'></a>"; 
     4084                return div.firstChild && typeof div.firstChild.getAttribute !== strundefined && 
     4085                        div.firstChild.getAttribute("href") === "#"; 
     4086        }) ? 
     4087                {} : 
     4088                { 
     4089                        "href": function( elem ) { 
     4090                                return elem.getAttribute( "href", 2 ); 
     4091                        }, 
     4092                        "type": function( elem ) { 
     4093                                return elem.getAttribute("type"); 
     4094                        } 
     4095                }; 
     4096 
     4097        // ID find and filter 
     4098        if ( support.getIdNotName ) { 
     4099                Expr.find["ID"] = function( id, context ) { 
     4100                        if ( typeof context.getElementById !== strundefined && !documentIsXML ) { 
     4101                                var m = context.getElementById( id ); 
     4102                                // Check parentNode to catch when Blackberry 4.6 returns 
     4103                                // nodes that are no longer in the document #6963 
     4104                                return m && m.parentNode ? [m] : []; 
     4105                        } 
     4106                }; 
     4107                Expr.filter["ID"] = function( id ) { 
     4108                        var attrId = id.replace( runescape, funescape ); 
     4109                        return function( elem ) { 
     4110                                return elem.getAttribute("id") === attrId; 
     4111                        }; 
     4112                }; 
     4113        } else { 
     4114                Expr.find["ID"] = function( id, context ) { 
     4115                        if ( typeof context.getElementById !== strundefined && !documentIsXML ) { 
     4116                                var m = context.getElementById( id ); 
     4117 
     4118                                return m ? 
     4119                                        m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ? 
     4120                                                [m] : 
     4121                                                undefined : 
     4122                                        []; 
     4123                        } 
     4124                }; 
     4125                Expr.filter["ID"] =  function( id ) { 
     4126                        var attrId = id.replace( runescape, funescape ); 
     4127                        return function( elem ) { 
     4128                                var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id"); 
     4129                                return node && node.value === attrId; 
     4130                        }; 
     4131                }; 
     4132        } 
     4133 
     4134        // Tag 
     4135        Expr.find["TAG"] = support.tagNameNoComments ? 
     4136                function( tag, context ) { 
     4137                        if ( typeof context.getElementsByTagName !== strundefined ) { 
     4138                                return context.getElementsByTagName( tag ); 
     4139                        } 
     4140                } : 
     4141                function( tag, context ) { 
     4142                        var elem, 
     4143                                tmp = [], 
     4144                                i = 0, 
     4145                                results = context.getElementsByTagName( tag ); 
     4146 
     4147                        // Filter out possible comments 
     4148                        if ( tag === "*" ) { 
     4149                                while ( (elem = results[i++]) ) { 
     4150                                        if ( elem.nodeType === 1 ) { 
     4151                                                tmp.push( elem ); 
     4152                                        } 
     4153                                } 
     4154 
     4155                                return tmp; 
     4156                        } 
     4157                        return results; 
     4158                }; 
     4159 
     4160        // Name 
     4161        Expr.find["NAME"] = support.getByName && function( tag, context ) { 
     4162                if ( typeof context.getElementsByName !== strundefined ) { 
     4163                        return context.getElementsByName( name ); 
     4164                } 
     4165        }; 
     4166 
     4167        // Class 
     4168        Expr.find["CLASS"] = support.getByClassName && function( className, context ) { 
     4169                if ( typeof context.getElementsByClassName !== strundefined && !documentIsXML ) { 
     4170                        return context.getElementsByClassName( className ); 
     4171                } 
     4172        }; 
     4173 
     4174        // QSA and matchesSelector support 
     4175 
     4176        // matchesSelector(:active) reports false when true (IE9/Opera 11.5) 
     4177        rbuggyMatches = []; 
     4178 
     4179        // qSa(:focus) reports false when true (Chrome 21), 
     4180        // no need to also add to buggyMatches since matches checks buggyQSA 
     4181        // A support test would require too much code (would include document ready) 
     4182        rbuggyQSA = [ ":focus" ]; 
     4183 
     4184        if ( (support.qsa = isNative(doc.querySelectorAll)) ) { 
     4185                // Build QSA regex 
     4186                // Regex strategy adopted from Diego Perini 
     4187                assert(function( div ) { 
     4188                        // Select is set to empty string on purpose 
     4189                        // This is to test IE's treatment of not explictly 
     4190                        // setting a boolean content attribute, 
     4191                        // since its presence should be enough 
     4192                        // http://bugs.jquery.com/ticket/12359 
     4193                        div.innerHTML = "<select><option selected=''></option></select>"; 
     4194 
     4195                        // IE8 - Some boolean attributes are not treated correctly 
     4196                        if ( !div.querySelectorAll("[selected]").length ) { 
     4197                                rbuggyQSA.push( "\\[" + whitespace + "*(?:checked|disabled|ismap|multiple|readonly|selected|value)" ); 
     4198                        } 
     4199 
     4200                        // Webkit/Opera - :checked should return selected option elements 
     4201                        // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked 
     4202                        // IE8 throws error here and will not see later tests 
     4203                        if ( !div.querySelectorAll(":checked").length ) { 
     4204                                rbuggyQSA.push(":checked"); 
     4205                        } 
     4206                }); 
     4207 
     4208                assert(function( div ) { 
     4209 
     4210                        // Opera 10-12/IE8 - ^= $= *= and empty values 
     4211                        // Should not select anything 
     4212                        div.innerHTML = "<input type='hidden' i=''/>"; 
     4213                        if ( div.querySelectorAll("[i^='']").length ) { 
     4214                                rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:\"\"|'')" ); 
     4215                        } 
     4216 
     4217                        // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) 
     4218                        // IE8 throws error here and will not see later tests 
     4219                        if ( !div.querySelectorAll(":enabled").length ) { 
     4220                                rbuggyQSA.push( ":enabled", ":disabled" ); 
     4221                        } 
     4222 
     4223                        // Opera 10-11 does not throw on post-comma invalid pseudos 
     4224                        div.querySelectorAll("*,:x"); 
     4225                        rbuggyQSA.push(",.*:"); 
     4226                }); 
     4227        } 
     4228 
     4229        if ( (support.matchesSelector = isNative( (matches = docElem.matchesSelector || 
     4230                docElem.mozMatchesSelector || 
     4231                docElem.webkitMatchesSelector || 
     4232                docElem.oMatchesSelector || 
     4233                docElem.msMatchesSelector) )) ) { 
     4234 
     4235                assert(function( div ) { 
     4236                        // Check to see if it's possible to do matchesSelector 
     4237                        // on a disconnected node (IE 9) 
     4238                        support.disconnectedMatch = matches.call( div, "div" ); 
     4239 
     4240                        // This should fail with an exception 
     4241                        // Gecko does not error, returns false instead 
     4242                        matches.call( div, "[s!='']:x" ); 
     4243                        rbuggyMatches.push( "!=", pseudos ); 
     4244                }); 
     4245        } 
     4246 
     4247        rbuggyQSA = new RegExp( rbuggyQSA.join("|") ); 
     4248        rbuggyMatches = new RegExp( rbuggyMatches.join("|") ); 
     4249 
     4250        // Element contains another 
     4251        // Purposefully does not implement inclusive descendent 
     4252        // As in, an element does not contain itself 
     4253        contains = isNative(docElem.contains) || docElem.compareDocumentPosition ? 
     4254                function( a, b ) { 
     4255                        var adown = a.nodeType === 9 ? a.documentElement : a, 
     4256                                bup = b && b.parentNode; 
     4257                        return a === bup || !!( bup && bup.nodeType === 1 && ( 
     4258                                adown.contains ? 
     4259                                        adown.contains( bup ) : 
     4260                                        a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 
     4261                        )); 
     4262                } : 
     4263                function( a, b ) { 
     4264                        if ( b ) { 
     4265                                while ( (b = b.parentNode) ) { 
     4266                                        if ( b === a ) { 
     4267                                                return true; 
     4268                                        } 
     4269                                } 
     4270                        } 
     4271                        return false; 
     4272                }; 
     4273 
     4274        // Document order sorting 
     4275        sortOrder = docElem.compareDocumentPosition ? 
     4276        function( a, b ) { 
     4277                var compare; 
     4278 
     4279                if ( a === b ) { 
     4280                        hasDuplicate = true; 
     4281                        return 0; 
     4282                } 
     4283 
     4284                if ( (compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition( b )) ) { 
     4285                        if ( compare & 1 || a.parentNode && a.parentNode.nodeType === 11 ) { 
     4286                                if ( a === doc || contains( preferredDoc, a ) ) { 
     4287                                        return -1; 
     4288                                } 
     4289                                if ( b === doc || contains( preferredDoc, b ) ) { 
     4290                                        return 1; 
     4291                                } 
     4292                                return 0; 
     4293                        } 
     4294                        return compare & 4 ? -1 : 1; 
     4295                } 
     4296 
     4297                return a.compareDocumentPosition ? -1 : 1; 
     4298        } : 
     4299        function( a, b ) { 
     4300                var cur, 
     4301                        i = 0, 
     4302                        aup = a.parentNode, 
     4303                        bup = b.parentNode, 
     4304                        ap = [ a ], 
     4305                        bp = [ b ]; 
     4306 
     4307                // Exit early if the nodes are identical 
     4308                if ( a === b ) { 
     4309                        hasDuplicate = true; 
     4310                        return 0; 
     4311 
     4312                // Parentless nodes are either documents or disconnected 
     4313                } else if ( !aup || !bup ) { 
     4314                        return a === doc ? -1 : 
     4315                                b === doc ? 1 : 
     4316                                aup ? -1 : 
     4317                                bup ? 1 : 
     4318                                0; 
     4319 
     4320                // If the nodes are siblings, we can do a quick check 
     4321                } else if ( aup === bup ) { 
     4322                        return siblingCheck( a, b ); 
     4323                } 
     4324 
     4325                // Otherwise we need full lists of their ancestors for comparison 
     4326                cur = a; 
     4327                while ( (cur = cur.parentNode) ) { 
     4328                        ap.unshift( cur ); 
     4329                } 
     4330                cur = b; 
     4331                while ( (cur = cur.parentNode) ) { 
     4332                        bp.unshift( cur ); 
     4333                } 
     4334 
     4335                // Walk down the tree looking for a discrepancy 
     4336                while ( ap[i] === bp[i] ) { 
     4337                        i++; 
     4338                } 
     4339 
     4340                return i ? 
     4341                        // Do a sibling check if the nodes have a common ancestor 
     4342                        siblingCheck( ap[i], bp[i] ) : 
     4343 
     4344                        // Otherwise nodes in our document sort first 
     4345                        ap[i] === preferredDoc ? -1 : 
     4346                        bp[i] === preferredDoc ? 1 : 
     4347                        0; 
     4348        }; 
     4349 
     4350        // Always assume the presence of duplicates if sort doesn't 
     4351        // pass them to our comparison function (as in Google Chrome). 
     4352        hasDuplicate = false; 
     4353        [0, 0].sort( sortOrder ); 
     4354        support.detectDuplicates = hasDuplicate; 
     4355 
     4356        return document; 
     4357}; 
    39394358 
    39404359Sizzle.matches = function( expr, elements ) { 
     
    39434362 
    39444363Sizzle.matchesSelector = function( elem, expr ) { 
    3945         return Sizzle( expr, null, null, [ elem ] ).length > 0; 
     4364        // Set document vars if needed 
     4365        if ( ( elem.ownerDocument || elem ) !== document ) { 
     4366                setDocument( elem ); 
     4367        } 
     4368 
     4369        // Make sure that attribute selectors are quoted 
     4370        expr = expr.replace( rattributeQuotes, "='$1']" ); 
     4371 
     4372        // rbuggyQSA always contains :focus, so no need for an existence check 
     4373        if ( support.matchesSelector && !documentIsXML && (!rbuggyMatches || !rbuggyMatches.test(expr)) && !rbuggyQSA.test(expr) ) { 
     4374                try { 
     4375                        var ret = matches.call( elem, expr ); 
     4376 
     4377                        // IE 9's matchesSelector returns false on disconnected nodes 
     4378                        if ( ret || support.disconnectedMatch || 
     4379                                        // As well, disconnected nodes are said to be in a document 
     4380                                        // fragment in IE 9 
     4381                                        elem.document && elem.document.nodeType !== 11 ) { 
     4382                                return ret; 
     4383                        } 
     4384                } catch(e) {} 
     4385        } 
     4386 
     4387        return Sizzle( expr, document, null, [elem] ).length > 0; 
    39464388}; 
     4389 
     4390Sizzle.contains = function( context, elem ) { 
     4391        // Set document vars if needed 
     4392        if ( ( context.ownerDocument || context ) !== document ) { 
     4393                setDocument( context ); 
     4394        } 
     4395        return contains( context, elem ); 
     4396}; 
     4397 
     4398Sizzle.attr = function( elem, name ) { 
     4399        var val; 
     4400 
     4401        // Set document vars if needed 
     4402        if ( ( elem.ownerDocument || elem ) !== document ) { 
     4403                setDocument( elem ); 
     4404        } 
     4405 
     4406        if ( !documentIsXML ) { 
     4407                name = name.toLowerCase(); 
     4408        } 
     4409        if ( (val = Expr.attrHandle[ name ]) ) { 
     4410                return val( elem ); 
     4411        } 
     4412        if ( documentIsXML || support.attributes ) { 
     4413                return elem.getAttribute( name ); 
     4414        } 
     4415        return ( (val = elem.getAttributeNode( name )) || elem.getAttribute( name ) ) && elem[ name ] === true ? 
     4416                name : 
     4417                val && val.specified ? val.value : null; 
     4418}; 
     4419 
     4420Sizzle.error = function( msg ) { 
     4421        throw new Error( "Syntax error, unrecognized expression: " + msg ); 
     4422}; 
     4423 
     4424// Document sorting and removing duplicates 
     4425Sizzle.uniqueSort = function( results ) { 
     4426        var elem, 
     4427                duplicates = [], 
     4428                i = 1, 
     4429                j = 0; 
     4430 
     4431        // Unless we *know* we can detect duplicates, assume their presence 
     4432        hasDuplicate = !support.detectDuplicates; 
     4433        results.sort( sortOrder ); 
     4434 
     4435        if ( hasDuplicate ) { 
     4436                for ( ; (elem = results[i]); i++ ) { 
     4437                        if ( elem === results[ i - 1 ] ) { 
     4438                                j = duplicates.push( i ); 
     4439                        } 
     4440                } 
     4441                while ( j-- ) { 
     4442                        results.splice( duplicates[ j ], 1 ); 
     4443                } 
     4444        } 
     4445 
     4446        return results; 
     4447}; 
     4448 
     4449function siblingCheck( a, b ) { 
     4450        var cur = b && a, 
     4451                diff = cur && ( ~b.sourceIndex || MAX_NEGATIVE ) - ( ~a.sourceIndex || MAX_NEGATIVE ); 
     4452 
     4453        // Use IE sourceIndex if available on both nodes 
     4454        if ( diff ) { 
     4455                return diff; 
     4456        } 
     4457 
     4458        // Check if b follows a 
     4459        if ( cur ) { 
     4460                while ( (cur = cur.nextSibling) ) { 
     4461                        if ( cur === b ) { 
     4462                                return -1; 
     4463                        } 
     4464                } 
     4465        } 
     4466 
     4467        return a ? 1 : -1; 
     4468} 
    39474469 
    39484470// Returns a function to use in pseudos for input types 
     
    39914513                nodeType = elem.nodeType; 
    39924514 
    3993         if ( nodeType ) { 
    3994                 if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { 
    3995                         // Use textContent for elements 
    3996                         // innerText usage removed for consistency of new lines (see #11153) 
    3997                         if ( typeof elem.textContent === "string" ) { 
    3998                                 return elem.textContent; 
    3999                         } else { 
    4000                                 // Traverse its children 
    4001                                 for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { 
    4002                                         ret += getText( elem ); 
    4003                                 } 
    4004                         } 
    4005                 } else if ( nodeType === 3 || nodeType === 4 ) { 
    4006                         return elem.nodeValue; 
    4007                 } 
    4008                 // Do not include comment or processing instruction nodes 
    4009         } else { 
    4010  
     4515        if ( !nodeType ) { 
    40114516                // If no nodeType, this is expected to be an array 
    40124517                for ( ; (node = elem[i]); i++ ) { 
     
    40144519                        ret += getText( node ); 
    40154520                } 
    4016         } 
     4521        } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { 
     4522                // Use textContent for elements 
     4523                // innerText usage removed for consistency of new lines (see #11153) 
     4524                if ( typeof elem.textContent === "string" ) { 
     4525                        return elem.textContent; 
     4526                } else { 
     4527                        // Traverse its children 
     4528                        for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { 
     4529                                ret += getText( elem ); 
     4530                        } 
     4531                } 
     4532        } else if ( nodeType === 3 || nodeType === 4 ) { 
     4533                return elem.nodeValue; 
     4534        } 
     4535        // Do not include comment or processing instruction nodes 
     4536 
    40174537        return ret; 
    40184538}; 
    40194539 
    4020 isXML = Sizzle.isXML = function( elem ) { 
    4021         // documentElement is verified for cases where it doesn't yet exist 
    4022         // (such as loading iframes in IE - #4833) 
    4023         var documentElement = elem && (elem.ownerDocument || elem).documentElement; 
    4024         return documentElement ? documentElement.nodeName !== "HTML" : false; 
    4025 }; 
    4026  
    4027 // Element contains another 
    4028 contains = Sizzle.contains = docElem.contains ? 
    4029         function( a, b ) { 
    4030                 var adown = a.nodeType === 9 ? a.documentElement : a, 
    4031                         bup = b && b.parentNode; 
    4032                 return a === bup || !!( bup && bup.nodeType === 1 && adown.contains && adown.contains(bup) ); 
    4033         } : 
    4034         docElem.compareDocumentPosition ? 
    4035         function( a, b ) { 
    4036                 return b && !!( a.compareDocumentPosition( b ) & 16 ); 
    4037         } : 
    4038         function( a, b ) { 
    4039                 while ( (b = b.parentNode) ) { 
    4040                         if ( b === a ) { 
    4041                                 return true; 
    4042                         } 
    4043                 } 
    4044                 return false; 
    4045         }; 
    4046  
    4047 Sizzle.attr = function( elem, name ) { 
    4048         var val, 
    4049                 xml = isXML( elem ); 
    4050  
    4051         if ( !xml ) { 
    4052                 name = name.toLowerCase(); 
    4053         } 
    4054         if ( (val = Expr.attrHandle[ name ]) ) { 
    4055                 return val( elem ); 
    4056         } 
    4057         if ( xml || assertAttributes ) { 
    4058                 return elem.getAttribute( name ); 
    4059         } 
    4060         val = elem.getAttributeNode( name ); 
    4061         return val ? 
    4062                 typeof elem[ name ] === "boolean" ? 
    4063                         elem[ name ] ? name : null : 
    4064                         val.specified ? val.value : null : 
    4065                 null; 
    4066 }; 
    4067  
    40684540Expr = Sizzle.selectors = { 
    40694541 
     
    40754547        match: matchExpr, 
    40764548 
    4077         // IE6/7 return a modified href 
    4078         attrHandle: assertHrefNotNormalized ? 
    4079                 {} : 
    4080                 { 
    4081                         "href": function( elem ) { 
    4082                                 return elem.getAttribute( "href", 2 ); 
    4083                         }, 
    4084                         "type": function( elem ) { 
    4085                                 return elem.getAttribute("type"); 
    4086                         } 
    4087                 }, 
    4088  
    4089         find: { 
    4090                 "ID": assertGetIdNotName ? 
    4091                         function( id, context, xml ) { 
    4092                                 if ( typeof context.getElementById !== strundefined && !xml ) { 
    4093                                         var m = context.getElementById( id ); 
    4094                                         // Check parentNode to catch when Blackberry 4.6 returns 
    4095                                         // nodes that are no longer in the document #6963 
    4096                                         return m && m.parentNode ? [m] : []; 
    4097                                 } 
    4098                         } : 
    4099                         function( id, context, xml ) { 
    4100                                 if ( typeof context.getElementById !== strundefined && !xml ) { 
    4101                                         var m = context.getElementById( id ); 
    4102  
    4103                                         return m ? 
    4104                                                 m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ? 
    4105                                                         [m] : 
    4106                                                         undefined : 
    4107                                                 []; 
    4108                                 } 
    4109                         }, 
    4110  
    4111                 "TAG": assertTagNameNoComments ? 
    4112                         function( tag, context ) { 
    4113                                 if ( typeof context.getElementsByTagName !== strundefined ) { 
    4114                                         return context.getElementsByTagName( tag ); 
    4115                                 } 
    4116                         } : 
    4117                         function( tag, context ) { 
    4118                                 var results = context.getElementsByTagName( tag ); 
    4119  
    4120                                 // Filter out possible comments 
    4121                                 if ( tag === "*" ) { 
    4122                                         var elem, 
    4123                                                 tmp = [], 
    4124                                                 i = 0; 
    4125  
    4126                                         for ( ; (elem = results[i]); i++ ) { 
    4127                                                 if ( elem.nodeType === 1 ) { 
    4128                                                         tmp.push( elem ); 
    4129                                                 } 
    4130                                         } 
    4131  
    4132                                         return tmp; 
    4133                                 } 
    4134                                 return results; 
    4135                         }, 
    4136  
    4137                 "NAME": assertUsableName && function( tag, context ) { 
    4138                         if ( typeof context.getElementsByName !== strundefined ) { 
    4139                                 return context.getElementsByName( name ); 
    4140                         } 
    4141                 }, 
    4142  
    4143                 "CLASS": assertUsableClassName && function( className, context, xml ) { 
    4144                         if ( typeof context.getElementsByClassName !== strundefined && !xml ) { 
    4145                                 return context.getElementsByClassName( className ); 
    4146                         } 
    4147                 } 
    4148         }, 
     4549        find: {}, 
    41494550 
    41504551        relative: { 
     
    41574558        preFilter: { 
    41584559                "ATTR": function( match ) { 
    4159                         match[1] = match[1].replace( rbackslash, "" ); 
     4560                        match[1] = match[1].replace( runescape, funescape ); 
    41604561 
    41614562                        // Move the given value to match[3] whether quoted or unquoted 
    4162                         match[3] = ( match[4] || match[5] || "" ).replace( rbackslash, "" ); 
     4563                        match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape ); 
    41634564 
    41644565                        if ( match[2] === "~=" ) { 
     
    41724573                        /* matches from matchExpr["CHILD"] 
    41734574                                1 type (only|nth|...) 
    4174                                 2 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 
    4175                                 3 xn-component of xn+y argument ([+-]?\d*n|) 
    4176                                 4 sign of xn-component 
    4177                                 5 x of xn-component 
    4178                                 6 sign of y-component 
    4179                                 7 y of y-component 
     4575                                2 what (child|of-type) 
     4576                                3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 
     4577                                4 xn-component of xn+y argument ([+-]?\d*n|) 
     4578                                5 sign of xn-component 
     4579                                6 x of xn-component 
     4580                                7 sign of y-component 
     4581                                8 y of y-component 
    41804582                        */ 
    41814583                        match[1] = match[1].toLowerCase(); 
    41824584 
    4183                         if ( match[1] === "nth" ) { 
    4184                                 // nth-child requires argument 
    4185                                 if ( !match[2] ) { 
     4585                        if ( match[1].slice( 0, 3 ) === "nth" ) { 
     4586                                // nth-* requires argument 
     4587                                if ( !match[3] ) { 
    41864588                                        Sizzle.error( match[0] ); 
    41874589                                } 
     
    41894591                                // numeric x and y parameters for Expr.filter.CHILD 
    41904592                                // remember that false/true cast respectively to 0/1 
    4191                                 match[3] = +( match[3] ? match[4] + (match[5] || 1) : 2 * ( match[2] === "even" || match[2] === "odd" ) ); 
    4192                                 match[4] = +( ( match[6] + match[7] ) || match[2] === "odd" ); 
     4593                                match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) ); 
     4594                                match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" ); 
    41934595 
    41944596                        // other types prohibit arguments 
    4195                         } else if ( match[2] ) { 
     4597                        } else if ( match[3] ) { 
    41964598                                Sizzle.error( match[0] ); 
    41974599                        } 
     
    42014603 
    42024604                "PSEUDO": function( match ) { 
    4203                         var unquoted, excess; 
     4605                        var excess, 
     4606                                unquoted = !match[5] && match[2]; 
     4607 
    42044608                        if ( matchExpr["CHILD"].test( match[0] ) ) { 
    42054609                                return null; 
    42064610                        } 
    42074611 
    4208                         if ( match[3] ) { 
    4209                                 match[2] = match[3]; 
    4210                         } else if ( (unquoted = match[4]) ) { 
    4211                                 // Only check arguments that contain a pseudo 
    4212                                 if ( rpseudo.test(unquoted) && 
    4213                                         // Get excess from tokenize (recursively) 
    4214                                         (excess = tokenize( unquoted, true )) && 
    4215                                         // advance to the next closing parenthesis 
    4216                                         (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) { 
    4217  
    4218                                         // excess is a negative index 
    4219                                         unquoted = unquoted.slice( 0, excess ); 
    4220                                         match[0] = match[0].slice( 0, excess ); 
    4221                                 } 
    4222                                 match[2] = unquoted; 
     4612                        // Accept quoted arguments as-is 
     4613                        if ( match[4] ) { 
     4614                                match[2] = match[4]; 
     4615 
     4616                        // Strip excess characters from unquoted arguments 
     4617                        } else if ( unquoted && rpseudo.test( unquoted ) && 
     4618                                // Get excess from tokenize (recursively) 
     4619                                (excess = tokenize( unquoted, true )) && 
     4620                                // advance to the next closing parenthesis 
     4621                                (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) { 
     4622 
     4623                                // excess is a negative index 
     4624                                match[0] = match[0].slice( 0, excess ); 
     4625                                match[2] = unquoted.slice( 0, excess ); 
    42234626                        } 
    42244627 
     
    42294632 
    42304633        filter: { 
    4231                 "ID": assertGetIdNotName ? 
    4232                         function( id ) { 
    4233                                 id = id.replace( rbackslash, "" ); 
    4234                                 return function( elem ) { 
    4235                                         return elem.getAttribute("id") === id; 
    4236                                 }; 
    4237                         } : 
    4238                         function( id ) { 
    4239                                 id = id.replace( rbackslash, "" ); 
    4240                                 return function( elem ) { 
    4241                                         var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id"); 
    4242                                         return node && node.value === id; 
    4243                                 }; 
    4244                         }, 
    42454634 
    42464635                "TAG": function( nodeName ) { 
     
    42484637                                return function() { return true; }; 
    42494638                        } 
    4250                         nodeName = nodeName.replace( rbackslash, "" ).toLowerCase(); 
    4251  
     4639 
     4640                        nodeName = nodeName.replace( runescape, funescape ).toLowerCase(); 
    42524641                        return function( elem ) { 
    42534642                                return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; 
     
    42564645 
    42574646                "CLASS": function( className ) { 
    4258                         var pattern = classCache[ expando ][ className + " " ]; 
     4647                        var pattern = classCache[ className + " " ]; 
    42594648 
    42604649                        return pattern || 
     
    42664655 
    42674656                "ATTR": function( name, operator, check ) { 
    4268                         return function( elem, context ) { 
     4657                        return function( elem ) { 
    42694658                                var result = Sizzle.attr( elem, name ); 
    42704659 
     
    42824671                                        operator === "^=" ? check && result.indexOf( check ) === 0 : 
    42834672                                        operator === "*=" ? check && result.indexOf( check ) > -1 : 
    4284                                         operator === "$=" ? check && result.substr( result.length - check.length ) === check : 
     4673                                        operator === "$=" ? check && result.slice( -check.length ) === check : 
    42854674                                        operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 : 
    4286                                         operator === "|=" ? result === check || result.substr( 0, check.length + 1 ) === check + "-" : 
     4675                                        operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" : 
    42874676                                        false; 
    42884677                        }; 
    42894678                }, 
    42904679 
    4291                 "CHILD": function( type, argument, first, last ) { 
    4292  
    4293                         if ( type === "nth" ) { 
    4294                                 return function( elem ) { 
    4295                                         var node, diff, 
    4296                                                 parent = elem.parentNode; 
    4297  
    4298                                         if ( first === 1 && last === 0 ) { 
    4299                                                 return true; 
    4300                                         } 
     4680                "CHILD": function( type, what, argument, first, last ) { 
     4681                        var simple = type.slice( 0, 3 ) !== "nth", 
     4682                                forward = type.slice( -4 ) !== "last", 
     4683                                ofType = what === "of-type"; 
     4684 
     4685                        return first === 1 && last === 0 ? 
     4686 
     4687                                // Shortcut for :nth-*(n) 
     4688                                function( elem ) { 
     4689                                        return !!elem.parentNode; 
     4690                                } : 
     4691 
     4692                                function( elem, context, xml ) { 
     4693                                        var cache, outerCache, node, diff, nodeIndex, start, 
     4694                                                dir = simple !== forward ? "nextSibling" : "previousSibling", 
     4695                                                parent = elem.parentNode, 
     4696                                                name = ofType && elem.nodeName.toLowerCase(), 
     4697                                                useCache = !xml && !ofType; 
    43014698 
    43024699                                        if ( parent ) { 
    4303                                                 diff = 0; 
    4304                                                 for ( node = parent.firstChild; node; node = node.nextSibling ) { 
    4305                                                         if ( node.nodeType === 1 ) { 
    4306                                                                 diff++; 
    4307                                                                 if ( elem === node ) { 
     4700 
     4701                                                // :(first|last|only)-(child|of-type) 
     4702                                                if ( simple ) { 
     4703                                                        while ( dir ) { 
     4704                                                                node = elem; 
     4705                                                                while ( (node = node[ dir ]) ) { 
     4706                                                                        if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) { 
     4707                                                                                return false; 
     4708                                                                        } 
     4709                                                                } 
     4710                                                                // Reverse direction for :only-* (if we haven't yet done so) 
     4711                                                                start = dir = type === "only" && !start && "nextSibling"; 
     4712                                                        } 
     4713                                                        return true; 
     4714                                                } 
     4715 
     4716                                                start = [ forward ? parent.firstChild : parent.lastChild ]; 
     4717 
     4718                                                // non-xml :nth-child(...) stores cache data on `parent` 
     4719                                                if ( forward && useCache ) { 
     4720                                                        // Seek `elem` from a previously-cached index 
     4721                                                        outerCache = parent[ expando ] || (parent[ expando ] = {}); 
     4722                                                        cache = outerCache[ type ] || []; 
     4723                                                        nodeIndex = cache[0] === dirruns && cache[1]; 
     4724                                                        diff = cache[0] === dirruns && cache[2]; 
     4725                                                        node = nodeIndex && parent.childNodes[ nodeIndex ]; 
     4726 
     4727                                                        while ( (node = ++nodeIndex && node && node[ dir ] || 
     4728 
     4729                                                                // Fallback to seeking `elem` from the start 
     4730                                                                (diff = nodeIndex = 0) || start.pop()) ) { 
     4731 
     4732                                                                // When found, cache indexes on `parent` and break 
     4733                                                                if ( node.nodeType === 1 && ++diff && node === elem ) { 
     4734                                                                        outerCache[ type ] = [ dirruns, nodeIndex, diff ]; 
    43084735                                                                        break; 
    43094736                                                                } 
    43104737                                                        } 
    4311                                                 } 
    4312                                         } 
    4313  
    4314                                         // Incorporate the offset (or cast to NaN), then check against cycle size 
    4315                                         diff -= last; 
    4316                                         return diff === first || ( diff % first === 0 && diff / first >= 0 ); 
    4317                                 }; 
    4318                         } 
    4319  
    4320                         return function( elem ) { 
    4321                                 var node = elem; 
    4322  
    4323                                 switch ( type ) { 
    4324                                         case "only": 
    4325                                         case "first": 
    4326                                                 while ( (node = node.previousSibling) ) { 
    4327                                                         if ( node.nodeType === 1 ) { 
    4328                                                                 return false; 
     4738 
     4739                                                // Use previously-cached element index if available 
     4740                                                } else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) { 
     4741                                                        diff = cache[1]; 
     4742 
     4743                                                // xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...) 
     4744                                                } else { 
     4745                                                        // Use the same loop as above to seek `elem` from the start 
     4746                                                        while ( (node = ++nodeIndex && node && node[ dir ] || 
     4747                                                                (diff = nodeIndex = 0) || start.pop()) ) { 
     4748 
     4749                                                                if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) { 
     4750                                                                        // Cache the index of each encountered element 
     4751                                                                        if ( useCache ) { 
     4752                                                                                (node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ]; 
     4753                                                                        } 
     4754 
     4755                                                                        if ( node === elem ) { 
     4756                                                                                break; 
     4757                                                                        } 
     4758                                                                } 
    43294759                                                        } 
    43304760                                                } 
    43314761 
    4332                                                 if ( type === "first" ) { 
    4333                                                         return true; 
    4334                                                 } 
    4335  
    4336                                                 node = elem; 
    4337  
    4338                                                 /* falls through */ 
    4339                                         case "last": 
    4340                                                 while ( (node = node.nextSibling) ) { 
    4341                                                         if ( node.nodeType === 1 ) { 
    4342                                                                 return false; 
    4343                                                         } 
    4344                                                 } 
    4345  
    4346                                                 return true; 
    4347                                 } 
    4348                         }; 
     4762                                                // Incorporate the offset, then check against cycle size 
     4763                                                diff -= last; 
     4764                                                return diff === first || ( diff % first === 0 && diff / first >= 0 ); 
     4765                                        } 
     4766                                }; 
    43494767                }, 
    43504768 
     
    43884806 
    43894807        pseudos: { 
     4808                // Potentially complex pseudos 
    43904809                "not": markFunction(function( selector ) { 
    43914810                        // Trim the selector passed to compile 
     
    44284847                }), 
    44294848 
     4849                // "Whether an element is represented by a :lang() selector 
     4850                // is based solely on the element's language value 
     4851                // being equal to the identifier C, 
     4852                // or beginning with the identifier C immediately followed by "-". 
     4853                // The matching of C against the element's language value is performed case-insensitively. 
     4854                // The identifier C does not have to be a valid language name." 
     4855                // http://www.w3.org/TR/selectors/#lang-pseudo 
     4856                "lang": markFunction( function( lang ) { 
     4857                        // lang value must be a valid identifider 
     4858                        if ( !ridentifier.test(lang || "") ) { 
     4859                                Sizzle.error( "unsupported lang: " + lang ); 
     4860                        } 
     4861                        lang = lang.replace( runescape, funescape ).toLowerCase(); 
     4862                        return function( elem ) { 
     4863                                var elemLang; 
     4864                                do { 
     4865                                        if ( (elemLang = documentIsXML ? 
     4866                                                elem.getAttribute("xml:lang") || elem.getAttribute("lang") : 
     4867                                                elem.lang) ) { 
     4868 
     4869                                                elemLang = elemLang.toLowerCase(); 
     4870                                                return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; 
     4871                                        } 
     4872                                } while ( (elem = elem.parentNode) && elem.nodeType === 1 ); 
     4873                                return false; 
     4874                        }; 
     4875                }), 
     4876 
     4877                // Miscellaneous 
     4878                "target": function( elem ) { 
     4879                        var hash = window.location && window.location.hash; 
     4880                        return hash && hash.slice( 1 ) === elem.id; 
     4881                }, 
     4882 
     4883                "root": function( elem ) { 
     4884                        return elem === docElem; 
     4885                }, 
     4886 
     4887                "focus": function( elem ) { 
     4888                        return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex); 
     4889                }, 
     4890 
     4891                // Boolean properties 
    44304892                "enabled": function( elem ) { 
    44314893                        return elem.disabled === false; 
     
    44534915                }, 
    44544916 
    4455                 "parent": function( elem ) { 
    4456                         return !Expr.pseudos["empty"]( elem ); 
    4457                 }, 
    4458  
     4917                // Contents 
    44594918                "empty": function( elem ) { 
    44604919                        // http://www.w3.org/TR/selectors/#empty-pseudo 
     
    44634922                        // Thanks to Diego Perini for the nodeName shortcut 
    44644923                        //   Greater than "@" means alpha characters (specifically not starting with "#" or "?") 
    4465                         var nodeType; 
    4466                         elem = elem.firstChild; 
    4467                         while ( elem ) { 
    4468                                 if ( elem.nodeName > "@" || (nodeType = elem.nodeType) === 3 || nodeType === 4 ) { 
     4924                        for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { 
     4925                                if ( elem.nodeName > "@" || elem.nodeType === 3 || elem.nodeType === 4 ) { 
    44694926                                        return false; 
    44704927                                } 
    4471                                 elem = elem.nextSibling; 
    44724928                        } 
    44734929                        return true; 
    44744930                }, 
    44754931 
     4932                "parent": function( elem ) { 
     4933                        return !Expr.pseudos["empty"]( elem ); 
     4934                }, 
     4935 
     4936                // Element/input types 
    44764937                "header": function( elem ) { 
    44774938                        return rheader.test( elem.nodeName ); 
    44784939                }, 
    44794940 
    4480                 "text": function( elem ) { 
    4481                         var type, attr; 
    4482                         // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc) 
    4483                         // use getAttribute instead to test this case 
    4484                         return elem.nodeName.toLowerCase() === "input" && 
    4485                                 (type = elem.type) === "text" && 
    4486                                 ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === type ); 
     4941                "input": function( elem ) { 
     4942                        return rinputs.test( elem.nodeName ); 
    44874943                }, 
    4488  
    4489                 // Input types 
    4490                 "radio": createInputPseudo("radio"), 
    4491                 "checkbox": createInputPseudo("checkbox"), 
    4492                 "file": createInputPseudo("file"), 
    4493                 "password": createInputPseudo("password"), 
    4494                 "image": createInputPseudo("image"), 
    4495  
    4496                 "submit": createButtonPseudo("submit"), 
    4497                 "reset": createButtonPseudo("reset"), 
    44984944 
    44994945                "button": function( elem ) { 
     
    45024948                }, 
    45034949 
    4504                 "input": function( elem ) { 
    4505                         return rinputs.test( elem.nodeName ); 
     4950                "text": function( elem ) { 
     4951                        var attr; 
     4952                        // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc) 
     4953                        // use getAttribute instead to test this case 
     4954                        return elem.nodeName.toLowerCase() === "input" && 
     4955                                elem.type === "text" && 
     4956                                ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === elem.type ); 
    45064957                }, 
    45074958 
    4508                 "focus": function( elem ) { 
    4509                         var doc = elem.ownerDocument; 
    4510                         return elem === doc.activeElement && (!doc.hasFocus || doc.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex); 
    4511                 }, 
    4512  
    4513                 "active": function( elem ) { 
    4514                         return elem === elem.ownerDocument.activeElement; 
    4515                 }, 
    4516  
    4517                 // Positional types 
     4959                // Position-in-collection 
    45184960                "first": createPositionalPseudo(function() { 
    45194961                        return [ 0 ]; 
     
    45294971 
    45304972                "even": createPositionalPseudo(function( matchIndexes, length ) { 
    4531                         for ( var i = 0; i < length; i += 2 ) { 
     4973                        var i = 0; 
     4974                        for ( ; i < length; i += 2 ) { 
    45324975                                matchIndexes.push( i ); 
    45334976                        } 
     
    45364979 
    45374980                "odd": createPositionalPseudo(function( matchIndexes, length ) { 
    4538                         for ( var i = 1; i < length; i += 2 ) { 
     4981                        var i = 1; 
     4982                        for ( ; i < length; i += 2 ) { 
    45394983                                matchIndexes.push( i ); 
    45404984                        } 
     
    45434987 
    45444988                "lt": createPositionalPseudo(function( matchIndexes, length, argument ) { 
    4545                         for ( var i = argument < 0 ? argument + length : argument; --i >= 0; ) { 
     4989                        var i = argument < 0 ? argument + length : argument; 
     4990                        for ( ; --i >= 0; ) { 
    45464991                                matchIndexes.push( i ); 
    45474992                        } 
     
    45504995 
    45514996                "gt": createPositionalPseudo(function( matchIndexes, length, argument ) { 
    4552                         for ( var i = argument < 0 ? argument + length : argument; ++i < length; ) { 
     4997                        var i = argument < 0 ? argument + length : argument; 
     4998                        for ( ; ++i < length; ) { 
    45534999                                matchIndexes.push( i ); 
    45545000                        } 
     
    45585004}; 
    45595005 
    4560 function siblingCheck( a, b, ret ) { 
    4561         if ( a === b ) { 
    4562                 return ret; 
    4563         } 
    4564  
    4565         var cur = a.nextSibling; 
    4566  
    4567         while ( cur ) { 
    4568                 if ( cur === b ) { 
    4569                         return -1; 
    4570                 } 
    4571  
    4572                 cur = cur.nextSibling; 
    4573         } 
    4574  
    4575         return 1; 
     5006// Add button/input type pseudos 
     5007for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { 
     5008        Expr.pseudos[ i ] = createInputPseudo( i ); 
    45765009} 
    4577  
    4578 sortOrder = docElem.compareDocumentPosition ? 
    4579         function( a, b ) { 
    4580                 if ( a === b ) { 
    4581                         hasDuplicate = true; 
    4582                         return 0; 
    4583                 } 
    4584  
    4585                 return ( !a.compareDocumentPosition || !b.compareDocumentPosition ? 
    4586                         a.compareDocumentPosition : 
    4587                         a.compareDocumentPosition(b) & 4 
    4588                 ) ? -1 : 1; 
    4589         } : 
    4590         function( a, b ) { 
    4591                 // The nodes are identical, we can exit early 
    4592                 if ( a === b ) { 
    4593                         hasDuplicate = true; 
    4594                         return 0; 
    4595  
    4596                 // Fallback to using sourceIndex (in IE) if it's available on both nodes 
    4597                 } else if ( a.sourceIndex && b.sourceIndex ) { 
    4598                         return a.sourceIndex - b.sourceIndex; 
    4599                 } 
    4600  
    4601                 var al, bl, 
    4602                         ap = [], 
    4603                         bp = [], 
    4604                         aup = a.parentNode, 
    4605                         bup = b.parentNode, 
    4606                         cur = aup; 
    4607  
    4608                 // If the nodes are siblings (or identical) we can do a quick check 
    4609                 if ( aup === bup ) { 
    4610                         return siblingCheck( a, b ); 
    4611  
    4612                 // If no parents were found then the nodes are disconnected 
    4613                 } else if ( !aup ) { 
    4614                         return -1; 
    4615  
    4616                 } else if ( !bup ) { 
    4617                         return 1; 
    4618                 } 
    4619  
    4620                 // Otherwise they're somewhere else in the tree so we need 
    4621                 // to build up a full list of the parentNodes for comparison 
    4622                 while ( cur ) { 
    4623                         ap.unshift( cur ); 
    4624                         cur = cur.parentNode; 
    4625                 } 
    4626  
    4627                 cur = bup; 
    4628  
    4629                 while ( cur ) { 
    4630                         bp.unshift( cur ); 
    4631                         cur = cur.parentNode; 
    4632                 } 
    4633  
    4634                 al = ap.length; 
    4635                 bl = bp.length; 
    4636  
    4637                 // Start walking down the tree looking for a discrepancy 
    4638                 for ( var i = 0; i < al && i < bl; i++ ) { 
    4639                         if ( ap[i] !== bp[i] ) { 
    4640                                 return siblingCheck( ap[i], bp[i] ); 
    4641                         } 
    4642                 } 
    4643  
    4644                 // We ended someplace up the tree so do a sibling check 
    4645                 return i === al ? 
    4646                         siblingCheck( a, bp[i], -1 ) : 
    4647                         siblingCheck( ap[i], b, 1 ); 
    4648         }; 
    4649  
    4650 // Always assume the presence of duplicates if sort doesn't 
    4651 // pass them to our comparison function (as in Google Chrome). 
    4652 [0, 0].sort( sortOrder ); 
    4653 baseHasDuplicate = !hasDuplicate; 
    4654  
    4655 // Document sorting and removing duplicates 
    4656 Sizzle.uniqueSort = function( results ) { 
    4657         var elem, 
    4658                 duplicates = [], 
    4659                 i = 1, 
    4660                 j = 0; 
    4661  
    4662         hasDuplicate = baseHasDuplicate; 
    4663         results.sort( sortOrder ); 
    4664  
    4665         if ( hasDuplicate ) { 
    4666                 for ( ; (elem = results[i]); i++ ) { 
    4667                         if ( elem === results[ i - 1 ] ) { 
    4668                                 j = duplicates.push( i ); 
    4669                         } 
    4670                 } 
    4671                 while ( j-- ) { 
    4672                         results.splice( duplicates[ j ], 1 ); 
    4673                 } 
    4674         } 
    4675  
    4676         return results; 
    4677 }; 
    4678  
    4679 Sizzle.error = function( msg ) { 
    4680         throw new Error( "Syntax error, unrecognized expression: " + msg ); 
    4681 }; 
     5010for ( i in { submit: true, reset: true } ) { 
     5011        Expr.pseudos[ i ] = createButtonPseudo( i ); 
     5012} 
    46825013 
    46835014function tokenize( selector, parseOnly ) { 
    46845015        var matched, match, tokens, type, 
    46855016                soFar, groups, preFilters, 
    4686                 cached = tokenCache[ expando ][ selector + " " ]; 
     5017                cached = tokenCache[ selector + " " ]; 
    46875018 
    46885019        if ( cached ) { 
     
    47095040                // Combinators 
    47105041                if ( (match = rcombinators.exec( soFar )) ) { 
    4711                         tokens.push( matched = new Token( match.shift() ) ); 
     5042                        matched = match.shift(); 
     5043                        tokens.push( { 
     5044                                value: matched, 
     5045                                // Cast descendant combinators to space 
     5046                                type: match[0].replace( rtrim, " " ) 
     5047                        } ); 
    47125048                        soFar = soFar.slice( matched.length ); 
    4713  
    4714                         // Cast descendant combinators to space 
    4715                         matched.type = match[0].replace( rtrim, " " ); 
    47165049                } 
    47175050 
     
    47205053                        if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] || 
    47215054                                (match = preFilters[ type ]( match ))) ) { 
    4722  
    4723                                 tokens.push( matched = new Token( match.shift() ) ); 
     5055                                matched = match.shift(); 
     5056                                tokens.push( { 
     5057                                        value: matched, 
     5058                                        type: type, 
     5059                                        matches: match 
     5060                                } ); 
    47245061                                soFar = soFar.slice( matched.length ); 
    4725                                 matched.type = type; 
    4726                                 matched.matches = match; 
    47275062                        } 
    47285063                } 
     
    47445079} 
    47455080 
     5081function toSelector( tokens ) { 
     5082        var i = 0, 
     5083                len = tokens.length, 
     5084                selector = ""; 
     5085        for ( ; i < len; i++ ) { 
     5086                selector += tokens[i].value; 
     5087        } 
     5088        return selector; 
     5089} 
     5090 
    47465091function addCombinator( matcher, combinator, base ) { 
    47475092        var dir = combinator.dir, 
    4748                 checkNonElements = base && combinator.dir === "parentNode", 
     5093                checkNonElements = base && dir === "parentNode", 
    47495094                doneName = done++; 
    47505095 
     
    47535098                function( elem, context, xml ) { 
    47545099                        while ( (elem = elem[ dir ]) ) { 
    4755                                 if ( checkNonElements || elem.nodeType === 1 ) { 
     5100                                if ( elem.nodeType === 1 || checkNonElements ) { 
    47565101                                        return matcher( elem, context, xml ); 
    47575102                                } 
     
    47615106                // Check against all ancestor/preceding elements 
    47625107                function( elem, context, xml ) { 
     5108                        var data, cache, outerCache, 
     5109                                dirkey = dirruns + " " + doneName; 
     5110 
    47635111                        // We can't set arbitrary data on XML nodes, so they don't benefit from dir caching 
    4764                         if ( !xml ) { 
    4765                                 var cache, 
    4766                                         dirkey = dirruns + " " + doneName + " ", 
    4767                                         cachedkey = dirkey + cachedruns; 
     5112                        if ( xml ) { 
    47685113                                while ( (elem = elem[ dir ]) ) { 
    4769                                         if ( checkNonElements || elem.nodeType === 1 ) { 
    4770                                                 if ( (cache = elem[ expando ]) === cachedkey ) { 
    4771                                                         return elem.sizset; 
    4772                                                 } else if ( typeof cache === "string" && cache.indexOf(dirkey) === 0 ) { 
    4773                                                         if ( elem.sizset ) { 
    4774                                                                 return elem; 
     5114                                        if ( elem.nodeType === 1 || checkNonElements ) { 
     5115                                                if ( matcher( elem, context, xml ) ) { 
     5116                                                        return true; 
     5117                                                } 
     5118                                        } 
     5119                                } 
     5120                        } else { 
     5121                                while ( (elem = elem[ dir ]) ) { 
     5122                                        if ( elem.nodeType === 1 || checkNonElements ) { 
     5123              &