Changeset 12040


Ignore:
Timestamp:
09/02/11 21:29:08 (8 years ago)
Author:
plg
Message:

update jQuery to version 1.6.2

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

Legend:

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

    r9553 r12040  
    11/*! 
    2  * jQuery JavaScript Library v1.5.1 
     2 * jQuery JavaScript Library v1.6.2 
    33 * http://jquery.com/ 
    44 * 
     
    1212 * Released under the MIT, BSD, and GPL Licenses. 
    1313 * 
    14  * Date: Wed Feb 23 13:55:29 2011 -0500 
     14 * Date: Thu Jun 30 14:16:56 2011 -0400 
    1515 */ 
    1616(function( window, undefined ) { 
    1717 
    1818// Use the correct document accordingly with window argument (sandbox) 
    19 var document = window.document; 
     19var document = window.document, 
     20        navigator = window.navigator, 
     21        location = window.location; 
    2022var jQuery = (function() { 
    2123 
     
    3739        // A simple way to check for HTML strings or ID strings 
    3840        // (both of which we optimize for) 
    39         quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/, 
     41        quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/, 
    4042 
    4143        // Check if a string has a non-whitespace character in it 
     
    6466        rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/, 
    6567 
     68        // Matches dashed string for camelizing 
     69        rdashAlpha = /-([a-z])/ig, 
     70 
     71        // Used by jQuery.camelCase as callback to replace() 
     72        fcamelCase = function( all, letter ) { 
     73                return letter.toUpperCase(); 
     74        }, 
     75 
    6676        // Keep a UserAgent string for use with jQuery.browser 
    6777        userAgent = navigator.userAgent, 
     
    7080        browserMatch, 
    7181 
    72         // Has the ready events already been bound? 
    73         readyBound = false, 
    74  
    7582        // The deferred used on DOM ready 
    7683        readyList, 
    77  
    78         // Promise methods 
    79         promiseMethods = "then done fail isResolved isRejected promise".split( " " ), 
    8084 
    8185        // The ready event handler 
     
    114118                        this.context = document; 
    115119                        this[0] = document.body; 
    116                         this.selector = "body"; 
     120                        this.selector = selector; 
    117121                        this.length = 1; 
    118122                        return this; 
     
    122126                if ( typeof selector === "string" ) { 
    123127                        // Are we dealing with HTML string or an ID? 
    124                         match = quickExpr.exec( selector ); 
     128                        if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) { 
     129                                // Assume that strings that start and end with <> are HTML and skip the regex check 
     130                                match = [ null, selector, null ]; 
     131 
     132                        } else { 
     133                                match = quickExpr.exec( selector ); 
     134                        } 
    125135 
    126136                        // Verify a match, and that no context was specified for #id 
     
    203213 
    204214        // The current version of jQuery being used 
    205         jquery: "1.5.1", 
     215        jquery: "1.6.2", 
    206216 
    207217        // The default length of a jQuery object is 0 
     
    379389jQuery.extend({ 
    380390        noConflict: function( deep ) { 
    381                 window.$ = _$; 
    382  
    383                 if ( deep ) { 
     391                if ( window.$ === jQuery ) { 
     392                        window.$ = _$; 
     393                } 
     394 
     395                if ( deep && window.jQuery === jQuery ) { 
    384396                        window.jQuery = _jQuery; 
    385397                } 
     
    395407        readyWait: 1, 
    396408 
     409        // Hold (or release) the ready event 
     410        holdReady: function( hold ) { 
     411                if ( hold ) { 
     412                        jQuery.readyWait++; 
     413                } else { 
     414                        jQuery.ready( true ); 
     415                } 
     416        }, 
     417 
    397418        // Handle when the DOM is ready 
    398419        ready: function( wait ) { 
    399                 // A third-party is pushing the ready event forwards 
    400                 if ( wait === true ) { 
    401                         jQuery.readyWait--; 
    402                 } 
    403  
    404                 // Make sure that the DOM is not already loaded 
    405                 if ( !jQuery.readyWait || (wait !== true && !jQuery.isReady) ) { 
     420                // Either a released hold or an DOMready/load event and not yet ready 
     421                if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) { 
    406422                        // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). 
    407423                        if ( !document.body ) { 
     
    428444 
    429445        bindReady: function() { 
    430                 if ( readyBound ) { 
     446                if ( readyList ) { 
    431447                        return; 
    432448                } 
    433449 
    434                 readyBound = true; 
     450                readyList = jQuery._Deferred(); 
    435451 
    436452                // Catch cases where $(document).ready() is called after the 
     
    453469                        // ensure firing before onload, 
    454470                        // maybe late but safe also for iframes 
    455                         document.attachEvent("onreadystatechange", DOMContentLoaded); 
     471                        document.attachEvent( "onreadystatechange", DOMContentLoaded ); 
    456472 
    457473                        // A fallback to window.onload, that will always work 
     
    541557                data = jQuery.trim( data ); 
    542558 
     559                // Attempt to parse using the native JSON parser first 
     560                if ( window.JSON && window.JSON.parse ) { 
     561                        return window.JSON.parse( data ); 
     562                } 
     563 
    543564                // Make sure the incoming data is actual JSON 
    544565                // Logic borrowed from http://json.org/json2.js 
    545                 if ( rvalidchars.test(data.replace(rvalidescape, "@") 
    546                         .replace(rvalidtokens, "]") 
    547                         .replace(rvalidbraces, "")) ) { 
    548  
    549                         // Try to use the native JSON parser first 
    550                         return window.JSON && window.JSON.parse ? 
    551                                 window.JSON.parse( data ) : 
    552                                 (new Function("return " + data))(); 
    553  
    554                 } else { 
    555                         jQuery.error( "Invalid JSON: " + data ); 
    556                 } 
     566                if ( rvalidchars.test( data.replace( rvalidescape, "@" ) 
     567                        .replace( rvalidtokens, "]" ) 
     568                        .replace( rvalidbraces, "")) ) { 
     569 
     570                        return (new Function( "return " + data ))(); 
     571 
     572                } 
     573                jQuery.error( "Invalid JSON: " + data ); 
    557574        }, 
    558575 
     
    581598        noop: function() {}, 
    582599 
    583         // Evalulates a script in a global context 
     600        // Evaluates a script in a global context 
     601        // Workarounds based on findings by Jim Driscoll 
     602        // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context 
    584603        globalEval: function( data ) { 
    585                 if ( data && rnotwhite.test(data) ) { 
    586                         // Inspired by code by Andrea Giammarchi 
    587                         // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html 
    588                         var head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement, 
    589                                 script = document.createElement( "script" ); 
    590  
    591                         if ( jQuery.support.scriptEval() ) { 
    592                                 script.appendChild( document.createTextNode( data ) ); 
    593                         } else { 
    594                                 script.text = data; 
    595                         } 
    596  
    597                         // Use insertBefore instead of appendChild to circumvent an IE6 bug. 
    598                         // This arises when a base node is used (#2709). 
    599                         head.insertBefore( script, head.firstChild ); 
    600                         head.removeChild( script ); 
    601                 } 
     604                if ( data && rnotwhite.test( data ) ) { 
     605                        // We use execScript on Internet Explorer 
     606                        // We use an anonymous function so that context is window 
     607                        // rather than jQuery in Firefox 
     608                        ( window.execScript || function( data ) { 
     609                                window[ "eval" ].call( window, data ); 
     610                        } )( data ); 
     611                } 
     612        }, 
     613 
     614        // Converts a dashed string to camelCased string; 
     615        // Used by both the css and data modules 
     616        camelCase: function( string ) { 
     617                return string.replace( rdashAlpha, fcamelCase ); 
    602618        }, 
    603619 
     
    610626                var name, i = 0, 
    611627                        length = object.length, 
    612                         isObj = length === undefined || jQuery.isFunction(object); 
     628                        isObj = length === undefined || jQuery.isFunction( object ); 
    613629 
    614630                if ( args ) { 
     
    636652                                } 
    637653                        } else { 
    638                                 for ( var value = object[0]; 
    639                                         i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {} 
     654                                for ( ; i < length; ) { 
     655                                        if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) { 
     656                                                break; 
     657                                        } 
     658                                } 
    640659                        } 
    641660                } 
     
    668687                        // in Safari 2 (See: #3039) 
    669688                        // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930 
    670                         var type = jQuery.type(array); 
     689                        var type = jQuery.type( array ); 
    671690 
    672691                        if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) { 
     
    681700 
    682701        inArray: function( elem, array ) { 
    683                 if ( array.indexOf ) { 
    684                         return array.indexOf( elem ); 
     702 
     703                if ( indexOf ) { 
     704                        return indexOf.call( array, elem ); 
    685705                } 
    686706 
     
    732752        // arg is for internal usage only 
    733753        map: function( elems, callback, arg ) { 
    734                 var ret = [], value; 
     754                var value, key, ret = [], 
     755                        i = 0, 
     756                        length = elems.length, 
     757                        // jquery objects are treated as arrays 
     758                        isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ; 
    735759 
    736760                // Go through the array, translating each of the items to their 
    737                 // new value (or values). 
    738                 for ( var i = 0, length = elems.length; i < length; i++ ) { 
    739                         value = callback( elems[ i ], i, arg ); 
    740  
    741                         if ( value != null ) { 
    742                                 ret[ ret.length ] = value; 
     761                if ( isArray ) { 
     762                        for ( ; i < length; i++ ) { 
     763                                value = callback( elems[ i ], i, arg ); 
     764 
     765                                if ( value != null ) { 
     766                                        ret[ ret.length ] = value; 
     767                                } 
     768                        } 
     769 
     770                // Go through every key on the object, 
     771                } else { 
     772                        for ( key in elems ) { 
     773                                value = callback( elems[ key ], key, arg ); 
     774 
     775                                if ( value != null ) { 
     776                                        ret[ ret.length ] = value; 
     777                                } 
    743778                        } 
    744779                } 
     
    751786        guid: 1, 
    752787 
    753         proxy: function( fn, proxy, thisObject ) { 
    754                 if ( arguments.length === 2 ) { 
    755                         if ( typeof proxy === "string" ) { 
    756                                 thisObject = fn; 
    757                                 fn = thisObject[ proxy ]; 
    758                                 proxy = undefined; 
    759  
    760                         } else if ( proxy && !jQuery.isFunction( proxy ) ) { 
    761                                 thisObject = proxy; 
    762                                 proxy = undefined; 
    763                         } 
    764                 } 
    765  
    766                 if ( !proxy && fn ) { 
     788        // Bind a function to a context, optionally partially applying any 
     789        // arguments. 
     790        proxy: function( fn, context ) { 
     791                if ( typeof context === "string" ) { 
     792                        var tmp = fn[ context ]; 
     793                        context = fn; 
     794                        fn = tmp; 
     795                } 
     796 
     797                // Quick check to determine if target is callable, in the spec 
     798                // this throws a TypeError, but we will just return undefined. 
     799                if ( !jQuery.isFunction( fn ) ) { 
     800                        return undefined; 
     801                } 
     802 
     803                // Simulated bind 
     804                var args = slice.call( arguments, 2 ), 
    767805                        proxy = function() { 
    768                                 return fn.apply( thisObject || this, arguments ); 
     806                                return fn.apply( context, args.concat( slice.call( arguments ) ) ); 
    769807                        }; 
    770                 } 
    771808 
    772809                // Set the guid of unique handler to the same of original handler, so it can be removed 
    773                 if ( fn ) { 
    774                         proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++; 
    775                 } 
    776  
    777                 // So proxy can be declared as an argument 
     810                proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++; 
     811 
    778812                return proxy; 
    779813        }, 
    780814 
    781815        // Mutifunctional method to get and set values to a collection 
    782         // The value/s can be optionally by executed if its a function 
     816        // The value/s can optionally be executed if it's a function 
    783817        access: function( elems, key, value, exec, fn, pass ) { 
    784818                var length = elems.length; 
     
    812846        }, 
    813847 
     848        // Use of jQuery.browser is frowned upon. 
     849        // More details: http://docs.jquery.com/Utilities/jQuery.browser 
     850        uaMatch: function( ua ) { 
     851                ua = ua.toLowerCase(); 
     852 
     853                var match = rwebkit.exec( ua ) || 
     854                        ropera.exec( ua ) || 
     855                        rmsie.exec( ua ) || 
     856                        ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) || 
     857                        []; 
     858 
     859                return { browser: match[1] || "", version: match[2] || "0" }; 
     860        }, 
     861 
     862        sub: function() { 
     863                function jQuerySub( selector, context ) { 
     864                        return new jQuerySub.fn.init( selector, context ); 
     865                } 
     866                jQuery.extend( true, jQuerySub, this ); 
     867                jQuerySub.superclass = this; 
     868                jQuerySub.fn = jQuerySub.prototype = this(); 
     869                jQuerySub.fn.constructor = jQuerySub; 
     870                jQuerySub.sub = this.sub; 
     871                jQuerySub.fn.init = function init( selector, context ) { 
     872                        if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) { 
     873                                context = jQuerySub( context ); 
     874                        } 
     875 
     876                        return jQuery.fn.init.call( this, selector, context, rootjQuerySub ); 
     877                }; 
     878                jQuerySub.fn.init.prototype = jQuerySub.fn; 
     879                var rootjQuerySub = jQuerySub(document); 
     880                return jQuerySub; 
     881        }, 
     882 
     883        browser: {} 
     884}); 
     885 
     886// Populate the class2type map 
     887jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) { 
     888        class2type[ "[object " + name + "]" ] = name.toLowerCase(); 
     889}); 
     890 
     891browserMatch = jQuery.uaMatch( userAgent ); 
     892if ( browserMatch.browser ) { 
     893        jQuery.browser[ browserMatch.browser ] = true; 
     894        jQuery.browser.version = browserMatch.version; 
     895} 
     896 
     897// Deprecated, use jQuery.browser.webkit instead 
     898if ( jQuery.browser.webkit ) { 
     899        jQuery.browser.safari = true; 
     900} 
     901 
     902// IE doesn't match non-breaking spaces with \s 
     903if ( rnotwhite.test( "\xA0" ) ) { 
     904        trimLeft = /^[\s\xA0]+/; 
     905        trimRight = /[\s\xA0]+$/; 
     906} 
     907 
     908// All jQuery objects should point back to these 
     909rootjQuery = jQuery(document); 
     910 
     911// Cleanup functions for the document ready method 
     912if ( document.addEventListener ) { 
     913        DOMContentLoaded = function() { 
     914                document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false ); 
     915                jQuery.ready(); 
     916        }; 
     917 
     918} else if ( document.attachEvent ) { 
     919        DOMContentLoaded = function() { 
     920                // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). 
     921                if ( document.readyState === "complete" ) { 
     922                        document.detachEvent( "onreadystatechange", DOMContentLoaded ); 
     923                        jQuery.ready(); 
     924                } 
     925        }; 
     926} 
     927 
     928// The DOM ready check for Internet Explorer 
     929function doScrollCheck() { 
     930        if ( jQuery.isReady ) { 
     931                return; 
     932        } 
     933 
     934        try { 
     935                // If IE is used, use the trick by Diego Perini 
     936                // http://javascript.nwbox.com/IEContentLoaded/ 
     937                document.documentElement.doScroll("left"); 
     938        } catch(e) { 
     939                setTimeout( doScrollCheck, 1 ); 
     940                return; 
     941        } 
     942 
     943        // and execute any waiting functions 
     944        jQuery.ready(); 
     945} 
     946 
     947return jQuery; 
     948 
     949})(); 
     950 
     951 
     952var // Promise methods 
     953        promiseMethods = "done fail isResolved isRejected promise then always pipe".split( " " ), 
     954        // Static reference to slice 
     955        sliceDeferred = [].slice; 
     956 
     957jQuery.extend({ 
    814958        // Create a simple deferred (one callbacks list) 
    815959        _Deferred: function() { 
     
    8571001                                resolveWith: function( context, args ) { 
    8581002                                        if ( !cancelled && !fired && !firing ) { 
     1003                                                // make sure args are available (#8421) 
     1004                                                args = args || []; 
    8591005                                                firing = 1; 
    8601006                                                try { 
     
    8621008                                                                callbacks.shift().apply( context, args ); 
    8631009                                                        } 
    864                                                 } 
    865                                                 // We have to add a catch block for 
    866                                                 // IE prior to 8 or else the finally 
    867                                                 // block will never get executed 
    868                                                 catch (e) { 
    869                                                         throw e; 
    8701010                                                } 
    8711011                                                finally { 
     
    8791019                                // resolve with this as context and given arguments 
    8801020                                resolve: function() { 
    881                                         deferred.resolveWith( jQuery.isFunction( this.promise ) ? this.promise() : this, arguments ); 
     1021                                        deferred.resolveWith( this, arguments ); 
    8821022                                        return this; 
    8831023                                }, 
     
    9101050                                return this; 
    9111051                        }, 
     1052                        always: function() { 
     1053                                return deferred.done.apply( deferred, arguments ).fail.apply( this, arguments ); 
     1054                        }, 
    9121055                        fail: failDeferred.done, 
    9131056                        rejectWith: failDeferred.resolveWith, 
    9141057                        reject: failDeferred.resolve, 
    9151058                        isRejected: failDeferred.isResolved, 
     1059                        pipe: function( fnDone, fnFail ) { 
     1060                                return jQuery.Deferred(function( newDefer ) { 
     1061                                        jQuery.each( { 
     1062                                                done: [ fnDone, "resolve" ], 
     1063                                                fail: [ fnFail, "reject" ] 
     1064                                        }, function( handler, data ) { 
     1065                                                var fn = data[ 0 ], 
     1066                                                        action = data[ 1 ], 
     1067                                                        returned; 
     1068                                                if ( jQuery.isFunction( fn ) ) { 
     1069                                                        deferred[ handler ](function() { 
     1070                                                                returned = fn.apply( this, arguments ); 
     1071                                                                if ( returned && jQuery.isFunction( returned.promise ) ) { 
     1072                                                                        returned.promise().then( newDefer.resolve, newDefer.reject ); 
     1073                                                                } else { 
     1074                                                                        newDefer[ action ]( returned ); 
     1075                                                                } 
     1076                                                        }); 
     1077                                                } else { 
     1078                                                        deferred[ handler ]( newDefer[ action ] ); 
     1079                                                } 
     1080                                        }); 
     1081                                }).promise(); 
     1082                        }, 
    9161083                        // Get a promise for this deferred 
    9171084                        // If obj is provided, the promise aspect is added to the object 
     
    9291096                                return obj; 
    9301097                        } 
    931                 } ); 
     1098                }); 
    9321099                // Make sure only one callback list will be used 
    9331100                deferred.done( failDeferred.cancel ).fail( deferred.cancel ); 
     
    9421109 
    9431110        // Deferred helper 
    944         when: function( object ) { 
    945                 var lastIndex = arguments.length, 
    946                         deferred = lastIndex <= 1 && object && jQuery.isFunction( object.promise ) ? 
    947                                 object : 
    948                                 jQuery.Deferred(), 
    949                         promise = deferred.promise(); 
    950  
    951                 if ( lastIndex > 1 ) { 
    952                         var array = slice.call( arguments, 0 ), 
    953                                 count = lastIndex, 
    954                                 iCallback = function( index ) { 
    955                                         return function( value ) { 
    956                                                 array[ index ] = arguments.length > 1 ? slice.call( arguments, 0 ) : value; 
    957                                                 if ( !( --count ) ) { 
    958                                                         deferred.resolveWith( promise, array ); 
    959                                                 } 
    960                                         }; 
    961                                 }; 
    962                         while( ( lastIndex-- ) ) { 
    963                                 object = array[ lastIndex ]; 
    964                                 if ( object && jQuery.isFunction( object.promise ) ) { 
    965                                         object.promise().then( iCallback(lastIndex), deferred.reject ); 
     1111        when: function( firstParam ) { 
     1112                var args = arguments, 
     1113                        i = 0, 
     1114                        length = args.length, 
     1115                        count = length, 
     1116                        deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ? 
     1117                                firstParam : 
     1118                                jQuery.Deferred(); 
     1119                function resolveFunc( i ) { 
     1120                        return function( value ) { 
     1121                                args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value; 
     1122                                if ( !( --count ) ) { 
     1123                                        // Strange bug in FF4: 
     1124                                        // Values changed onto the arguments object sometimes end up as undefined values 
     1125                                        // outside the $.when method. Cloning the object into a fresh array solves the issue 
     1126                                        deferred.resolveWith( deferred, sliceDeferred.call( args, 0 ) ); 
     1127                                } 
     1128                        }; 
     1129                } 
     1130                if ( length > 1 ) { 
     1131                        for( ; i < length; i++ ) { 
     1132                                if ( args[ i ] && jQuery.isFunction( args[ i ].promise ) ) { 
     1133                                        args[ i ].promise().then( resolveFunc(i), deferred.reject ); 
    9661134                                } else { 
    9671135                                        --count; 
     
    9691137                        } 
    9701138                        if ( !count ) { 
    971                                 deferred.resolveWith( promise, array ); 
    972                         } 
    973                 } else if ( deferred !== object ) { 
    974                         deferred.resolve( object ); 
    975                 } 
    976                 return promise; 
    977         }, 
    978  
    979         // Use of jQuery.browser is frowned upon. 
    980         // More details: http://docs.jquery.com/Utilities/jQuery.browser 
    981         uaMatch: function( ua ) { 
    982                 ua = ua.toLowerCase(); 
    983  
    984                 var match = rwebkit.exec( ua ) || 
    985                         ropera.exec( ua ) || 
    986                         rmsie.exec( ua ) || 
    987                         ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) || 
    988                         []; 
    989  
    990                 return { browser: match[1] || "", version: match[2] || "0" }; 
    991         }, 
    992  
    993         sub: function() { 
    994                 function jQuerySubclass( selector, context ) { 
    995                         return new jQuerySubclass.fn.init( selector, context ); 
    996                 } 
    997                 jQuery.extend( true, jQuerySubclass, this ); 
    998                 jQuerySubclass.superclass = this; 
    999                 jQuerySubclass.fn = jQuerySubclass.prototype = this(); 
    1000                 jQuerySubclass.fn.constructor = jQuerySubclass; 
    1001                 jQuerySubclass.subclass = this.subclass; 
    1002                 jQuerySubclass.fn.init = function init( selector, context ) { 
    1003                         if ( context && context instanceof jQuery && !(context instanceof jQuerySubclass) ) { 
    1004                                 context = jQuerySubclass(context); 
    1005                         } 
    1006  
    1007                         return jQuery.fn.init.call( this, selector, context, rootjQuerySubclass ); 
    1008                 }; 
    1009                 jQuerySubclass.fn.init.prototype = jQuerySubclass.fn; 
    1010                 var rootjQuerySubclass = jQuerySubclass(document); 
    1011                 return jQuerySubclass; 
    1012         }, 
    1013  
    1014         browser: {} 
     1139                                deferred.resolveWith( deferred, args ); 
     1140                        } 
     1141                } else if ( deferred !== firstParam ) { 
     1142                        deferred.resolveWith( deferred, length ? [ firstParam ] : [] ); 
     1143                } 
     1144                return deferred.promise(); 
     1145        } 
    10151146}); 
    10161147 
    1017 // Create readyList deferred 
    1018 readyList = jQuery._Deferred(); 
    1019  
    1020 // Populate the class2type map 
    1021 jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) { 
    1022         class2type[ "[object " + name + "]" ] = name.toLowerCase(); 
    1023 }); 
    1024  
    1025 browserMatch = jQuery.uaMatch( userAgent ); 
    1026 if ( browserMatch.browser ) { 
    1027         jQuery.browser[ browserMatch.browser ] = true; 
    1028         jQuery.browser.version = browserMatch.version; 
    1029 } 
    1030  
    1031 // Deprecated, use jQuery.browser.webkit instead 
    1032 if ( jQuery.browser.webkit ) { 
    1033         jQuery.browser.safari = true; 
    1034 } 
    1035  
    1036 if ( indexOf ) { 
    1037         jQuery.inArray = function( elem, array ) { 
    1038                 return indexOf.call( array, elem ); 
    1039         }; 
    1040 } 
    1041  
    1042 // IE doesn't match non-breaking spaces with \s 
    1043 if ( rnotwhite.test( "\xA0" ) ) { 
    1044         trimLeft = /^[\s\xA0]+/; 
    1045         trimRight = /[\s\xA0]+$/; 
    1046 } 
    1047  
    1048 // All jQuery objects should point back to these 
    1049 rootjQuery = jQuery(document); 
    1050  
    1051 // Cleanup functions for the document ready method 
    1052 if ( document.addEventListener ) { 
    1053         DOMContentLoaded = function() { 
    1054                 document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false ); 
    1055                 jQuery.ready(); 
    1056         }; 
    1057  
    1058 } else if ( document.attachEvent ) { 
    1059         DOMContentLoaded = function() { 
    1060                 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). 
    1061                 if ( document.readyState === "complete" ) { 
    1062                         document.detachEvent( "onreadystatechange", DOMContentLoaded ); 
    1063                         jQuery.ready(); 
    1064                 } 
    1065         }; 
    1066 } 
    1067  
    1068 // The DOM ready check for Internet Explorer 
    1069 function doScrollCheck() { 
    1070         if ( jQuery.isReady ) { 
    1071                 return; 
    1072         } 
    1073  
    1074         try { 
    1075                 // If IE is used, use the trick by Diego Perini 
    1076                 // http://javascript.nwbox.com/IEContentLoaded/ 
    1077                 document.documentElement.doScroll("left"); 
    1078         } catch(e) { 
    1079                 setTimeout( doScrollCheck, 1 ); 
    1080                 return; 
    1081         } 
    1082  
    1083         // and execute any waiting functions 
    1084         jQuery.ready(); 
    1085 } 
    1086  
    1087 // Expose jQuery to the global object 
    1088 return jQuery; 
    1089  
    1090 })(); 
    1091  
    1092  
    1093 (function() { 
    1094  
    1095         jQuery.support = {}; 
    1096  
    1097         var div = document.createElement("div"); 
    1098  
    1099         div.style.display = "none"; 
    1100         div.innerHTML = "   <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>"; 
    1101  
    1102         var all = div.getElementsByTagName("*"), 
    1103                 a = div.getElementsByTagName("a")[0], 
    1104                 select = document.createElement("select"), 
    1105                 opt = select.appendChild( document.createElement("option") ), 
    1106                 input = div.getElementsByTagName("input")[0]; 
     1148 
     1149 
     1150jQuery.support = (function() { 
     1151 
     1152        var div = document.createElement( "div" ), 
     1153                documentElement = document.documentElement, 
     1154                all, 
     1155                a, 
     1156                select, 
     1157                opt, 
     1158                input, 
     1159                marginDiv, 
     1160                support, 
     1161                fragment, 
     1162                body, 
     1163                testElementParent, 
     1164                testElement, 
     1165                testElementStyle, 
     1166                tds, 
     1167                events, 
     1168                eventName, 
     1169                i, 
     1170                isSupported; 
     1171 
     1172        // Preliminary tests 
     1173        div.setAttribute("className", "t"); 
     1174        div.innerHTML = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>"; 
     1175 
     1176        all = div.getElementsByTagName( "*" ); 
     1177        a = div.getElementsByTagName( "a" )[ 0 ]; 
    11071178 
    11081179        // Can't get basic test support 
    11091180        if ( !all || !all.length || !a ) { 
    1110                 return; 
    1111         } 
    1112  
    1113         jQuery.support = { 
     1181                return {}; 
     1182        } 
     1183 
     1184        // First batch of supports tests 
     1185        select = document.createElement( "select" ); 
     1186        opt = select.appendChild( document.createElement("option") ); 
     1187        input = div.getElementsByTagName( "input" )[ 0 ]; 
     1188 
     1189        support = { 
    11141190                // IE strips leading whitespace when .innerHTML is used 
    1115                 leadingWhitespace: div.firstChild.nodeType === 3, 
     1191                leadingWhitespace: ( div.firstChild.nodeType === 3 ), 
    11161192 
    11171193                // Make sure that tbody elements aren't automatically inserted 
    11181194                // IE will insert them into empty tables 
    1119                 tbody: !div.getElementsByTagName("tbody").length, 
     1195                tbody: !div.getElementsByTagName( "tbody" ).length, 
    11201196 
    11211197                // Make sure that link elements get serialized correctly by innerHTML 
    11221198                // This requires a wrapper element in IE 
    1123                 htmlSerialize: !!div.getElementsByTagName("link").length, 
     1199                htmlSerialize: !!div.getElementsByTagName( "link" ).length, 
    11241200 
    11251201                // Get the style information from getAttribute 
    1126                 // (IE uses .cssText insted) 
    1127                 style: /red/.test( a.getAttribute("style") ), 
     1202                // (IE uses .cssText instead) 
     1203                style: /top/.test( a.getAttribute("style") ), 
    11281204 
    11291205                // Make sure that URLs aren't manipulated 
    11301206                // (IE normalizes it by default) 
    1131                 hrefNormalized: a.getAttribute("href") === "/a", 
     1207                hrefNormalized: ( a.getAttribute( "href" ) === "/a" ), 
    11321208 
    11331209                // Make sure that element opacity exists 
     
    11431219                // that it defaults to "on". 
    11441220                // (WebKit defaults to "" instead) 
    1145                 checkOn: input.value === "on", 
     1221                checkOn: ( input.value === "on" ), 
    11461222 
    11471223                // Make sure that a selected-by-default option has a working selected property. 
     
    11491225                optSelected: opt.selected, 
    11501226 
     1227                // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7) 
     1228                getSetAttribute: div.className !== "t", 
     1229 
    11511230                // Will be defined later 
     1231                submitBubbles: true, 
     1232                changeBubbles: true, 
     1233                focusinBubbles: false, 
    11521234                deleteExpando: true, 
    1153                 optDisabled: false, 
    1154                 checkClone: false, 
    11551235                noCloneEvent: true, 
    1156                 noCloneChecked: true, 
    1157                 boxModel: null, 
    11581236                inlineBlockNeedsLayout: false, 
    11591237                shrinkWrapBlocks: false, 
    1160                 reliableHiddenOffsets: true 
     1238                reliableMarginRight: true 
    11611239        }; 
    11621240 
     1241        // Make sure checked status is properly cloned 
    11631242        input.checked = true; 
    1164         jQuery.support.noCloneChecked = input.cloneNode( true ).checked; 
     1243        support.noCloneChecked = input.cloneNode( true ).checked; 
    11651244 
    11661245        // Make sure that the options inside disabled selects aren't marked as disabled 
    1167         // (WebKit marks them as diabled) 
     1246        // (WebKit marks them as disabled) 
    11681247        select.disabled = true; 
    1169         jQuery.support.optDisabled = !opt.disabled; 
    1170  
    1171         var _scriptEval = null; 
    1172         jQuery.support.scriptEval = function() { 
    1173                 if ( _scriptEval === null ) { 
    1174                         var root = document.documentElement, 
    1175                                 script = document.createElement("script"), 
    1176                                 id = "script" + jQuery.now(); 
    1177  
    1178                         try { 
    1179                                 script.appendChild( document.createTextNode( "window." + id + "=1;" ) ); 
    1180                         } catch(e) {} 
    1181  
    1182                         root.insertBefore( script, root.firstChild ); 
    1183  
    1184                         // Make sure that the execution of code works by injecting a script 
    1185                         // tag with appendChild/createTextNode 
    1186                         // (IE doesn't support this, fails, and uses .text instead) 
    1187                         if ( window[ id ] ) { 
    1188                                 _scriptEval = true; 
    1189                                 delete window[ id ]; 
    1190                         } else { 
    1191                                 _scriptEval = false; 
    1192                         } 
    1193  
    1194                         root.removeChild( script ); 
    1195                         // release memory in IE 
    1196                         root = script = id  = null; 
    1197                 } 
    1198  
    1199                 return _scriptEval; 
    1200         }; 
     1248        support.optDisabled = !opt.disabled; 
    12011249 
    12021250        // Test to see if it's possible to delete an expando from an element 
     
    12041252        try { 
    12051253                delete div.test; 
    1206  
    1207         } catch(e) { 
    1208                 jQuery.support.deleteExpando = false; 
     1254        } catch( e ) { 
     1255                support.deleteExpando = false; 
    12091256        } 
    12101257 
    12111258        if ( !div.addEventListener && div.attachEvent && div.fireEvent ) { 
    1212                 div.attachEvent("onclick", function click() { 
     1259                div.attachEvent( "onclick", function() { 
    12131260                        // Cloning a node shouldn't copy over any 
    12141261                        // bound event handlers (IE does this) 
    1215                         jQuery.support.noCloneEvent = false; 
    1216                         div.detachEvent("onclick", click); 
     1262                        support.noCloneEvent = false; 
    12171263                }); 
    1218                 div.cloneNode(true).fireEvent("onclick"); 
    1219         } 
    1220  
    1221         div = document.createElement("div"); 
    1222         div.innerHTML = "<input type='radio' name='radiotest' checked='checked'/>"; 
    1223  
    1224         var fragment = document.createDocumentFragment(); 
     1264                div.cloneNode( true ).fireEvent( "onclick" ); 
     1265        } 
     1266 
     1267        // Check if a radio maintains it's value 
     1268        // after being appended to the DOM 
     1269        input = document.createElement("input"); 
     1270        input.value = "t"; 
     1271        input.setAttribute("type", "radio"); 
     1272        support.radioValue = input.value === "t"; 
     1273 
     1274        input.setAttribute("checked", "checked"); 
     1275        div.appendChild( input ); 
     1276        fragment = document.createDocumentFragment(); 
    12251277        fragment.appendChild( div.firstChild ); 
    12261278 
    12271279        // WebKit doesn't clone checked state correctly in fragments 
    1228         jQuery.support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked; 
     1280        support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked; 
     1281 
     1282        div.innerHTML = ""; 
    12291283 
    12301284        // Figure out if the W3C box model works as expected 
    1231         // document.body must exist before we can do this 
    1232         jQuery(function() { 
    1233                 var div = document.createElement("div"), 
    1234                         body = document.getElementsByTagName("body")[0]; 
    1235  
    1236                 // Frameset documents with no body should not run this code 
    1237                 if ( !body ) { 
    1238                         return; 
    1239                 } 
    1240  
    1241                 div.style.width = div.style.paddingLeft = "1px"; 
    1242                 body.appendChild( div ); 
    1243                 jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2; 
    1244  
    1245                 if ( "zoom" in div.style ) { 
    1246                         // Check if natively block-level elements act like inline-block 
    1247                         // elements when setting their display to 'inline' and giving 
    1248                         // them layout 
    1249                         // (IE < 8 does this) 
    1250                         div.style.display = "inline"; 
    1251                         div.style.zoom = 1; 
    1252                         jQuery.support.inlineBlockNeedsLayout = div.offsetWidth === 2; 
    1253  
    1254                         // Check if elements with layout shrink-wrap their children 
    1255                         // (IE 6 does this) 
    1256                         div.style.display = ""; 
    1257                         div.innerHTML = "<div style='width:4px;'></div>"; 
    1258                         jQuery.support.shrinkWrapBlocks = div.offsetWidth !== 2; 
    1259                 } 
    1260  
    1261                 div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>"; 
    1262                 var tds = div.getElementsByTagName("td"); 
    1263  
    1264                 // Check if table cells still have offsetWidth/Height when they are set 
    1265                 // to display:none and there are still other visible table cells in a 
    1266                 // table row; if so, offsetWidth/Height are not reliable for use when 
    1267                 // determining if an element has been hidden directly using 
    1268                 // display:none (it is still safe to use offsets if a parent element is 
    1269                 // hidden; don safety goggles and see bug #4512 for more information). 
    1270                 // (only IE 8 fails this test) 
    1271                 jQuery.support.reliableHiddenOffsets = tds[0].offsetHeight === 0; 
    1272  
    1273                 tds[0].style.display = ""; 
    1274                 tds[1].style.display = "none"; 
    1275  
    1276                 // Check if empty table cells still have offsetWidth/Height 
    1277                 // (IE < 8 fail this test) 
    1278                 jQuery.support.reliableHiddenOffsets = jQuery.support.reliableHiddenOffsets && tds[0].offsetHeight === 0; 
    1279                 div.innerHTML = ""; 
    1280  
    1281                 body.removeChild( div ).style.display = "none"; 
    1282                 div = tds = null; 
    1283         }); 
     1285        div.style.width = div.style.paddingLeft = "1px"; 
     1286 
     1287        body = document.getElementsByTagName( "body" )[ 0 ]; 
     1288        // We use our own, invisible, body unless the body is already present 
     1289        // in which case we use a div (#9239) 
     1290        testElement = document.createElement( body ? "div" : "body" ); 
     1291        testElementStyle = { 
     1292                visibility: "hidden", 
     1293                width: 0, 
     1294                height: 0, 
     1295                border: 0, 
     1296                margin: 0 
     1297        }; 
     1298        if ( body ) { 
     1299                jQuery.extend( testElementStyle, { 
     1300                        position: "absolute", 
     1301                        left: -1000, 
     1302                        top: -1000 
     1303                }); 
     1304        } 
     1305        for ( i in testElementStyle ) { 
     1306                testElement.style[ i ] = testElementStyle[ i ]; 
     1307        } 
     1308        testElement.appendChild( div ); 
     1309        testElementParent = body || documentElement; 
     1310        testElementParent.insertBefore( testElement, testElementParent.firstChild ); 
     1311 
     1312        // Check if a disconnected checkbox will retain its checked 
     1313        // value of true after appended to the DOM (IE6/7) 
     1314        support.appendChecked = input.checked; 
     1315 
     1316        support.boxModel = div.offsetWidth === 2; 
     1317 
     1318        if ( "zoom" in div.style ) { 
     1319                // Check if natively block-level elements act like inline-block 
     1320                // elements when setting their display to 'inline' and giving 
     1321                // them layout 
     1322                // (IE < 8 does this) 
     1323                div.style.display = "inline"; 
     1324                div.style.zoom = 1; 
     1325                support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 ); 
     1326 
     1327                // Check if elements with layout shrink-wrap their children 
     1328                // (IE 6 does this) 
     1329                div.style.display = ""; 
     1330                div.innerHTML = "<div style='width:4px;'></div>"; 
     1331                support.shrinkWrapBlocks = ( div.offsetWidth !== 2 ); 
     1332        } 
     1333 
     1334        div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>"; 
     1335        tds = div.getElementsByTagName( "td" ); 
     1336 
     1337        // Check if table cells still have offsetWidth/Height when they are set 
     1338        // to display:none and there are still other visible table cells in a 
     1339        // table row; if so, offsetWidth/Height are not reliable for use when 
     1340        // determining if an element has been hidden directly using 
     1341        // display:none (it is still safe to use offsets if a parent element is 
     1342        // hidden; don safety goggles and see bug #4512 for more information). 
     1343        // (only IE 8 fails this test) 
     1344        isSupported = ( tds[ 0 ].offsetHeight === 0 ); 
     1345 
     1346        tds[ 0 ].style.display = ""; 
     1347        tds[ 1 ].style.display = "none"; 
     1348 
     1349        // Check if empty table cells still have offsetWidth/Height 
     1350        // (IE < 8 fail this test) 
     1351        support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 ); 
     1352        div.innerHTML = ""; 
     1353 
     1354        // Check if div with explicit width and no margin-right incorrectly 
     1355        // gets computed margin-right based on width of container. For more 
     1356        // info see bug #3333 
     1357        // Fails in WebKit before Feb 2011 nightlies 
     1358        // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right 
     1359        if ( document.defaultView && document.defaultView.getComputedStyle ) { 
     1360                marginDiv = document.createElement( "div" ); 
     1361                marginDiv.style.width = "0"; 
     1362                marginDiv.style.marginRight = "0"; 
     1363                div.appendChild( marginDiv ); 
     1364                support.reliableMarginRight = 
     1365                        ( parseInt( ( document.defaultView.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0; 
     1366        } 
     1367 
     1368        // Remove the body element we added 
     1369        testElement.innerHTML = ""; 
     1370        testElementParent.removeChild( testElement ); 
    12841371 
    12851372        // Technique from Juriy Zaytsev 
    12861373        // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/ 
    1287         var eventSupported = function( eventName ) { 
    1288                 var el = document.createElement("div"); 
    1289                 eventName = "on" + eventName; 
    1290  
    1291                 // We only care about the case where non-standard event systems 
    1292                 // are used, namely in IE. Short-circuiting here helps us to 
    1293                 // avoid an eval call (in setAttribute) which can cause CSP 
    1294                 // to go haywire. See: https://developer.mozilla.org/en/Security/CSP 
    1295                 if ( !el.attachEvent ) { 
    1296                         return true; 
    1297                 } 
    1298  
    1299                 var isSupported = (eventName in el); 
    1300                 if ( !isSupported ) { 
    1301                         el.setAttribute(eventName, "return;"); 
    1302                         isSupported = typeof el[eventName] === "function"; 
    1303                 } 
    1304                 el = null; 
    1305  
    1306                 return isSupported; 
    1307         }; 
    1308  
    1309         jQuery.support.submitBubbles = eventSupported("submit"); 
    1310         jQuery.support.changeBubbles = eventSupported("change"); 
    1311  
    1312         // release memory in IE 
    1313         div = all = a = null; 
     1374        // We only care about the case where non-standard event systems 
     1375        // are used, namely in IE. Short-circuiting here helps us to 
     1376        // avoid an eval call (in setAttribute) which can cause CSP 
     1377        // to go haywire. See: https://developer.mozilla.org/en/Security/CSP 
     1378        if ( div.attachEvent ) { 
     1379                for( i in { 
     1380                        submit: 1, 
     1381                        change: 1, 
     1382                        focusin: 1 
     1383                } ) { 
     1384                        eventName = "on" + i; 
     1385                        isSupported = ( eventName in div ); 
     1386                        if ( !isSupported ) { 
     1387                                div.setAttribute( eventName, "return;" ); 
     1388                                isSupported = ( typeof div[ eventName ] === "function" ); 
     1389                        } 
     1390                        support[ i + "Bubbles" ] = isSupported; 
     1391                } 
     1392        } 
     1393 
     1394        // Null connected elements to avoid leaks in IE 
     1395        testElement = fragment = select = opt = body = marginDiv = div = input = null; 
     1396 
     1397        return support; 
    13141398})(); 
    13151399 
    1316  
    1317  
    1318 var rbrace = /^(?:\{.*\}|\[.*\])$/; 
     1400// Keep track of boxModel 
     1401jQuery.boxModel = jQuery.support.boxModel; 
     1402 
     1403 
     1404 
     1405 
     1406var rbrace = /^(?:\{.*\}|\[.*\])$/, 
     1407        rmultiDash = /([a-z])([A-Z])/g; 
    13191408 
    13201409jQuery.extend({ 
     
    14131502 
    14141503                if ( data !== undefined ) { 
    1415                         thisCache[ name ] = data; 
     1504                        thisCache[ jQuery.camelCase( name ) ] = data; 
    14161505                } 
    14171506 
     
    14231512                } 
    14241513 
    1425                 return getByName ? thisCache[ name ] : thisCache; 
     1514                return getByName ?  
     1515                        // Check for both converted-to-camel and non-converted data property names 
     1516                        thisCache[ jQuery.camelCase( name ) ] || thisCache[ name ] : 
     1517                        thisCache; 
    14261518        }, 
    14271519 
     
    15391631 
    15401632                                if ( this[0].nodeType === 1 ) { 
    1541                                         var attr = this[0].attributes, name; 
     1633                            var attr = this[0].attributes, name; 
    15421634                                        for ( var i = 0, l = attr.length; i < l; i++ ) { 
    15431635                                                name = attr[i].name; 
    15441636 
    15451637                                                if ( name.indexOf( "data-" ) === 0 ) { 
    1546                                                         name = name.substr( 5 ); 
     1638                                                        name = jQuery.camelCase( name.substring(5) ); 
     1639 
    15471640                                                        dataAttr( this[0], name, data[ name ] ); 
    15481641                                                } 
     
    15981691        // data from the HTML5 data-* attribute 
    15991692        if ( data === undefined && elem.nodeType === 1 ) { 
    1600                 data = elem.getAttribute( "data-" + key ); 
     1693                var name = "data-" + key.replace( rmultiDash, "$1-$2" ).toLowerCase(); 
     1694 
     1695                data = elem.getAttribute( name ); 
    16011696 
    16021697                if ( typeof data === "string" ) { 
     
    16371732 
    16381733 
     1734function handleQueueMarkDefer( elem, type, src ) { 
     1735        var deferDataKey = type + "defer", 
     1736                queueDataKey = type + "queue", 
     1737                markDataKey = type + "mark", 
     1738                defer = jQuery.data( elem, deferDataKey, undefined, true ); 
     1739        if ( defer && 
     1740                ( src === "queue" || !jQuery.data( elem, queueDataKey, undefined, true ) ) && 
     1741                ( src === "mark" || !jQuery.data( elem, markDataKey, undefined, true ) ) ) { 
     1742                // Give room for hard-coded callbacks to fire first 
     1743                // and eventually mark/queue something else on the element 
     1744                setTimeout( function() { 
     1745                        if ( !jQuery.data( elem, queueDataKey, undefined, true ) && 
     1746                                !jQuery.data( elem, markDataKey, undefined, true ) ) { 
     1747                                jQuery.removeData( elem, deferDataKey, true ); 
     1748                                defer.resolve(); 
     1749                        } 
     1750                }, 0 ); 
     1751        } 
     1752} 
     1753 
    16391754jQuery.extend({ 
     1755 
     1756        _mark: function( elem, type ) { 
     1757                if ( elem ) { 
     1758                        type = (type || "fx") + "mark"; 
     1759                        jQuery.data( elem, type, (jQuery.data(elem,type,undefined,true) || 0) + 1, true ); 
     1760                } 
     1761        }, 
     1762 
     1763        _unmark: function( force, elem, type ) { 
     1764                if ( force !== true ) { 
     1765                        type = elem; 
     1766                        elem = force; 
     1767                        force = false; 
     1768                } 
     1769                if ( elem ) { 
     1770                        type = type || "fx"; 
     1771                        var key = type + "mark", 
     1772                                count = force ? 0 : ( (jQuery.data( elem, key, undefined, true) || 1 ) - 1 ); 
     1773                        if ( count ) { 
     1774                                jQuery.data( elem, key, count, true ); 
     1775                        } else { 
     1776                                jQuery.removeData( elem, key, true ); 
     1777                                handleQueueMarkDefer( elem, type, "mark" ); 
     1778                        } 
     1779                } 
     1780        }, 
     1781 
    16401782        queue: function( elem, type, data ) { 
    1641                 if ( !elem ) { 
    1642                         return; 
    1643                 } 
    1644  
    1645                 type = (type || "fx") + "queue"; 
    1646                 var q = jQuery._data( elem, type ); 
    1647  
    1648                 // Speed up dequeue by getting out quickly if this is just a lookup 
    1649                 if ( !data ) { 
     1783                if ( elem ) { 
     1784                        type = (type || "fx") + "queue"; 
     1785                        var q = jQuery.data( elem, type, undefined, true ); 
     1786                        // Speed up dequeue by getting out quickly if this is just a lookup 
     1787                        if ( data ) { 
     1788                                if ( !q || jQuery.isArray(data) ) { 
     1789                                        q = jQuery.data( elem, type, jQuery.makeArray(data), true ); 
     1790                                } else { 
     1791                                        q.push( data ); 
     1792                                } 
     1793                        } 
    16501794                        return q || []; 
    16511795                } 
    1652  
    1653                 if ( !q || jQuery.isArray(data) ) { 
    1654                         q = jQuery._data( elem, type, jQuery.makeArray(data) ); 
    1655  
    1656                 } else { 
    1657                         q.push( data ); 
    1658                 } 
    1659  
    1660                 return q; 
    16611796        }, 
    16621797 
     
    16651800 
    16661801                var queue = jQuery.queue( elem, type ), 
    1667                         fn = queue.shift(); 
     1802                        fn = queue.shift(), 
     1803                        defer; 
    16681804 
    16691805                // If the fx queue is dequeued, always remove the progress sentinel 
     
    16861822                if ( !queue.length ) { 
    16871823                        jQuery.removeData( elem, type + "queue", true ); 
     1824                        handleQueueMarkDefer( elem, type, "queue" ); 
    16881825                } 
    16891826        } 
     
    17001837                        return jQuery.queue( this[0], type ); 
    17011838                } 
    1702                 return this.each(function( i ) { 
     1839                return this.each(function() { 
    17031840                        var queue = jQuery.queue( this, type, data ); 
    17041841 
     
    17131850                }); 
    17141851        }, 
    1715  
    17161852        // Based off of the plugin by Clint Helfers, with permission. 
    17171853        // http://blindsignals.com/index.php/2009/07/jquery-delay/ 
     
    17271863                }); 
    17281864        }, 
    1729  
    17301865        clearQueue: function( type ) { 
    17311866                return this.queue( type || "fx", [] ); 
     1867        }, 
     1868        // Get a promise resolved when queues of a certain type 
     1869        // are emptied (fx is the type by default) 
     1870        promise: function( type, object ) { 
     1871                if ( typeof type !== "string" ) { 
     1872                        object = type; 
     1873                        type = undefined; 
     1874                } 
     1875                type = type || "fx"; 
     1876                var defer = jQuery.Deferred(), 
     1877                        elements = this, 
     1878                        i = elements.length, 
     1879                        count = 1, 
     1880                        deferDataKey = type + "defer", 
     1881                        queueDataKey = type + "queue", 
     1882                        markDataKey = type + "mark", 
     1883                        tmp; 
     1884                function resolve() { 
     1885                        if ( !( --count ) ) { 
     1886                                defer.resolveWith( elements, [ elements ] ); 
     1887                        } 
     1888                } 
     1889                while( i-- ) { 
     1890                        if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) || 
     1891                                        ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) || 
     1892                                                jQuery.data( elements[ i ], markDataKey, undefined, true ) ) && 
     1893                                        jQuery.data( elements[ i ], deferDataKey, jQuery._Deferred(), true ) )) { 
     1894                                count++; 
     1895                                tmp.done( resolve ); 
     1896                        } 
     1897                } 
     1898                resolve(); 
     1899                return defer.promise(); 
    17321900        } 
    17331901}); 
     
    17371905 
    17381906var rclass = /[\n\t\r]/g, 
    1739         rspaces = /\s+/, 
     1907        rspace = /\s+/, 
    17401908        rreturn = /\r/g, 
    1741         rspecialurl = /^(?:href|src|style)$/, 
    17421909        rtype = /^(?:button|input)$/i, 
    17431910        rfocusable = /^(?:button|input|object|select|textarea)$/i, 
    17441911        rclickable = /^a(?:rea)?$/i, 
    1745         rradiocheck = /^(?:radio|checkbox)$/i; 
    1746  
    1747 jQuery.props = { 
    1748         "for": "htmlFor", 
    1749         "class": "className", 
    1750         readonly: "readOnly", 
    1751         maxlength: "maxLength", 
    1752         cellspacing: "cellSpacing", 
    1753         rowspan: "rowSpan", 
    1754         colspan: "colSpan", 
    1755         tabindex: "tabIndex", 
    1756         usemap: "useMap", 
    1757         frameborder: "frameBorder" 
    1758 }; 
     1912        rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i, 
     1913        rinvalidChar = /\:|^on/, 
     1914        formHook, boolHook; 
    17591915 
    17601916jQuery.fn.extend({ 
     
    17631919        }, 
    17641920 
    1765         removeAttr: function( name, fn ) { 
    1766                 return this.each(function(){ 
    1767                         jQuery.attr( this, name, "" ); 
    1768                         if ( this.nodeType === 1 ) { 
    1769                                 this.removeAttribute( name ); 
    1770                         } 
     1921        removeAttr: function( name ) { 
     1922                return this.each(function() { 
     1923                        jQuery.removeAttr( this, name ); 
    17711924                }); 
    17721925        }, 
     1926         
     1927        prop: function( name, value ) { 
     1928                return jQuery.access( this, name, value, true, jQuery.prop ); 
     1929        }, 
     1930         
     1931        removeProp: function( name ) { 
     1932                name = jQuery.propFix[ name ] || name; 
     1933                return this.each(function() { 
     1934                        // try/catch handles cases where IE balks (such as removing a property on window) 
     1935                        try { 
     1936                                this[ name ] = undefined; 
     1937                                delete this[ name ]; 
     1938                        } catch( e ) {} 
     1939                }); 
     1940        }, 
    17731941 
    17741942        addClass: function( value ) { 
    1775                 if ( jQuery.isFunction(value) ) { 
    1776                         return this.each(function(i) { 
    1777                                 var self = jQuery(this); 
    1778                                 self.addClass( value.call(this, i, self.attr("class")) ); 
     1943                var classNames, i, l, elem, 
     1944                        setClass, c, cl; 
     1945 
     1946                if ( jQuery.isFunction( value ) ) { 
     1947                        return this.each(function( j ) { 
     1948                                jQuery( this ).addClass( value.call(this, j, this.className) ); 
    17791949                        }); 
    17801950                } 
    17811951 
    17821952                if ( value && typeof value === "string" ) { 
    1783                         var classNames = (value || "").split( rspaces ); 
    1784  
    1785                         for ( var i = 0, l = this.length; i < l; i++ ) { 
    1786                                 var elem = this[i]; 
     1953                        classNames = value.split( rspace ); 
     1954 
     1955                        for ( i = 0, l = this.length; i < l; i++ ) { 
     1956                                elem = this[ i ]; 
    17871957 
    17881958                                if ( elem.nodeType === 1 ) { 
    1789                                         if ( !elem.className ) { 
     1959                                        if ( !elem.className && classNames.length === 1 ) { 
    17901960                                                elem.className = value; 
    17911961 
    17921962                                        } else { 
    1793                                                 var className = " " + elem.className + " ", 
    1794                                                         setClass = elem.className; 
    1795  
    1796                                                 for ( var c = 0, cl = classNames.length; c < cl; c++ ) { 
    1797                                                         if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) { 
    1798                                                                 setClass += " " + classNames[c]; 
     1963                                                setClass = " " + elem.className + " "; 
     1964 
     1965                                                for ( c = 0, cl = classNames.length; c < cl; c++ ) { 
     1966                                                        if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) { 
     1967                                                                setClass += classNames[ c ] + " "; 
    17991968                                                        } 
    18001969                                                } 
     
    18091978 
    18101979        removeClass: function( value ) { 
    1811                 if ( jQuery.isFunction(value) ) { 
    1812                         return this.each(function(i) { 
    1813                                 var self = jQuery(this); 
    1814                                 self.removeClass( value.call(this, i, self.attr("class")) ); 
     1980                var classNames, i, l, elem, className, c, cl; 
     1981 
     1982                if ( jQuery.isFunction( value ) ) { 
     1983                        return this.each(function( j ) { 
     1984                                jQuery( this ).removeClass( value.call(this, j, this.className) ); 
    18151985                        }); 
    18161986                } 
    18171987 
    18181988                if ( (value && typeof value === "string") || value === undefined ) { 
    1819                         var classNames = (value || "").split( rspaces ); 
    1820  
    1821                         for ( var i = 0, l = this.length; i < l; i++ ) { 
    1822                                 var elem = this[i]; 
     1989                        classNames = (value || "").split( rspace ); 
     1990 
     1991                        for ( i = 0, l = this.length; i < l; i++ ) { 
     1992                                elem = this[ i ]; 
    18231993 
    18241994                                if ( elem.nodeType === 1 && elem.className ) { 
    18251995                                        if ( value ) { 
    1826                                                 var className = (" " + elem.className + " ").replace(rclass, " "); 
    1827                                                 for ( var c = 0, cl = classNames.length; c < cl; c++ ) { 
    1828                                                         className = className.replace(" " + classNames[c] + " ", " "); 
     1996                                                className = (" " + elem.className + " ").replace( rclass, " " ); 
     1997                                                for ( c = 0, cl = classNames.length; c < cl; c++ ) { 
     1998                                                        className = className.replace(" " + classNames[ c ] + " ", " "); 
    18291999                                                } 
    18302000                                                elem.className = jQuery.trim( className ); 
     
    18452015 
    18462016                if ( jQuery.isFunction( value ) ) { 
    1847                         return this.each(function(i) { 
    1848                                 var self = jQuery(this); 
    1849                                 self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal ); 
     2017                        return this.each(function( i ) { 
     2018                                jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal ); 
    18502019                        }); 
    18512020                } 
     
    18582027                                        self = jQuery( this ), 
    18592028                                        state = stateVal, 
    1860                                         classNames = value.split( rspaces ); 
     2029                                        classNames = value.split( rspace ); 
    18612030 
    18622031                                while ( (className = classNames[ i++ ]) ) { 
     
    18902059 
    18912060        val: function( value ) { 
     2061                var hooks, ret, 
     2062                        elem = this[0]; 
     2063                 
    18922064                if ( !arguments.length ) { 
    1893                         var elem = this[0]; 
    1894  
    18952065                        if ( elem ) { 
    1896                                 if ( jQuery.nodeName( elem, "option" ) ) { 
    1897                                         // attributes.value is undefined in Blackberry 4.7 but 
    1898                                         // uses .value. See #6932 
    1899                                         var val = elem.attributes.value; 
    1900                                         return !val || val.specified ? elem.value : elem.text; 
    1901                                 } 
    1902  
    1903                                 // We need to handle select boxes special 
    1904                                 if ( jQuery.nodeName( elem, "select" ) ) { 
    1905                                         var index = elem.selectedIndex, 
    1906                                                 values = [], 
    1907                                                 options = elem.options, 
    1908                                                 one = elem.type === "select-one"; 
    1909  
    1910                                         // Nothing was selected 
    1911                                         if ( index < 0 ) { 
    1912                                                 return null; 
    1913                                         } 
    1914  
    1915                                         // Loop through all the selected options 
    1916                                         for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) { 
    1917                                                 var option = options[ i ]; 
    1918  
    1919                                                 // Don't return options that are disabled or in a disabled optgroup 
    1920                                                 if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) && 
    1921                                                                 (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) { 
    1922  
    1923                                                         // Get the specific value for the option 
    1924                                                         value = jQuery(option).val(); 
    1925  
    1926                                                         // We don't need an array for one selects 
    1927                                                         if ( one ) { 
    1928                                                                 return value; 
    1929                                                         } 
    1930  
    1931                                                         // Multi-Selects return an array 
    1932                                                         values.push( value ); 
    1933                                                 } 
    1934                                         } 
    1935  
    1936                                         // Fixes Bug #2551 -- select.val() broken in IE after form.reset() 
    1937                                         if ( one && !values.length && options.length ) { 
    1938                                                 return jQuery( options[ index ] ).val(); 
    1939                                         } 
    1940  
    1941                                         return values; 
    1942                                 } 
    1943  
    1944                                 // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified 
    1945                                 if ( rradiocheck.test( elem.type ) && !jQuery.support.checkOn ) { 
    1946                                         return elem.getAttribute("value") === null ? "on" : elem.value; 
    1947                                 } 
    1948  
    1949                                 // Everything else, we just grab the value 
    1950                                 return (elem.value || "").replace(rreturn, ""); 
    1951  
     2066                                hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] || jQuery.valHooks[ elem.type ]; 
     2067 
     2068                                if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) { 
     2069                                        return ret; 
     2070                                } 
     2071 
     2072                                ret = elem.value; 
     2073 
     2074                                return typeof ret === "string" ?  
     2075                                        // handle most common string cases 
     2076                                        ret.replace(rreturn, "") :  
     2077                                        // handle cases where value is null/undef or number 
     2078                                        ret == null ? "" : ret; 
    19522079                        } 
    19532080 
     
    19552082                } 
    19562083 
    1957                 var isFunction = jQuery.isFunction(value); 
    1958  
    1959                 return this.each(function(i) { 
    1960                         var self = jQuery(this), val = value; 
     2084                var isFunction = jQuery.isFunction( value ); 
     2085 
     2086                return this.each(function( i ) { 
     2087                        var self = jQuery(this), val; 
    19612088 
    19622089                        if ( this.nodeType !== 1 ) { 
     
    19652092 
    19662093                        if ( isFunction ) { 
    1967                                 val = value.call(this, i, self.val()); 
     2094                                val = value.call( this, i, self.val() ); 
     2095                        } else { 
     2096                                val = value; 
    19682097                        } 
    19692098 
     
    19732102                        } else if ( typeof val === "number" ) { 
    19742103                                val += ""; 
    1975                         } else if ( jQuery.isArray(val) ) { 
    1976                                 val = jQuery.map(val, function (value) { 
     2104                        } else if ( jQuery.isArray( val ) ) { 
     2105                                val = jQuery.map(val, function ( value ) { 
    19772106                                        return value == null ? "" : value + ""; 
    19782107                                }); 
    19792108                        } 
    19802109 
    1981                         if ( jQuery.isArray(val) && rradiocheck.test( this.type ) ) { 
    1982                                 this.checked = jQuery.inArray( self.val(), val ) >= 0; 
    1983  
    1984                         } else if ( jQuery.nodeName( this, "select" ) ) { 
    1985                                 var values = jQuery.makeArray(val); 
    1986  
    1987                                 jQuery( "option", this ).each(function() { 
     2110                        hooks = jQuery.valHooks[ this.nodeName.toLowerCase() ] || jQuery.valHooks[ this.type ]; 
     2111 
     2112                        // If set returns undefined, fall back to normal setting 
     2113                        if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) { 
     2114                                this.value = val; 
     2115                        } 
     2116                }); 
     2117        } 
     2118}); 
     2119 
     2120jQuery.extend({ 
     2121        valHooks: { 
     2122                option: { 
     2123                        get: function( elem ) { 
     2124                                // attributes.value is undefined in Blackberry 4.7 but 
     2125                                // uses .value. See #6932 
     2126                                var val = elem.attributes.value; 
     2127                                return !val || val.specified ? elem.value : elem.text; 
     2128                        } 
     2129                }, 
     2130                select: { 
     2131                        get: function( elem ) { 
     2132                                var value, 
     2133                                        index = elem.selectedIndex, 
     2134                                        values = [], 
     2135                                        options = elem.options, 
     2136                                        one = elem.type === "select-one"; 
     2137 
     2138                                // Nothing was selected 
     2139                                if ( index < 0 ) { 
     2140                                        return null; 
     2141                                } 
     2142 
     2143                                // Loop through all the selected options 
     2144                                for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) { 
     2145                                        var option = options[ i ]; 
     2146 
     2147                                        // Don't return options that are disabled or in a disabled optgroup 
     2148                                        if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) && 
     2149                                                        (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) { 
     2150 
     2151                                                // Get the specific value for the option 
     2152                                                value = jQuery( option ).val(); 
     2153 
     2154                                                // We don't need an array for one selects 
     2155                                                if ( one ) { 
     2156                                                        return value; 
     2157                                                } 
     2158 
     2159                                                // Multi-Selects return an array 
     2160                                                values.push( value ); 
     2161                                        } 
     2162                                } 
     2163 
     2164                                // Fixes Bug #2551 -- select.val() broken in IE after form.reset() 
     2165                                if ( one && !values.length && options.length ) { 
     2166                                        return jQuery( options[ index ] ).val(); 
     2167                                } 
     2168 
     2169                                return values; 
     2170                        }, 
     2171 
     2172                        set: function( elem, value ) { 
     2173                                var values = jQuery.makeArray( value ); 
     2174 
     2175                                jQuery(elem).find("option").each(function() { 
    19882176                                        this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0; 
    19892177                                }); 
    19902178 
    19912179                                if ( !values.length ) { 
    1992                                         this.selectedIndex = -1; 
    1993                                 } 
    1994  
    1995                         } else { 
    1996                                 this.value = val; 
    1997                         } 
    1998                 }); 
    1999         } 
    2000 }); 
    2001  
    2002 jQuery.extend({ 
     2180                                        elem.selectedIndex = -1; 
     2181                                } 
     2182                                return values; 
     2183                        } 
     2184                } 
     2185        }, 
     2186 
    20032187        attrFn: { 
    20042188                val: true, 
     
    20112195                offset: true 
    20122196        }, 
    2013  
     2197         
     2198        attrFix: { 
     2199                // Always normalize to ensure hook usage 
     2200                tabindex: "tabIndex" 
     2201        }, 
     2202         
    20142203        attr: function( elem, name, value, pass ) { 
     2204                var nType = elem.nodeType; 
     2205                 
    20152206                // don't get/set attributes on text, comment and attribute nodes 
    2016                 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || elem.nodeType === 2 ) { 
     2207                if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { 
    20172208                        return undefined; 
    20182209                } 
    20192210 
    20202211                if ( pass && name in jQuery.attrFn ) { 
    2021                         return jQuery(elem)[name](value); 
    2022                 } 
    2023  
    2024                 var notxml = elem.nodeType !== 1 || !jQuery.isXMLDoc( elem ), 
    2025                         // Whether we are setting (or getting) 
    2026                         set = value !== undefined; 
    2027  
    2028                 // Try to normalize/fix the name 
    2029                 name = notxml && jQuery.props[ name ] || name; 
    2030  
    2031                 // Only do all the following if this is a node (faster for style) 
     2212                        return jQuery( elem )[ name ]( value ); 
     2213                } 
     2214 
     2215                // Fallback to prop when attributes are not supported 
     2216                if ( !("getAttribute" in elem) ) { 
     2217                        return jQuery.prop( elem, name, value ); 
     2218                } 
     2219 
     2220                var ret, hooks, 
     2221                        notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); 
     2222 
     2223                // Normalize the name if needed 
     2224                if ( notxml ) { 
     2225                        name = jQuery.attrFix[ name ] || name; 
     2226 
     2227                        hooks = jQuery.attrHooks[ name ]; 
     2228 
     2229                        if ( !hooks ) { 
     2230                                // Use boolHook for boolean attributes 
     2231                                if ( rboolean.test( name ) ) { 
     2232 
     2233                                        hooks = boolHook; 
     2234 
     2235                                // Use formHook for forms and if the name contains certain characters 
     2236                                } else if ( formHook && name !== "className" && 
     2237                                        (jQuery.nodeName( elem, "form" ) || rinvalidChar.test( name )) ) { 
     2238 
     2239                                        hooks = formHook; 
     2240                                } 
     2241                        } 
     2242                } 
     2243 
     2244                if ( value !== undefined ) { 
     2245 
     2246                        if ( value === null ) { 
     2247                                jQuery.removeAttr( elem, name ); 
     2248                                return undefined; 
     2249 
     2250                        } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) { 
     2251                                return ret; 
     2252 
     2253                        } else { 
     2254                                elem.setAttribute( name, "" + value ); 
     2255                                return value; 
     2256                        } 
     2257 
     2258                } else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) { 
     2259                        return ret; 
     2260 
     2261                } else { 
     2262 
     2263                        ret = elem.getAttribute( name ); 
     2264 
     2265                        // Non-existent attributes return null, we normalize to undefined 
     2266                        return ret === null ? 
     2267                                undefined : 
     2268                                ret; 
     2269                } 
     2270        }, 
     2271 
     2272        removeAttr: function( elem, name ) { 
     2273                var propName; 
    20322274                if ( elem.nodeType === 1 ) { 
    2033                         // These attributes require special treatment 
    2034                         var special = rspecialurl.test( name ); 
    2035  
    2036                         // Safari mis-reports the default selected property of an option 
    2037                         // Accessing the parent's selectedIndex property fixes it 
    2038                         if ( name === "selected" && !jQuery.support.optSelected ) { 
    2039                                 var parent = elem.parentNode; 
    2040                                 if ( parent ) { 
    2041                                         parent.selectedIndex; 
    2042  
    2043                                         // Make sure that it also works with optgroups, see #5701 
    2044                                         if ( parent.parentNode ) { 
    2045                                                 parent.parentNode.selectedIndex; 
     2275                        name = jQuery.attrFix[ name ] || name; 
     2276                 
     2277                        if ( jQuery.support.getSetAttribute ) { 
     2278                                // Use removeAttribute in browsers that support it 
     2279                                elem.removeAttribute( name ); 
     2280                        } else { 
     2281                                jQuery.attr( elem, name, "" ); 
     2282                                elem.removeAttributeNode( elem.getAttributeNode( name ) ); 
     2283                        } 
     2284 
     2285                        // Set corresponding property to false for boolean attributes 
     2286                        if ( rboolean.test( name ) && (propName = jQuery.propFix[ name ] || name) in elem ) { 
     2287                                elem[ propName ] = false; 
     2288                        } 
     2289                } 
     2290        }, 
     2291 
     2292        attrHooks: { 
     2293                type: { 
     2294                        set: function( elem, value ) { 
     2295                                // We can't allow the type property to be changed (since it causes problems in IE) 
     2296                                if ( rtype.test( elem.nodeName ) && elem.parentNode ) { 
     2297                                        jQuery.error( "type property can't be changed" ); 
     2298                                } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) { 
     2299                                        // Setting the type on a radio button after the value resets the value in IE6-9 
     2300                                        // Reset value to it's default in case type is set after value 
     2301                                        // This is for element creation 
     2302                                        var val = elem.value; 
     2303                                        elem.setAttribute( "type", value ); 
     2304                                        if ( val ) { 
     2305                                                elem.value = val; 
    20462306                                        } 
    2047                                 } 
    2048                         } 
    2049  
    2050                         // If applicable, access the attribute via the DOM 0 way 
    2051                         // 'in' checks fail in Blackberry 4.7 #6931 
    2052                         if ( (name in elem || elem[ name ] !== undefined) && notxml && !special ) { 
    2053                                 if ( set ) { 
    2054                                         // We can't allow the type property to be changed (since it causes problems in IE) 
    2055                                         if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) { 
    2056                                                 jQuery.error( "type property can't be changed" ); 
    2057                                         } 
    2058  
    2059                                         if ( value === null ) { 
    2060                                                 if ( elem.nodeType === 1 ) { 
    2061                                                         elem.removeAttribute( name ); 
    2062                                                 } 
    2063  
    2064                                         } else { 
    2065                                                 elem[ name ] = value; 
    2066                                         } 
    2067                                 } 
    2068  
    2069                                 // browsers index elements by id/name on forms, give priority to attributes. 
    2070                                 if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) { 
    2071                                         return elem.getAttributeNode( name ).nodeValue; 
    2072                                 } 
    2073  
     2307                                        return value; 
     2308                                } 
     2309                        } 
     2310                }, 
     2311                tabIndex: { 
     2312                        get: function( elem ) { 
    20742313                                // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set 
    20752314                                // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ 
    2076                                 if ( name === "tabIndex" ) { 
    2077                                         var attributeNode = elem.getAttributeNode( "tabIndex" ); 
    2078  
    2079                                         return attributeNode && attributeNode.specified ? 
    2080                                                 attributeNode.value : 
    2081                                                 rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ? 
    2082                                                         0 : 
    2083                                                         undefined; 
    2084                                 } 
    2085  
     2315                                var attributeNode = elem.getAttributeNode("tabIndex"); 
     2316 
     2317                                return attributeNode && attributeNode.specified ? 
     2318                                        parseInt( attributeNode.value, 10 ) : 
     2319                                        rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ? 
     2320                                                0 : 
     2321                                                undefined; 
     2322                        } 
     2323                }, 
     2324                // Use the value property for back compat 
     2325                // Use the formHook for button elements in IE6/7 (#1954) 
     2326                value: { 
     2327                        get: function( elem, name ) { 
     2328                                if ( formHook && jQuery.nodeName( elem, "button" ) ) { 
     2329                                        return formHook.get( elem, name ); 
     2330                                } 
     2331                                return name in elem ? 
     2332                                        elem.value : 
     2333                                        null; 
     2334                        }, 
     2335                        set: function( elem, value, name ) { 
     2336                                if ( formHook && jQuery.nodeName( elem, "button" ) ) { 
     2337                                        return formHook.set( elem, value, name ); 
     2338                                } 
     2339                                // Does not return so that setAttribute is also used 
     2340                                elem.value = value; 
     2341                        } 
     2342                } 
     2343        }, 
     2344 
     2345        propFix: { 
     2346                tabindex: "tabIndex", 
     2347                readonly: "readOnly", 
     2348                "for": "htmlFor", 
     2349                "class": "className", 
     2350                maxlength: "maxLength", 
     2351                cellspacing: "cellSpacing", 
     2352                cellpadding: "cellPadding", 
     2353                rowspan: "rowSpan", 
     2354                colspan: "colSpan", 
     2355                usemap: "useMap", 
     2356                frameborder: "frameBorder", 
     2357                contenteditable: "contentEditable" 
     2358        }, 
     2359         
     2360        prop: function( elem, name, value ) { 
     2361                var nType = elem.nodeType; 
     2362 
     2363                // don't get/set properties on text, comment and attribute nodes 
     2364                if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { 
     2365                        return undefined; 
     2366                } 
     2367 
     2368                var ret, hooks, 
     2369                        notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); 
     2370 
     2371                if ( notxml ) { 
     2372                        // Fix name and attach hooks 
     2373                        name = jQuery.propFix[ name ] || name; 
     2374                        hooks = jQuery.propHooks[ name ]; 
     2375                } 
     2376 
     2377                if ( value !== undefined ) { 
     2378                        if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) { 
     2379                                return ret; 
     2380 
     2381                        } else { 
     2382                                return (elem[ name ] = value); 
     2383                        } 
     2384 
     2385                } else { 
     2386                        if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== undefined ) { 
     2387                                return ret; 
     2388 
     2389                        } else { 
    20862390                                return elem[ name ]; 
    20872391                        } 
    2088  
    2089                         if ( !jQuery.support.style && notxml && name === "style" ) { 
    2090                                 if ( set ) { 
    2091                                         elem.style.cssText = "" + value; 
    2092                                 } 
    2093  
    2094                                 return elem.style.cssText; 
    2095                         } 
    2096  
    2097                         if ( set ) { 
    2098                                 // convert the value to a string (all browsers do this but IE) see #1070 
    2099                                 elem.setAttribute( name, "" + value ); 
    2100                         } 
    2101  
    2102                         // Ensure that missing attributes return undefined 
    2103                         // Blackberry 4.7 returns "" from getAttribute #6938 
    2104                         if ( !elem.attributes[ name ] && (elem.hasAttribute && !elem.hasAttribute( name )) ) { 
    2105                                 return undefined; 
    2106                         } 
    2107  
    2108                         var attr = !jQuery.support.hrefNormalized && notxml && special ? 
    2109                                         // Some attributes require a special call on IE 
    2110                                         elem.getAttribute( name, 2 ) : 
    2111                                         elem.getAttribute( name ); 
    2112  
    2113                         // Non-existent attributes return null, we normalize to undefined 
    2114                         return attr === null ? undefined : attr; 
    2115                 } 
    2116                 // Handle everything which isn't a DOM element node 
    2117                 if ( set ) { 
    2118                         elem[ name ] = value; 
    2119                 } 
    2120                 return elem[ name ]; 
    2121         } 
     2392                } 
     2393        }, 
     2394         
     2395        propHooks: {} 
     2396}); 
     2397 
     2398// Hook for boolean attributes 
     2399boolHook = { 
     2400        get: function( elem, name ) { 
     2401                // Align boolean attributes with corresponding properties 
     2402                return jQuery.prop( elem, name ) ? 
     2403                        name.toLowerCase() : 
     2404                        undefined; 
     2405        }, 
     2406        set: function( elem, value, name ) { 
     2407                var propName; 
     2408                if ( value === false ) { 
     2409                        // Remove boolean attributes when set to false 
     2410                        jQuery.removeAttr( elem, name ); 
     2411                } else { 
     2412                        // value is true since we know at this point it's type boolean and not false 
     2413                        // Set boolean attributes to the same name and set the DOM property 
     2414                        propName = jQuery.propFix[ name ] || name; 
     2415                        if ( propName in elem ) { 
     2416                                // Only set the IDL specifically if it already exists on the element 
     2417                                elem[ propName ] = true; 
     2418                        } 
     2419 
     2420                        elem.setAttribute( name, name.toLowerCase() ); 
     2421                } 
     2422                return name; 
     2423        } 
     2424}; 
     2425 
     2426// IE6/7 do not support getting/setting some attributes with get/setAttribute 
     2427if ( !jQuery.support.getSetAttribute ) { 
     2428 
     2429        // propFix is more comprehensive and contains all fixes 
     2430        jQuery.attrFix = jQuery.propFix; 
     2431         
     2432        // Use this for any attribute on a form in IE6/7 
     2433        formHook = jQuery.attrHooks.name = jQuery.attrHooks.title = jQuery.valHooks.button = { 
     2434                get: function( elem, name ) { 
     2435                        var ret; 
     2436                        ret = elem.getAttributeNode( name ); 
     2437                        // Return undefined if nodeValue is empty string 
     2438                        return ret && ret.nodeValue !== "" ? 
     2439                                ret.nodeValue : 
     2440                                undefined; 
     2441                }, 
     2442                set: function( elem, value, name ) { 
     2443                        // Check form objects in IE (multiple bugs related) 
     2444                        // Only use nodeValue if the attribute node exists on the form 
     2445                        var ret = elem.getAttributeNode( name ); 
     2446                        if ( ret ) { 
     2447                                ret.nodeValue = value; 
     2448                                return value; 
     2449                        } 
     2450                } 
     2451        }; 
     2452 
     2453        // Set width and height to auto instead of 0 on empty string( Bug #8150 ) 
     2454        // This is for removals 
     2455        jQuery.each([ "width", "height" ], function( i, name ) { 
     2456                jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], { 
     2457                        set: function( elem, value ) { 
     2458                                if ( value === "" ) { 
     2459                                        elem.setAttribute( name, "auto" ); 
     2460                                        return value; 
     2461                                } 
     2462                        } 
     2463                }); 
     2464        }); 
     2465} 
     2466 
     2467 
     2468// Some attributes require a special call on IE 
     2469if ( !jQuery.support.hrefNormalized ) { 
     2470        jQuery.each([ "href", "src", "width", "height" ], function( i, name ) { 
     2471                jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], { 
     2472                        get: function( elem ) { 
     2473                                var ret = elem.getAttribute( name, 2 ); 
     2474                                return ret === null ? undefined : ret; 
     2475                        } 
     2476                }); 
     2477        }); 
     2478} 
     2479 
     2480if ( !jQuery.support.style ) { 
     2481        jQuery.attrHooks.style = { 
     2482                get: function( elem ) { 
     2483                        // Return undefined in the case of empty string 
     2484                        // Normalize to lowercase since IE uppercases css property names 
     2485                        return elem.style.cssText.toLowerCase() || undefined; 
     2486                }, 
     2487                set: function( elem, value ) { 
     2488                        return (elem.style.cssText = "" + value); 
     2489                } 
     2490        }; 
     2491} 
     2492 
     2493// Safari mis-reports the default selected property of an option 
     2494// Accessing the parent's selectedIndex property fixes it 
     2495if ( !jQuery.support.optSelected ) { 
     2496        jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, { 
     2497                get: function( elem ) { 
     2498                        var parent = elem.parentNode; 
     2499 
     2500                        if ( parent ) { 
     2501                                parent.selectedIndex; 
     2502 
     2503                                // Make sure that it also works with optgroups, see #5701 
     2504                                if ( parent.parentNode ) { 
     2505                                        parent.parentNode.selectedIndex; 
     2506                                } 
     2507                        } 
     2508                } 
     2509        }); 
     2510} 
     2511 
     2512// Radios and checkboxes getter/setter 
     2513if ( !jQuery.support.checkOn ) { 
     2514        jQuery.each([ "radio", "checkbox" ], function() { 
     2515                jQuery.valHooks[ this ] = { 
     2516                        get: function( elem ) { 
     2517                                // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified 
     2518                                return elem.getAttribute("value") === null ? "on" : elem.value; 
     2519                        } 
     2520                }; 
     2521        }); 
     2522} 
     2523jQuery.each([ "radio", "checkbox" ], function() { 
     2524        jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], { 
     2525                set: function( elem, value ) { 
     2526                        if ( jQuery.isArray( value ) ) { 
     2527                                return (elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0); 
     2528                        } 
     2529                } 
     2530        }); 
    21222531}); 
    21232532 
     
    21282537        rformElems = /^(?:textarea|input|select)$/i, 
    21292538        rperiod = /\./g, 
    2130         rspace = / /g, 
     2539        rspaces = / /g, 
    21312540        rescape = /[^\w\s.|`]/g, 
    21322541        fcleanup = function( nm ) { 
     
    21482557                } 
    21492558 
    2150                 // TODO :: Use a try/catch until it's safe to pull this out (likely 1.6) 
    2151                 // Minor release fix for bug #8018 
    2152                 try { 
    2153                         // For whatever reason, IE has trouble passing the window object 
    2154                         // around, causing it to be cloned in the process 
    2155                         if ( jQuery.isWindow( elem ) && ( elem !== window && !elem.frameElement ) ) { 
    2156                                 elem = window; 
    2157                         } 
    2158                 } 
    2159                 catch ( e ) {} 
    2160  
    21612559                if ( handler === false ) { 
    21622560                        handler = returnFalse; 
     
    21952593 
    21962594                if ( !eventHandle ) { 
    2197                         elemData.handle = eventHandle = function() { 
    2198                                 // Handle the second event of a trigger and when 
    2199                                 // an event is called after a page has unloaded 
    2200                                 return typeof jQuery !== "undefined" && !jQuery.event.triggered ? 
     2595                        elemData.handle = eventHandle = function( e ) { 
     2596                                // Discard the second event of a jQuery.event.trigger() and 
     2597                                // when an event is called after a page has unloaded 
     2598                                return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ? 
    22012599                                        jQuery.event.handle.apply( eventHandle.elem, arguments ) : 
    22022600                                        undefined; 
     
    22682666                        handlers.push( handleObj ); 
    22692667 
    2270                         // Keep track of which events have been used, for global triggering 
     2668                        // Keep track of which events have been used, for event optimization 
    22712669                        jQuery.event.global[ type ] = true; 
    22722670                } 
     
    24012799                } 
    24022800        }, 
    2403  
    2404         // bubbling is internal 
    2405         trigger: function( event, data, elem /*, bubbling */ ) { 
     2801         
     2802        // Events that are safe to short-circuit if no handlers are attached. 
     2803        // Native DOM events should not be added, they may have inline handlers. 
     2804        customEvent: { 
     2805                "getData": true, 
     2806                "setData": true, 
     2807                "changeData": true 
     2808        }, 
     2809 
     2810        trigger: function( event, data, elem, onlyHandlers ) { 
    24062811                // Event object or event type 
    24072812                var type = event.type || event, 
    2408                         bubbling = arguments[3]; 
    2409  
    2410                 if ( !bubbling ) { 
    2411                         event = typeof event === "object" ? 
    2412                                 // jQuery.Event object 
    2413                                 event[ jQuery.expando ] ? event : 
    2414                                 // Object literal 
    2415                                 jQuery.extend( jQuery.Event(type), event ) : 
    2416                                 // Just the event type (string) 
    2417                                 jQuery.Event(type); 
    2418  
    2419                         if ( type.indexOf("!") >= 0 ) { 
    2420                                 event.type = type = type.slice(0, -1); 
    2421                                 event.exclusive = true; 
    2422                         } 
    2423  
    2424                         // Handle a global trigger 
    2425                         if ( !elem ) { 
    2426                                 // Don't bubble custom events when global (to avoid too much overhead) 
    2427                                 event.stopPropagation(); 
    2428  
    2429                                 // Only trigger if we've ever bound an event for it 
    2430                                 if ( jQuery.event.global[ type ] ) { 
    2431                                         // XXX This code smells terrible. event.js should not be directly 
    2432                                         // inspecting the data cache 
    2433                                         jQuery.each( jQuery.cache, function() { 
    2434                                                 // internalKey variable is just used to make it easier to find 
    2435                                                 // and potentially change this stuff later; currently it just 
    2436                                                 // points to jQuery.expando 
    2437                                                 var internalKey = jQuery.expando, 
    2438                                                         internalCache = this[ internalKey ]; 
    2439                                                 if ( internalCache && internalCache.events && internalCache.events[ type ] ) { 
    2440                                                         jQuery.event.trigger( event, data, internalCache.handle.elem ); 
     2813                        namespaces = [], 
     2814                        exclusive; 
     2815 
     2816                if ( type.indexOf("!") >= 0 ) { 
     2817                        // Exclusive events trigger only for the exact event (no namespaces) 
     2818                        type = type.slice(0, -1); 
     2819                        exclusive = true; 
     2820                } 
     2821 
     2822                if ( type.indexOf(".") >= 0 ) { 
     2823                        // Namespaced trigger; create a regexp to match event type in handle() 
     2824                        namespaces = type.split("."); 
     2825                        type = namespaces.shift(); 
     2826                        namespaces.sort(); 
     2827                } 
     2828 
     2829                if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) { 
     2830                        // No jQuery handlers for this event type, and it can't have inline handlers 
     2831                        return; 
     2832                } 
     2833 
     2834                // Caller can pass in an Event, Object, or just an event type string 
     2835                event = typeof event === "object" ? 
     2836                        // jQuery.Event object 
     2837                        event[ jQuery.expando ] ? event : 
     2838                        // Object literal 
     2839                        new jQuery.Event( type, event ) : 
     2840                        // Just the event type (string) 
     2841                        new jQuery.Event( type ); 
     2842 
     2843                event.type = type; 
     2844                event.exclusive = exclusive; 
     2845                event.namespace = namespaces.join("."); 
     2846                event.namespace_re = new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)"); 
     2847                 
     2848                // triggerHandler() and global events don't bubble or run the default action 
     2849                if ( onlyHandlers || !elem ) { 
     2850                        event.preventDefault(); 
     2851                        event.stopPropagation(); 
     2852                } 
     2853 
     2854                // Handle a global trigger 
     2855                if ( !elem ) { 
     2856                        // TODO: Stop taunting the data cache; remove global events and always attach to document 
     2857                        jQuery.each( jQuery.cache, function() { 
     2858                                // internalKey variable is just used to make it easier to find 
     2859                                // and potentially change this stuff later; currently it just 
     2860                                // points to jQuery.expando 
     2861                                var internalKey = jQuery.expando, 
     2862                                        internalCache = this[ internalKey ]; 
     2863                                if ( internalCache && internalCache.events && internalCache.events[ type ] ) { 
     2864                                        jQuery.event.trigger( event, data, internalCache.handle.elem ); 
     2865                                } 
     2866                        }); 
     2867                        return; 
     2868                } 
     2869 
     2870                // Don't do events on text and comment nodes 
     2871                if ( elem.nodeType === 3 || elem.nodeType === 8 ) { 
     2872                        return; 
     2873                } 
     2874 
     2875                // Clean up the event in case it is being reused 
     2876                event.result = undefined; 
     2877                event.target = elem; 
     2878 
     2879                // Clone any incoming data and prepend the event, creating the handler arg list 
     2880                data = data != null ? jQuery.makeArray( data ) : []; 
     2881                data.unshift( event ); 
     2882 
     2883                var cur = elem, 
     2884                        // IE doesn't like method names with a colon (#3533, #8272) 
     2885                        ontype = type.indexOf(":") < 0 ? "on" + type : ""; 
     2886 
     2887                // Fire event on the current element, then bubble up the DOM tree 
     2888                do { 
     2889                        var handle = jQuery._data( cur, "handle" ); 
     2890 
     2891                        event.currentTarget = cur; 
     2892                        if ( handle ) { 
     2893                                handle.apply( cur, data ); 
     2894                        } 
     2895 
     2896                        // Trigger an inline bound script 
     2897                        if ( ontype && jQuery.acceptData( cur ) && cur[ ontype ] && cur[ ontype ].apply( cur, data ) === false ) { 
     2898                                event.result = false; 
     2899                                event.preventDefault(); 
     2900                        } 
     2901 
     2902                        // Bubble up to document, then to window 
     2903                        cur = cur.parentNode || cur.ownerDocument || cur === event.target.ownerDocument && window; 
     2904                } while ( cur && !event.isPropagationStopped() ); 
     2905 
     2906                // If nobody prevented the default action, do it now 
     2907                if ( !event.isDefaultPrevented() ) { 
     2908                        var old, 
     2909                                special = jQuery.event.special[ type ] || {}; 
     2910 
     2911                        if ( (!special._default || special._default.call( elem.ownerDocument, event ) === false) && 
     2912                                !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) { 
     2913 
     2914                                // Call a native DOM method on the target with the same name name as the event. 
     2915                                // Can't use an .isFunction)() check here because IE6/7 fails that test. 
     2916                                // IE<9 dies on focus to hidden element (#1486), may want to revisit a try/catch. 
     2917                                try { 
     2918                                        if ( ontype && elem[ type ] ) { 
     2919                                                // Don't re-trigger an onFOO event when we call its FOO() method 
     2920                                                old = elem[ ontype ]; 
     2921 
     2922                                                if ( old ) { 
     2923                                                        elem[ ontype ] = null; 
    24412924                                                } 
    2442                                         }); 
    2443                                 } 
    2444                         } 
    2445  
    2446                         // Handle triggering a single element 
    2447  
    2448                         // don't do events on text and comment nodes 
    2449                         if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) { 
    2450                                 return undefined; 
    2451                         } 
    2452  
    2453                         // Clean up in case it is reused 
    2454                         event.result = undefined; 
    2455                         event.target = elem; 
    2456  
    2457                         // Clone the incoming data, if any 
    2458                         data = jQuery.makeArray( data ); 
    2459                         data.unshift( event ); 
    2460                 } 
    2461  
    2462                 event.currentTarget = elem; 
    2463  
    2464                 // Trigger the event, it is assumed that "handle" is a function 
    2465                 var handle = jQuery._data( elem, "handle" ); 
    2466  
    2467                 if ( handle ) { 
    2468                         handle.apply( elem, data ); 
    2469                 } 
    2470  
    2471                 var parent = elem.parentNode || elem.ownerDocument; 
    2472  
    2473                 // Trigger an inline bound script 
    2474                 try { 
    2475                         if ( !(elem && elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()]) ) { 
    2476                                 if ( elem[ "on" + type ] && elem[ "on" + type ].apply( elem, data ) === false ) { 
    2477                                         event.result = false; 
    2478                                         event.preventDefault(); 
    2479                                 } 
    2480                         } 
    2481  
    2482                 // prevent IE from throwing an error for some elements with some event types, see #3533 
    2483                 } catch (inlineError) {} 
    2484  
    2485                 if ( !event.isPropagationStopped() && parent ) { 
    2486                         jQuery.event.trigger( event, data, parent, true ); 
    2487  
    2488                 } else if ( !event.isDefaultPrevented() ) { 
    2489                         var old, 
    2490                                 target = event.target, 
    2491                                 targetType = type.replace( rnamespaces, "" ), 
    2492                                 isClick = jQuery.nodeName( target, "a" ) && targetType === "click", 
    2493                                 special = jQuery.event.special[ targetType ] || {}; 
    2494  
    2495                         if ( (!special._default || special._default.call( elem, event ) === false) && 
    2496                                 !isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) { 
    2497  
    2498                                 try { 
    2499                                         if ( target[ targetType ] ) { 
    2500                                                 // Make sure that we don't accidentally re-trigger the onFOO events 
    2501                                                 old = target[ "on" + targetType ]; 
    2502  
    2503                                                 if ( old ) { 
    2504                                                         target[ "on" + targetType ] = null; 
    2505                                                 } 
    2506  
    2507                                                 jQuery.event.triggered = true; 
    2508                                                 target[ targetType ](); 
     2925 
     2926                                                jQuery.event.triggered = type; 
     2927                                                elem[ type ](); 
    25092928                                        } 
    2510  
    2511                                 // prevent IE from throwing an error for some elements with some event types, see #3533 
    2512                                 } catch (triggerError) {} 
     2929                                } catch ( ieError ) {} 
    25132930 
    25142931                                if ( old ) { 
    2515                                         target[ "on" + targetType ] = old; 
    2516                                 } 
    2517  
    2518                                 jQuery.event.triggered = false; 
    2519                         } 
    2520                 } 
     2932                                        elem[ ontype ] = old; 
     2933                                } 
     2934 
     2935                                jQuery.event.triggered = undefined; 
     2936                        } 
     2937                } 
     2938                 
     2939                return event.result; 
    25212940        }, 
    25222941 
    25232942        handle: function( event ) { 
    2524                 var all, handlers, namespaces, namespace_re, events, 
    2525                         namespace_sort = [], 
    2526                         args = jQuery.makeArray( arguments ); 
    2527  
    2528                 event = args[0] = jQuery.event.fix( event || window.event ); 
     2943                event = jQuery.event.fix( event || window.event ); 
     2944                // Snapshot the handlers list since a called handler may add/remove events. 
     2945                var handlers = ((jQuery._data( this, "events" ) || {})[ event.type ] || []).slice(0), 
     2946                        run_all = !event.exclusive && !event.namespace, 
     2947                        args = Array.prototype.slice.call( arguments, 0 ); 
     2948 
     2949                // Use the fix-ed Event rather than the (read-only) native event 
     2950                args[0] = event; 
    25292951                event.currentTarget = this; 
    25302952 
    2531                 // Namespaced event handlers 
    2532                 all = event.type.indexOf(".") < 0 && !event.exclusive; 
    2533  
    2534                 if ( !all ) { 
    2535                         namespaces = event.type.split("."); 
    2536                         event.type = namespaces.shift(); 
    2537                         namespace_sort = namespaces.slice(0).sort(); 
    2538                         namespace_re = new RegExp("(^|\\.)" + namespace_sort.join("\\.(?:.*\\.)?") + "(\\.|$)"); 
    2539                 } 
    2540  
    2541                 event.namespace = event.namespace || namespace_sort.join("."); 
    2542  
    2543                 events = jQuery._data(this, "events"); 
    2544  
    2545                 handlers = (events || {})[ event.type ]; 
    2546  
    2547                 if ( events && handlers ) { 
    2548                         // Clone the handlers to prevent manipulation 
    2549                         handlers = handlers.slice(0); 
    2550  
    2551                         for ( var j = 0, l = handlers.length; j < l; j++ ) { 
    2552                                 var handleObj = handlers[ j ]; 
    2553  
    2554                                 // Filter the functions by class 
    2555                                 if ( all || namespace_re.test( handleObj.namespace ) ) { 
    2556                                         // Pass in a reference to the handler function itself 
    2557                                         // So that we can later remove it 
    2558                                         event.handler = handleObj.handler; 
    2559                                         event.data = handleObj.data; 
    2560                                         event.handleObj = handleObj; 
    2561  
    2562                                         var ret = handleObj.handler.apply( this, args ); 
    2563  
    2564                                         if ( ret !== undefined ) { 
    2565                                                 event.result = ret; 
    2566                                                 if ( ret === false ) { 
    2567                                                         event.preventDefault(); 
    2568                                                         event.stopPropagation(); 
    2569                                                 } 
     2953                for ( var j = 0, l = handlers.length; j < l; j++ ) { 
     2954                        var handleObj = handlers[ j ]; 
     2955 
     2956                        // Triggered event must 1) be non-exclusive and have no namespace, or 
     2957                        // 2) have namespace(s) a subset or equal to those in the bound event. 
     2958                        if ( run_all || event.namespace_re.test( handleObj.namespace ) ) { 
     2959                                // Pass in a reference to the handler function itself 
     2960                                // So that we can later remove it 
     2961                                event.handler = handleObj.handler; 
     2962                                event.data = handleObj.data; 
     2963                                event.handleObj = handleObj; 
     2964 
     2965                                var ret = handleObj.handler.apply( this, args ); 
     2966 
     2967                                if ( ret !== undefined ) { 
     2968                                        event.result = ret; 
     2969                                        if ( ret === false ) { 
     2970                                                event.preventDefault(); 
     2971                                                event.stopPropagation(); 
    25702972                                        } 
    2571  
    2572                                         if ( event.isImmediatePropagationStopped() ) { 
    2573                                                 break; 
    2574                                         } 
    2575                                 } 
    2576                         } 
    2577                 } 
    2578  
     2973                                } 
     2974 
     2975                                if ( event.isImmediatePropagationStopped() ) { 
     2976                                        break; 
     2977                                } 
     2978                        } 
     2979                } 
    25792980                return event.result; 
    25802981        }, 
     
    26153016                // Calculate pageX/Y if missing and clientX/Y available 
    26163017                if ( event.pageX == null && event.clientX != null ) { 
    2617                         var doc = document.documentElement, 
    2618                                 body = document.body; 
     3018                        var eventDocument = event.target.ownerDocument || document, 
     3019                                doc = eventDocument.documentElement, 
     3020                                body = eventDocument.body; 
    26193021 
    26203022                        event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0); 
     
    26953097        }; 
    26963098 
    2697 jQuery.Event = function( src ) { 
     3099jQuery.Event = function( src, props ) { 
    26983100        // Allow instantiation without the 'new' keyword 
    26993101        if ( !this.preventDefault ) { 
    2700                 return new jQuery.Event( src ); 
     3102                return new jQuery.Event( src, props ); 
    27013103        } 
    27023104 
     
    27143116        } else { 
    27153117                this.type = src; 
     3118        } 
     3119 
     3120        // Put explicitly provided properties onto the event object 
     3121        if ( props ) { 
     3122                jQuery.extend( this, props ); 
    27163123        } 
    27173124 
     
    27773184// Used in jQuery.event.special.mouseenter and mouseleave handlers 
    27783185var withinElement = function( event ) { 
     3186 
    27793187        // Check if mouse(over|out) are still within the same parent element 
    2780         var parent = event.relatedTarget; 
    2781  
    2782         // Firefox sometimes assigns relatedTarget a XUL element 
    2783         // which we cannot access the parentNode property of 
    2784         try { 
    2785  
    2786                 // Chrome does something similar, the parentNode property 
    2787                 // can be accessed but is null. 
    2788                 if ( parent !== document && !parent.parentNode ) { 
    2789                         return; 
    2790                 } 
    2791                 // Traverse up the tree 
    2792                 while ( parent && parent !== this ) { 
    2793                         parent = parent.parentNode; 
    2794                 } 
    2795  
    2796                 if ( parent !== this ) { 
    2797                         // set the correct event type 
    2798                         event.type = event.data; 
    2799  
    2800                         // handle event if we actually just moused on to a non sub-element 
     3188        var related = event.relatedTarget, 
     3189                inside = false, 
     3190                eventType = event.type; 
     3191 
     3192        event.type = event.data; 
     3193 
     3194        if ( related !== this ) { 
     3195 
     3196                if ( related ) { 
     3197                        inside = jQuery.contains( this, related ); 
     3198                } 
     3199 
     3200                if ( !inside ) { 
     3201 
    28013202                        jQuery.event.handle.apply( this, arguments ); 
    2802                 } 
    2803  
    2804         // assuming we've left the element since we most likely mousedover a xul element 
    2805         } catch(e) { } 
     3203 
     3204                        event.type = eventType; 
     3205                } 
     3206        } 
    28063207}, 
    28073208 
     
    28333234        jQuery.event.special.submit = { 
    28343235                setup: function( data, namespaces ) { 
    2835                         if ( this.nodeName && this.nodeName.toLowerCase() !== "form" ) { 
     3236                        if ( !jQuery.nodeName( this, "form" ) ) { 
    28363237                                jQuery.event.add(this, "click.specialSubmit", function( e ) { 
    28373238                                        var elem = e.target, 
     
    28823283                                ""; 
    28833284 
    2884                 } else if ( elem.nodeName.toLowerCase() === "select" ) { 
     3285                } else if ( jQuery.nodeName( elem, "select" ) ) { 
    28853286                        val = elem.selectedIndex; 
    28863287                } 
     
    29223323 
    29233324                        click: function( e ) { 
    2924                                 var elem = e.target, type = elem.type; 
    2925  
    2926                                 if ( type === "radio" || type === "checkbox" || elem.nodeName.toLowerCase() === "select" ) { 
     3325                                var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : ""; 
     3326 
     3327                                if ( type === "radio" || type === "checkbox" || jQuery.nodeName( elem, "select" ) ) { 
    29273328                                        testChange.call( this, e ); 
    29283329                                } 
     
    29323333                        // Keydown will be called before keypress, which is used in submit-event delegation 
    29333334                        keydown: function( e ) { 
    2934                                 var elem = e.target, type = elem.type; 
    2935  
    2936                                 if ( (e.keyCode === 13 && elem.nodeName.toLowerCase() !== "textarea") || 
     3335                                var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : ""; 
     3336 
     3337                                if ( (e.keyCode === 13 && !jQuery.nodeName( elem, "textarea" ) ) || 
    29373338                                        (e.keyCode === 32 && (type === "checkbox" || type === "radio")) || 
    29383339                                        type === "select-multiple" ) { 
     
    29913392 
    29923393// Create "bubbling" focus and blur events 
    2993 if ( document.addEventListener ) { 
     3394if ( !jQuery.support.focusinBubbles ) { 
    29943395        jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) { 
     3396 
     3397                // Attach a single capturing handler while someone wants focusin/focusout 
     3398                var attaches = 0; 
     3399 
    29953400                jQuery.event.special[ fix ] = { 
    29963401                        setup: function() { 
    2997                                 this.addEventListener( orig, handler, true ); 
     3402                                if ( attaches++ === 0 ) { 
     3403                                        document.addEventListener( orig, handler, true ); 
     3404                                } 
    29983405                        }, 
    29993406                        teardown: function() { 
    3000                                 this.removeEventListener( orig, handler, true ); 
     3407                                if ( --attaches === 0 ) { 
     3408                                        document.removeEventListener( orig, handler, true ); 
     3409                                } 
    30013410                        } 
    30023411                }; 
    30033412 
    3004                 function handler( e ) { 
    3005                         e = jQuery.event.fix( e ); 
     3413                function handler( donor ) { 
     3414                        // Donor event is always a native one; fix it and switch its type. 
     3415                        // Let focusin/out handler cancel the donor focus/blur event. 
     3416                        var e = jQuery.event.fix( donor ); 
    30063417                        e.type = fix; 
    3007                         return jQuery.event.handle.call( this, e ); 
     3418                        e.originalEvent = {}; 
     3419                        jQuery.event.trigger( e, null, e.target ); 
     3420                        if ( e.isDefaultPrevented() ) { 
     3421                                donor.preventDefault(); 
     3422                        } 
    30083423                } 
    30093424        }); 
     
    30123427jQuery.each(["bind", "one"], function( i, name ) { 
    30133428        jQuery.fn[ name ] = function( type, data, fn ) { 
     3429                var handler; 
     3430 
    30143431                // Handle object literals 
    30153432                if ( typeof type === "object" ) { 
     
    30203437                } 
    30213438 
    3022                 if ( jQuery.isFunction( data ) || data === false ) { 
     3439                if ( arguments.length === 2 || data === false ) { 
    30233440                        fn = data; 
    30243441                        data = undefined; 
    30253442                } 
    30263443 
    3027                 var handler = name === "one" ? jQuery.proxy( fn, function( event ) { 
    3028                         jQuery( this ).unbind( event, handler ); 
    3029                         return fn.apply( this, arguments ); 
    3030                 }) : fn; 
     3444                if ( name === "one" ) { 
     3445                        handler = function( event ) { 
     3446                                jQuery( this ).unbind( event, handler ); 
     3447                                return fn.apply( this, arguments ); 
     3448                        }; 
     3449                        handler.guid = fn.guid || jQuery.guid++; 
     3450                } else { 
     3451                        handler = fn; 
     3452                } 
    30313453 
    30323454                if ( type === "unload" && name !== "one" ) { 
     
    30663488        undelegate: function( selector, types, fn ) { 
    30673489                if ( arguments.length === 0 ) { 
    3068                                 return this.unbind( "live" ); 
     3490                        return this.unbind( "live" ); 
    30693491 
    30703492                } else { 
     
    30813503        triggerHandler: function( type, data ) { 
    30823504                if ( this[0] ) { 
    3083                         var event = jQuery.Event( type ); 
    3084                         event.preventDefault(); 
    3085                         event.stopPropagation(); 
    3086                         jQuery.event.trigger( event, data, this[0] ); 
    3087                         return event.result; 
     3505                        return jQuery.event.trigger( type, data, this[0], true ); 
    30883506                } 
    30893507        }, 
     
    30923510                // Save reference to arguments for access in closure 
    30933511                var args = arguments, 
    3094                         i = 1; 
     3512                        guid = fn.guid || jQuery.guid++, 
     3513                        i = 0, 
     3514                        toggler = function( event ) { 
     3515                                // Figure out which function to execute 
     3516                                var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i; 
     3517                                jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 ); 
     3518 
     3519                                // Make sure that clicks stop 
     3520                                event.preventDefault(); 
     3521 
     3522                                // and execute the function 
     3523                                return args[ lastToggle ].apply( this, arguments ) || false; 
     3524                        }; 
    30953525 
    30963526                // link all the functions, so any of them can unbind this click handler 
     3527                toggler.guid = guid; 
    30973528                while ( i < args.length ) { 
    3098                         jQuery.proxy( fn, args[ i++ ] ); 
    3099                 } 
    3100  
    3101                 return this.click( jQuery.proxy( fn, function( event ) { 
    3102                         // Figure out which function to execute 
    3103                         var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i; 
    3104                         jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 ); 
    3105  
    3106                         // Make sure that clicks stop 
    3107                         event.preventDefault(); 
    3108  
    3109                         // and execute the function 
    3110                         return args[ lastToggle ].apply( this, arguments ) || false; 
    3111                 })); 
     3529                        args[ i++ ].guid = guid; 
     3530                } 
     3531 
     3532                return this.click( toggler ); 
    31123533        }, 
    31133534 
     
    31383559                } 
    31393560 
    3140                 if ( jQuery.isFunction( data ) ) { 
    3141                         fn = data; 
     3561                if ( name === "die" && !types && 
     3562                                        origSelector && origSelector.charAt(0) === "." ) { 
     3563 
     3564                        context.unbind( origSelector ); 
     3565 
     3566                        return this; 
     3567                } 
     3568 
     3569                if ( data === false || jQuery.isFunction( data ) ) { 
     3570                        fn = data || returnFalse; 
    31423571                        data = undefined; 
    31433572                } 
     
    31613590                        preType = type; 
    31623591 
    3163                         if ( type === "focus" || type === "blur" ) { 
     3592                        if ( liveMap[ type ] ) { 
    31643593                                types.push( liveMap[ type ] + namespaces ); 
    31653594                                type = type + namespaces; 
     
    32323661                                        event.type = handleObj.preType; 
    32333662                                        related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0]; 
     3663 
     3664                                        // Make sure not to accidentally match a child element with the same selector 
     3665                                        if ( related && jQuery.contains( elem, related ) ) { 
     3666                                                related = elem; 
     3667                                        } 
    32343668                                } 
    32353669 
     
    32703704 
    32713705function liveConvert( type, selector ) { 
    3272         return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspace, "&"); 
     3706        return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspaces, "&"); 
    32733707} 
    32743708 
     
    32933727        } 
    32943728}); 
     3729 
    32953730 
    32963731 
     
    39194354 
    39204355                text: function( elem ) { 
     4356                        var attr = elem.getAttribute( "type" ), type = elem.type; 
    39214357                        // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)  
    39224358                        // use getAttribute instead to test this case 
    3923                         return "text" === elem.getAttribute( 'type' ); 
     4359                        return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null ); 
    39244360                }, 
     4361 
    39254362                radio: function( elem ) { 
    3926                         return "radio" === elem.type; 
     4363                        return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type; 
    39274364                }, 
    39284365 
    39294366                checkbox: function( elem ) { 
    3930                         return "checkbox" === elem.type; 
     4367                        return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type; 
    39314368                }, 
    39324369 
    39334370                file: function( elem ) { 
    3934                         return "file" === elem.type; 
     4371                        return elem.nodeName.toLowerCase() === "input" && "file" === elem.type; 
    39354372                }, 
     4373 
    39364374                password: function( elem ) { 
    3937                         return "password" === elem.type; 
     4375                        return elem.nodeName.toLowerCase() === "input" && "password" === elem.type; 
    39384376                }, 
    39394377 
    39404378                submit: function( elem ) { 
    3941                         return "submit" === elem.type; 
     4379                        var name = elem.nodeName.toLowerCase(); 
     4380                        return (name === "input" || name === "button") && "submit" === elem.type; 
    39424381                }, 
    39434382 
    39444383                image: function( elem ) { 
    3945                         return "image" === elem.type; 
     4384                        return elem.nodeName.toLowerCase() === "input" && "image" === elem.type; 
    39464385                }, 
    39474386 
    39484387                reset: function( elem ) { 
    3949                         return "reset" === elem.type; 
     4388                        var name = elem.nodeName.toLowerCase(); 
     4389                        return (name === "input" || name === "button") && "reset" === elem.type; 
    39504390                }, 
    39514391 
    39524392                button: function( elem ) { 
    3953                         return "button" === elem.type || elem.nodeName.toLowerCase() === "button"; 
     4393                        var name = elem.nodeName.toLowerCase(); 
     4394                        return name === "input" && "button" === elem.type || name === "button"; 
    39544395                }, 
    39554396 
    39564397                input: function( elem ) { 
    39574398                        return (/input|select|textarea|button/i).test( elem.nodeName ); 
     4399                }, 
     4400 
     4401                focus: function( elem ) { 
     4402                        return elem === elem.ownerDocument.activeElement; 
    39584403                } 
    39594404        }, 
     
    42084653} else { 
    42094654        sortOrder = function( a, b ) { 
     4655                // The nodes are identical, we can exit early 
     4656                if ( a === b ) { 
     4657                        hasDuplicate = true; 
     4658                        return 0; 
     4659 
     4660                // Fallback to using sourceIndex (in IE) if it's available on both nodes 
     4661                } else if ( a.sourceIndex && b.sourceIndex ) { 
     4662                        return a.sourceIndex - b.sourceIndex; 
     4663                } 
     4664 
    42104665                var al, bl, 
    42114666                        ap = [], 
     
    42154670                        cur = aup; 
    42164671 
    4217                 // The nodes are identical, we can exit early 
    4218                 if ( a === b ) { 
    4219                         hasDuplicate = true; 
    4220                         return 0; 
    4221  
    42224672                // If the nodes are siblings (or identical) we can do a quick check 
    4223                 } else if ( aup === bup ) { 
     4673                if ( aup === bup ) { 
    42244674                        return siblingCheck( a, b ); 
    42254675 
     
    44974947(function(){ 
    44984948        var html = document.documentElement, 
    4499                 matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector, 
    4500                 pseudoWorks = false; 
    4501  
    4502         try { 
    4503                 // This should fail with an exception 
    4504                 // Gecko does not error, returns false instead 
    4505                 matches.call( document.documentElement, "[test!='']:sizzle" ); 
     4949                matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector; 
     4950 
     4951        if ( matches ) { 
     4952                // Check to see if it's possible to do matchesSelector 
     4953                // on a disconnected node (IE 9 fails this) 
     4954                var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ), 
     4955                        pseudoWorks = false; 
     4956 
     4957                try { 
     4958                        // This should fail with an exception 
     4959                        // Gecko does not error, returns false instead 
     4960                        matches.call( document.documentElement, "[test!='']:sizzle" ); 
    45064961         
    4507         } catch( pseudoError ) { 
    4508                 pseudoWorks = true; 
    4509         } 
    4510  
    4511         if ( matches ) { 
     4962                } catch( pseudoError ) { 
     4963                        pseudoWorks = true; 
     4964                } 
     4965 
    45124966                Sizzle.matchesSelector = function( node, expr ) { 
    45134967                        // Make sure that attribute selectors are quoted 
     
    45174971                                try {  
    45184972                                        if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) { 
    4519                                                 return matches.call( node, expr ); 
     4973                                                var ret = matches.call( node, expr ); 
     4974 
     4975                                                // IE 9's matchesSelector returns false on disconnected nodes 
     4976                                                if ( ret || !disconnectedMatch || 
     4977                                                                // As well, disconnected nodes are said to be in a document 
     4978                                                                // fragment in IE 9, so check for that 
     4979                                                                node.document && node.document.nodeType !== 11 ) { 
     4980                                                        return ret; 
     4981                                                } 
    45204982                                        } 
    45214983                                } catch(e) {} 
     
    47065168jQuery.fn.extend({ 
    47075169        find: function( selector ) { 
     5170                var self = this, 
     5171                        i, l; 
     5172 
     5173                if ( typeof selector !== "string" ) { 
     5174                        return jQuery( selector ).filter(function() { 
     5175                                for ( i = 0, l = self.length; i < l; i++ ) { 
     5176                                        if ( jQuery.contains( self[ i ], this ) ) { 
     5177                                                return true; 
     5178                                        } 
     5179                                } 
     5180                        }); 
     5181                } 
     5182 
    47085183                var ret = this.pushStack( "", "find", selector ), 
    4709                         length = 0; 
    4710  
    4711                 for ( var i = 0, l = this.length; i < l; i++ ) { 
     5184                        length, n, r; 
     5185 
     5186                for ( i = 0, l = this.length; i < l; i++ ) { 
    47125187                        length = ret.length; 
    47135188                        jQuery.find( selector, this[i], ret ); 
     
    47155190                        if ( i > 0 ) { 
    47165191                                // Make sure that the results are unique 
    4717                                 for ( var n = length; n < ret.length; n++ ) { 
    4718                                         for ( var r = 0; r < length; r++ ) { 
     5192                                for ( n = length; n < ret.length; n++ ) { 
     5193                                        for ( r = 0; r < length; r++ ) { 
    47195194                                                if ( ret[r] === ret[n] ) { 
    47205195                                                        ret.splice(n--, 1); 
     
    47495224 
    47505225        is: function( selector ) { 
    4751                 return !!selector && jQuery.filter( selector, this ).length > 0; 
     5226                return !!selector && ( typeof selector === "string" ? 
     5227                        jQuery.filter( selector, this ).length > 0 : 
     5228                        this.filter( selector ).length > 0 ); 
    47525229        }, 
    47535230 
    47545231        closest: function( selectors, context ) { 
    47555232                var ret = [], i, l, cur = this[0]; 
    4756  
     5233                 
     5234                // Array 
    47575235                if ( jQuery.isArray( selectors ) ) { 
    47585236                        var match, selector, 
     
    47645242                                        selector = selectors[i]; 
    47655243 
    4766                                         if ( !matches[selector] ) { 
    4767                                                 matches[selector] = jQuery.expr.match.POS.test( selector ) ? 
     5244                                        if ( !matches[ selector ] ) { 
     5245                                                matches[ selector ] = POS.test( selector ) ? 
    47685246                                                        jQuery( selector, context || this.context ) : 
    47695247                                                        selector; 
     
    47735251                                while ( cur && cur.ownerDocument && cur !== context ) { 
    47745252                                        for ( selector in matches ) { 
    4775                                                 match = matches[selector]; 
    4776  
    4777                                                 if ( match.jquery ? match.index(cur) > -1 : jQuery(cur).is(match) ) { 
     5253                                                match = matches[ selector ]; 
     5254 
     5255                                                if ( match.jquery ? match.index( cur ) > -1 : jQuery( cur ).is( match ) ) { 
    47785256                                                        ret.push({ selector: selector, elem: cur, level: level }); 
    47795257                                                } 
     
    47885266                } 
    47895267 
    4790                 var pos = POS.test( selectors ) ? 
    4791                         jQuery( selectors, context || this.context ) : null; 
     5268                // String 
     5269                var pos = POS.test( selectors ) || typeof selectors !== "string" ? 
     5270                                jQuery( selectors, context || this.context ) : 
     5271                                0; 
    47925272 
    47935273                for ( i = 0, l = this.length; i < l; i++ ) { 
     
    48015281                                } else { 
    48025282                                        cur = cur.parentNode; 
    4803                                         if ( !cur || !cur.ownerDocument || cur === context ) { 
     5283                                        if ( !cur || !cur.ownerDocument || cur === context || cur.nodeType === 11 ) { 
    48045284                                                break; 
    48055285                                        } 
     
    48085288                } 
    48095289 
    4810                 ret = ret.length > 1 ? jQuery.unique(ret) : ret; 
     5290                ret = ret.length > 1 ? jQuery.unique( ret ) : ret; 
    48115291 
    48125292                return this.pushStack( ret, "closest", selectors ); 
     
    48315311                var set = typeof selector === "string" ? 
    48325312                                jQuery( selector, context ) : 
    4833                                 jQuery.makeArray( selector ), 
     5313                                jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ), 
    48345314                        all = jQuery.merge( this.get(), set ); 
    48355315 
     
    49695449// Implement the identical functionality for filter and not 
    49705450function winnow( elements, qualifier, keep ) { 
     5451 
     5452        // Can't pass null or undefined to indexOf in Firefox 4 
     5453        // Set to 0 to skip string check 
     5454        qualifier = qualifier || 0; 
     5455 
    49715456        if ( jQuery.isFunction( qualifier ) ) { 
    49725457                return jQuery.grep(elements, function( elem, i ) { 
     
    50095494        // checked="checked" or checked 
    50105495        rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, 
     5496        rscriptType = /\/(java|ecma)script/i, 
     5497        rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)/, 
    50115498        wrapMap = { 
    50125499                option: [ 1, "<select multiple='multiple'>", "</select>" ], 
     
    50695556 
    50705557                                return elem; 
    5071                         }).append(this); 
     5558                        }).append( this ); 
    50725559                } 
    50735560 
     
    52615748                        }); 
    52625749                } else { 
    5263                         return this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ); 
     5750                        return this.length ? 
     5751                                this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) : 
     5752                                this; 
    52645753                } 
    52655754        }, 
     
    53755864} 
    53765865 
    5377 function cloneFixAttributes(src, dest) { 
     5866function cloneFixAttributes( src, dest ) { 
     5867        var nodeName; 
     5868 
    53785869        // We do not need to do anything for non-Elements 
    53795870        if ( dest.nodeType !== 1 ) { 
     
    53815872        } 
    53825873 
    5383         var nodeName = dest.nodeName.toLowerCase(); 
    5384  
    53855874        // clearAttributes removes the attributes, which we don't want, 
    53865875        // but also removes the attachEvent events, which we *do* want 
    5387         dest.clearAttributes(); 
     5876        if ( dest.clearAttributes ) { 
     5877                dest.clearAttributes(); 
     5878        } 
    53885879 
    53895880        // mergeAttributes, in contrast, only merges back on the 
    53905881        // original attributes, not the events 
    5391         dest.mergeAttributes(src); 
     5882        if ( dest.mergeAttributes ) { 
     5883                dest.mergeAttributes( src ); 
     5884        } 
     5885 
     5886        nodeName = dest.nodeName.toLowerCase(); 
    53925887 
    53935888        // IE6-8 fail to clone children inside object elements that use 
     
    54285923 
    54295924jQuery.buildFragment = function( args, nodes, scripts ) { 
    5430         var fragment, cacheable, cacheresults, 
    5431                 doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document); 
     5925        var fragment, cacheable, cacheresults, doc; 
     5926 
     5927  // nodes may contain either an explicit document object, 
     5928  // a jQuery collection or context object. 
     5929  // If nodes[0] contains a valid object to assign to doc 
     5930  if ( nodes && nodes[0] ) { 
     5931    doc = nodes[0].ownerDocument || nodes[0]; 
     5932  } 
     5933 
     5934  // Ensure that an attr object doesn't incorrectly stand in as a document object 
     5935        // Chrome and Firefox seem to allow this to occur and will throw exception 
     5936        // Fixes #8950 
     5937        if ( !doc.createDocumentFragment ) { 
     5938                doc = document; 
     5939        } 
    54325940 
    54335941        // Only cache "small" (1/2 KB) HTML strings that are associated with the main document 
     
    54395947 
    54405948                cacheable = true; 
     5949 
    54415950                cacheresults = jQuery.fragments[ args[0] ]; 
    5442                 if ( cacheresults ) { 
    5443                         if ( cacheresults !== 1 ) { 
    5444                                 fragment = cacheresults; 
    5445                         } 
     5951                if ( cacheresults && cacheresults !== 1 ) { 
     5952                        fragment = cacheresults; 
    54465953                } 
    54475954        } 
     
    54925999        if ( "getElementsByTagName" in elem ) { 
    54936000                return elem.getElementsByTagName( "*" ); 
    5494          
     6001 
    54956002        } else if ( "querySelectorAll" in elem ) { 
    54966003                return elem.querySelectorAll( "*" ); 
     
    54986005        } else { 
    54996006                return []; 
     6007        } 
     6008} 
     6009 
     6010// Used in clean, fixes the defaultChecked property 
     6011function fixDefaultChecked( elem ) { 
     6012        if ( elem.type === "checkbox" || elem.type === "radio" ) { 
     6013                elem.defaultChecked = elem.checked; 
     6014        } 
     6015} 
     6016// Finds all inputs and passes them to fixDefaultChecked 
     6017function findInputs( elem ) { 
     6018        if ( jQuery.nodeName( elem, "input" ) ) { 
     6019                fixDefaultChecked( elem ); 
     6020        } else if ( "getElementsByTagName" in elem ) { 
     6021                jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked ); 
    55006022        } 
    55016023} 
     
    55456067                } 
    55466068 
     6069                srcElements = destElements = null; 
     6070 
    55476071                // Return the cloned set 
    55486072                return clone; 
    5549 }, 
     6073        }, 
     6074 
    55506075        clean: function( elems, context, fragment, scripts ) { 
     6076                var checkScriptType; 
     6077 
    55516078                context = context || document; 
    55526079 
     
    55566083                } 
    55576084 
    5558                 var ret = []; 
     6085                var ret = [], j; 
    55596086 
    55606087                for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) { 
     
    55686095 
    55696096                        // Convert html string into DOM nodes 
    5570                         if ( typeof elem === "string" && !rhtml.test( elem ) ) { 
    5571                                 elem = context.createTextNode( elem ); 
    5572  
    5573                         } else if ( typeof elem === "string" ) { 
    5574                                 // Fix "XHTML"-style tags in all browsers 
    5575                                 elem = elem.replace(rxhtmlTag, "<$1></$2>"); 
    5576  
    5577                                 // Trim whitespace, otherwise indexOf won't work as expected 
    5578                                 var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(), 
    5579                                         wrap = wrapMap[ tag ] || wrapMap._default, 
    5580                                         depth = wrap[0], 
    5581                                         div = context.createElement("div"); 
    5582  
    5583                                 // Go to html and back, then peel off extra wrappers 
    5584                                 div.innerHTML = wrap[1] + elem + wrap[2]; 
    5585  
    5586                                 // Move to the right depth 
    5587                                 while ( depth-- ) { 
    5588                                         div = div.lastChild; 
    5589                                 } 
    5590  
    5591                                 // Remove IE's autoinserted <tbody> from table fragments 
    5592                                 if ( !jQuery.support.tbody ) { 
    5593  
    5594                                         // String was a <table>, *may* have spurious <tbody> 
    5595                                         var hasBody = rtbody.test(elem), 
    5596                                                 tbody = tag === "table" && !hasBody ? 
    5597                                                         div.firstChild && div.firstChild.childNodes : 
    5598  
    5599                                                         // String was a bare <thead> or <tfoot> 
    5600                                                         wrap[1] === "<table>" && !hasBody ? 
    5601                                                                 div.childNodes : 
    5602                                                                 []; 
    5603  
    5604                                         for ( var j = tbody.length - 1; j >= 0 ; --j ) { 
    5605                                                 if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) { 
    5606                                                         tbody[ j ].parentNode.removeChild( tbody[ j ] ); 
     6097                        if ( typeof elem === "string" ) { 
     6098                                if ( !rhtml.test( elem ) ) { 
     6099                                        elem = context.createTextNode( elem ); 
     6100                                } else { 
     6101                                        // Fix "XHTML"-style tags in all browsers 
     6102                                        elem = elem.replace(rxhtmlTag, "<$1></$2>"); 
     6103 
     6104                                        // Trim whitespace, otherwise indexOf won't work as expected 
     6105                                        var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(), 
     6106                                                wrap = wrapMap[ tag ] || wrapMap._default, 
     6107                                                depth = wrap[0], 
     6108                                                div = context.createElement("div"); 
     6109 
     6110                                        // Go to html and back, then peel off extra wrappers 
     6111                                        div.innerHTML = wrap[1] + elem + wrap[2]; 
     6112 
     6113                                        // Move to the right depth 
     6114                                        while ( depth-- ) { 
     6115                                                div = div.lastChild; 
     6116                                        } 
     6117 
     6118                                        // Remove IE's autoinserted <tbody> from table fragments 
     6119                                        if ( !jQuery.support.tbody ) { 
     6120 
     6121                                                // String was a <table>, *may* have spurious <tbody> 
     6122                                                var hasBody = rtbody.test(elem), 
     6123                                                        tbody = tag === "table" && !hasBody ? 
     6124                                                                div.firstChild && div.firstChild.childNodes : 
     6125 
     6126                                                                // String was a bare <thead> or <tfoot> 
     6127                                                                wrap[1] === "<table>" && !hasBody ? 
     6128                                                                        div.childNodes : 
     6129                                                                        []; 
     6130 
     6131                                                for ( j = tbody.length - 1; j >= 0 ; --j ) { 
     6132                                                        if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) { 
     6133                                                                tbody[ j ].parentNode.removeChild( tbody[ j ] ); 
     6134                                                        } 
    56076135                                                } 
    56086136                                        } 
    56096137 
    5610                                 } 
    5611  
    5612                                 // IE completely kills leading whitespace when innerHTML is used 
    5613                                 if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) { 
    5614                                         div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild ); 
    5615                                 } 
    5616  
    5617                                 elem = div.childNodes; 
     6138                                        // IE completely kills leading whitespace when innerHTML is used 
     6139                                        if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) { 
     6140                                                div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild ); 
     6141                                        } 
     6142 
     6143                                        elem = div.childNodes; 
     6144                                } 
     6145                        } 
     6146 
     6147                        // Resets defaultChecked for any radios and checkboxes 
     6148                        // about to be appended to the DOM in IE 6/7 (#8060) 
     6149                        var len; 
     6150                        if ( !jQuery.support.appendChecked ) { 
     6151                                if ( elem[0] && typeof (len = elem.length) === "number" ) { 
     6152                                        for ( j = 0; j < len; j++ ) { 
     6153                                                findInputs( elem[j] ); 
     6154                                        } 
     6155                                } else { 
     6156                                        findInputs( elem ); 
     6157                                } 
    56186158                        } 
    56196159 
     
    56266166 
    56276167                if ( fragment ) { 
     6168                        checkScriptType = function( elem ) { 
     6169                                return !elem.type || rscriptType.test( elem.type ); 
     6170                        }; 
    56286171                        for ( i = 0; ret[i]; i++ ) { 
    56296172                                if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) { 
     
    56326175                                } else { 
    56336176                                        if ( ret[i].nodeType === 1 ) { 
    5634                                                 ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) ); 
     6177                                                var jsTags = jQuery.grep( ret[i].getElementsByTagName( "script" ), checkScriptType ); 
     6178 
     6179                                                ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) ); 
    56356180                                        } 
    56366181                                        fragment.appendChild( ret[i] ); 
     
    56946239                }); 
    56956240        } else { 
    5696                 jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" ); 
     6241                jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "/*$0*/" ) ); 
    56976242        } 
    56986243 
     
    57046249 
    57056250 
    5706  
    57076251var ralpha = /alpha\([^)]*\)/i, 
    57086252        ropacity = /opacity=([^)]*)/, 
    5709         rdashAlpha = /-([a-z])/ig, 
    5710         rupper = /([A-Z])/g, 
     6253        // fixed for IE9, see #8346 
     6254        rupper = /([A-Z]|^ms)/g, 
    57116255        rnumpx = /^-?\d+(?:px)?$/i, 
    57126256        rnum = /^-?\d/, 
     6257        rrelNum = /^[+\-]=/, 
     6258        rrelNumFilter = /[^+\-\.\de]+/g, 
    57136259 
    57146260        cssShow = { position: "absolute", visibility: "hidden", display: "block" }, 
     
    57186264 
    57196265        getComputedStyle, 
    5720         currentStyle, 
    5721  
    5722         fcamelCase = function( all, letter ) { 
    5723                 return letter.toUpperCase(); 
    5724         }; 
     6266        currentStyle; 
    57256267 
    57266268jQuery.fn.css = function( name, value ) { 
     
    57576299        // Exclude the following css properties to add px 
    57586300        cssNumber: { 
     6301                "fillOpacity": true, 
     6302                "fontWeight": true, 
     6303                "lineHeight": true, 
     6304                "opacity": true, 
     6305                "orphans": true, 
     6306                "widows": true, 
    57596307                "zIndex": true, 
    5760                 "fontWeight": true, 
    5761                 "opacity": true, 
    5762                 "zoom": true, 
    5763                 "lineHeight": true 
     6308                "zoom": true 
    57646309        }, 
    57656310 
     
    57796324 
    57806325                // Make sure that we're working with the right name 
    5781                 var ret, origName = jQuery.camelCase( name ), 
     6326                var ret, type, origName = jQuery.camelCase( name ), 
    57826327                        style = elem.style, hooks = jQuery.cssHooks[ origName ]; 
    57836328 
     
    57866331                // Check if we're setting a value 
    57876332                if ( value !== undefined ) { 
     6333                        type = typeof value; 
     6334 
    57886335                        // Make sure that NaN and null values aren't set. See: #7116 
    5789                         if ( typeof value === "number" && isNaN( value ) || value == null ) { 
     6336                        if ( type === "number" && isNaN( value ) || value == null ) { 
    57906337                                return; 
    57916338                        } 
    57926339 
     6340                        // convert relative number strings (+= or -=) to relative numbers. #7345 
     6341                        if ( type === "string" && rrelNum.test( value ) ) { 
     6342                                value = +value.replace( rrelNumFilter, "" ) + parseFloat( jQuery.css( elem, name ) ); 
     6343                                // Fixes bug #9237 
     6344                                type = "number"; 
     6345                        } 
     6346 
    57936347                        // If a number was passed in, add 'px' to the (except for certain CSS properties) 
    5794                         if ( typeof value === "number" && !jQuery.cssNumber[ origName ] ) { 
     6348                        if ( type === "number" && !jQuery.cssNumber[ origName ] ) { 
    57956349                                value += "px"; 
    57966350                        } 
     
    58176371 
    58186372        css: function( elem, name, extra ) { 
     6373                var ret, hooks; 
     6374 
    58196375                // Make sure that we're working with the right name 
    5820                 var ret, origName = jQuery.camelCase( name ), 
    5821                         hooks = jQuery.cssHooks[ origName ]; 
    5822  
    5823                 name = jQuery.cssProps[ origName ] || origName; 
     6376                name = jQuery.camelCase( name ); 
     6377                hooks = jQuery.cssHooks[ name ]; 
     6378                name = jQuery.cssProps[ name ] || name; 
     6379 
     6380                // cssFloat needs a special treatment 
     6381                if ( name === "cssFloat" ) { 
     6382                        name = "float"; 
     6383                } 
    58246384 
    58256385                // If a hook was provided get the computed value from there 
     
    58296389                // Otherwise, if a way to get the computed value exists, use that 
    58306390                } else if ( curCSS ) { 
    5831                         return curCSS( elem, name, origName ); 
     6391                        return curCSS( elem, name ); 
    58326392                } 
    58336393        }, 
     
    58496409                        elem.style[ name ] = old[ name ]; 
    58506410                } 
    5851         }, 
    5852  
    5853         camelCase: function( string ) { 
    5854                 return string.replace( rdashAlpha, fcamelCase ); 
    58556411        } 
    58566412}); 
     
    58666422                        if ( computed ) { 
    58676423                                if ( elem.offsetWidth !== 0 ) { 
    5868                                         val = getWH( elem, name, extra ); 
    5869  
     6424                                        return getWH( elem, name, extra ); 
    58706425                                } else { 
    58716426                                        jQuery.swap( elem, cssShow, function() { 
     
    58746429                                } 
    58756430 
    5876                                 if ( val <= 0 ) { 
    5877                                         val = curCSS( elem, name, name ); 
    5878  
    5879                                         if ( val === "0px" && currentStyle ) { 
    5880                                                 val = currentStyle( elem, name, name ); 
    5881                                         } 
    5882  
    5883                                         if ( val != null ) { 
    5884                                                 // Should return "auto" instead of 0, use 0 for 
    5885                                                 // temporary backwards-compat 
    5886                                                 return val === "" || val === "auto" ? "0px" : val; 
    5887                                         } 
    5888                                 } 
    5889  
    5890                                 if ( val < 0 || val == null ) { 
    5891                                         val = elem.style[ name ]; 
    5892  
    5893                                         // Should return "auto" instead of 0, use 0 for 
    5894                                         // temporary backwards-compat 
    5895                                         return val === "" || val === "auto" ? "0px" : val; 
    5896                                 } 
    5897  
    5898                                 return typeof val === "string" ? val : val + "px"; 
     6431                                return val; 
    58996432                        } 
    59006433                }, 
     
    59036436                        if ( rnumpx.test( value ) ) { 
    59046437                                // ignore negative width and height values #1599 
    5905                                 value = parseFloat(value); 
     6438                                value = parseFloat( value ); 
    59066439 
    59076440                                if ( value >= 0 ) { 
     
    59206453                get: function( elem, computed ) { 
    59216454                        // IE uses filters for opacity 
    5922                         return ropacity.test((computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "") ? 
    5923                                 (parseFloat(RegExp.$1) / 100) + "" : 
     6455                        return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ? 
     6456                                ( parseFloat( RegExp.$1 ) / 100 ) + "" : 
    59246457                                computed ? "1" : ""; 
    59256458                }, 
    59266459 
    59276460                set: function( elem, value ) { 
    5928                         var style = elem.style; 
     6461                        var style = elem.style, 
     6462                                currentStyle = elem.currentStyle; 
    59296463 
    59306464                        // IE has trouble with opacity if it does not have layout 
     
    59336467 
    59346468                        // Set the alpha filter to set the opacity 
    5935                         var opacity = jQuery.isNaN(value) ? 
     6469                        var opacity = jQuery.isNaN( value ) ? 
    59366470                                "" : 
    59376471                                "alpha(opacity=" + value * 100 + ")", 
    5938                                 filter = style.filter || ""; 
    5939  
    5940                         style.filter = ralpha.test(filter) ? 
    5941                                 filter.replace(ralpha, opacity) : 
    5942                                 style.filter + ' ' + opacity; 
     6472                                filter = currentStyle && currentStyle.filter || style.filter || ""; 
     6473 
     6474                        style.filter = ralpha.test( filter ) ? 
     6475                                filter.replace( ralpha, opacity ) : 
     6476                                filter + " " + opacity; 
    59436477                } 
    59446478        }; 
    59456479} 
    59466480 
     6481jQuery(function() { 
     6482        // This hook cannot be added until DOM ready because the support test 
     6483        // for it is not run until after DOM ready 
     6484        if ( !jQuery.support.reliableMarginRight ) { 
     6485                jQuery.cssHooks.marginRight = { 
     6486                        get: function( elem, computed ) { 
     6487                                // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right 
     6488                                // Work around by temporarily setting element display to inline-block 
     6489                                var ret; 
     6490                                jQuery.swap( elem, { "display": "inline-block" }, function() { 
     6491                                        if ( computed ) { 
     6492                                                ret = curCSS( elem, "margin-right", "marginRight" ); 
     6493                                        } else { 
     6494                                                ret = elem.style.marginRight; 
     6495                                        } 
     6496                                }); 
     6497                                return ret; 
     6498                        } 
     6499                }; 
     6500        } 
     6501}); 
     6502 
    59476503if ( document.defaultView && document.defaultView.getComputedStyle ) { 
    5948         getComputedStyle = function( elem, newName, name ) { 
     6504        getComputedStyle = function( elem, name ) { 
    59496505                var ret, defaultView, computedStyle; 
    59506506 
     
    60036559 
    60046560function getWH( elem, name, extra ) { 
    6005         var which = name === "width" ? cssWidth : cssHeight, 
    6006                 val = name === "width" ? elem.offsetWidth : elem.offsetHeight; 
    6007  
    6008         if ( extra === "border" ) { 
    6009                 return val; 
    6010         } 
    6011  
    6012         jQuery.each( which, function() { 
    6013                 if ( !extra ) { 
    6014                         val -= parseFloat(jQuery.css( elem, "padding" + this )) || 0; 
    6015                 } 
    6016  
    6017                 if ( extra === "margin" ) { 
    6018                         val += parseFloat(jQuery.css( elem, "margin" + this )) || 0; 
    6019  
    6020                 } else { 
    6021                         val -= parseFloat(jQuery.css( elem, "border" + this + "Width" )) || 0; 
    6022                 } 
    6023         }); 
    6024  
    6025         return val; 
     6561 
     6562        // Start with offset property 
     6563        var val = name === "width" ? elem.offsetWidth : elem.offsetHeight, 
     6564                which = name === "width" ? cssWidth : cssHeight; 
     6565 
     6566        if ( val > 0 ) { 
     6567                if ( extra !== "border" ) { 
     6568                        jQuery.each( which, function() { 
     6569                                if ( !extra ) { 
     6570                                        val -= parseFloat( jQuery.css( elem, "padding" + this ) ) || 0; 
     6571                                } 
     6572                                if ( extra === "margin" ) { 
     6573                                        val += parseFloat( jQuery.css( elem, extra + this ) ) || 0; 
     6574                                } else { 
     6575                                        val -= parseFloat( jQuery.css( elem, "border" + this + "Width" ) ) || 0; 
     6576                                } 
     6577                        }); 
     6578                } 
     6579 
     6580                return val + "px"; 
     6581        } 
     6582 
     6583        // Fall back to computed then uncomputed css if necessary 
     6584        val = curCSS( elem, name, name ); 
     6585        if ( val < 0 || val == null ) { 
     6586                val = elem.style[ name ] || 0; 
     6587        } 
     6588        // Normalize "", auto, and prepare for extra 
     6589        val = parseFloat( val ) || 0; 
     6590 
     6591        // Add padding, border, margin 
     6592        if ( extra ) { 
     6593                jQuery.each( which, function() { 
     6594                        val += parseFloat( jQuery.css( elem, "padding" + this ) ) || 0; 
     6595                        if ( extra !== "padding" ) { 
     6596                                val += parseFloat( jQuery.css( elem, "border" + this + "Width" ) ) || 0; 
     6597                        } 
     6598                        if ( extra === "margin" ) { 
     6599                                val += parseFloat( jQuery.css( elem, extra + this ) ) || 0; 
     6600                        } 
     6601                }); 
     6602        } 
     6603 
     6604        return val + "px"; 
    60266605} 
    60276606 
     
    60496628        rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i, 
    60506629        // #7653, #8125, #8152: local protocol detection 
    6051         rlocalProtocol = /(?:^file|^widget|\-extension):$/, 
     6630        rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|widget):$/, 
    60526631        rnoContent = /^(?:GET|HEAD)$/, 
    60536632        rprotocol = /^\/\//, 
     
    60576636        rspacesAjax = /\s+/, 
    60586637        rts = /([?&])_=[^&]*/, 
    6059         rucHeaders = /(^|\-)([a-z])/g, 
    6060         rucHeadersFunc = function( _, $1, $2 ) { 
    6061                 return $1 + $2.toUpperCase(); 
    6062         }, 
    6063         rurl = /^([\w\+\.\-]+:)\/\/([^\/?#:]*)(?::(\d+))?/, 
     6638        rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/, 
    60646639 
    60656640        // Keep a copy of the old load method 
     
    60916666 
    60926667// #8138, IE may throw an exception when accessing 
    6093 // a field from document.location if document.domain has been set 
     6668// a field from window.location if document.domain has been set 
    60946669try { 
    6095         ajaxLocation = document.location.href; 
     6670        ajaxLocation = location.href; 
    60966671} catch( e ) { 
    60976672        // Use the href attribute of an A element 
     
    61036678 
    61046679// Segment location into parts 
    6105 ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ); 
     6680ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || []; 
    61066681 
    61076682// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport 
     
    61416716} 
    61426717 
    6143 //Base inspection function for prefilters and transports 
     6718// Base inspection function for prefilters and transports 
    61446719function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR, 
    61456720                dataType /* internal */, inspected /* internal */ ) { 
     
    62906865                return this.bind( o, f ); 
    62916866        }; 
    6292 } ); 
     6867}); 
    62936868 
    62946869jQuery.each( [ "get", "post" ], function( i, method ) { 
     
    63096884                }); 
    63106885        }; 
    6311 } ); 
     6886}); 
    63126887 
    63136888jQuery.extend({ 
     
    63616936                traditional: false, 
    63626937                headers: {}, 
    6363                 crossDomain: null, 
    63646938                */ 
    63656939 
     
    64367010                        // Headers (they are sent all at once) 
    64377011                        requestHeaders = {}, 
     7012                        requestHeadersNames = {}, 
    64387013                        // Response headers 
    64397014                        responseHeadersString, 
     
    64597034                                setRequestHeader: function( name, value ) { 
    64607035                                        if ( !state ) { 
    6461                                                 requestHeaders[ name.toLowerCase().replace( rucHeaders, rucHeadersFunc ) ] = value; 
     7036                                                var lname = name.toLowerCase(); 
     7037                                                name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name; 
     7038                                                requestHeaders[ name ] = value; 
    64627039                                        } 
    64637040                                        return this; 
     
    66467223 
    66477224                // Determine if a cross-domain request is in order 
    6648                 if ( !s.crossDomain ) { 
     7225                if ( s.crossDomain == null ) { 
    66497226                        parts = rurl.exec( s.url.toLowerCase() ); 
    66507227                        s.crossDomain = !!( parts && 
     
    67077284                // Set the correct header, if data is being sent 
    67087285                if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { 
    6709                         requestHeaders[ "Content-Type" ] = s.contentType; 
     7286                        jqXHR.setRequestHeader( "Content-Type", s.contentType ); 
    67107287                } 
    67117288 
     
    67147291                        ifModifiedKey = ifModifiedKey || s.url; 
    67157292                        if ( jQuery.lastModified[ ifModifiedKey ] ) { 
    6716                                 requestHeaders[ "If-Modified-Since" ] = jQuery.lastModified[ ifModifiedKey ]; 
     7293                                jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] ); 
    67177294                        } 
    67187295                        if ( jQuery.etag[ ifModifiedKey ] ) { 
    6719                                 requestHeaders[ "If-None-Match" ] = jQuery.etag[ ifModifiedKey ]; 
     7296                                jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] ); 
    67207297                        } 
    67217298                } 
    67227299 
    67237300                // Set the Accepts header for the server, depending on the dataType 
    6724                 requestHeaders.Accept = s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ? 
    6725                         s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", */*; q=0.01" : "" ) : 
    6726                         s.accepts[ "*" ]; 
     7301                jqXHR.setRequestHeader( 
     7302                        "Accept", 
     7303                        s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ? 
     7304                                s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", */*; q=0.01" : "" ) : 
     7305                                s.accepts[ "*" ] 
     7306                ); 
    67277307 
    67287308                // Check for headers option 
     
    68007380                        jQuery.each( a, function() { 
    68017381                                add( this.name, this.value ); 
    6802                         } ); 
     7382                        }); 
    68037383 
    68047384                } else { 
     
    68167396 
    68177397function buildParams( prefix, obj, traditional, add ) { 
    6818         if ( jQuery.isArray( obj ) && obj.length ) { 
     7398        if ( jQuery.isArray( obj ) ) { 
    68197399                // Serialize array item. 
    68207400                jQuery.each( obj, function( i, v ) { 
     
    68367416 
    68377417        } else if ( !traditional && obj != null && typeof obj === "object" ) { 
    6838                 // If we see an array here, it is empty and should be treated as an empty 
    6839                 // object 
    6840                 if ( jQuery.isArray( obj ) || jQuery.isEmptyObject( obj ) ) { 
    6841                         add( prefix, "" ); 
    6842  
    68437418                // Serialize object item. 
    6844                 } else { 
    6845                         for ( var name in obj ) { 
    6846                                 buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); 
    6847                         } 
     7419                for ( var name in obj ) { 
     7420                        buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); 
    68487421                } 
    68497422 
     
    70257598 
    70267599var jsc = jQuery.now(), 
    7027         jsre = /(\=)\?(&|$)|()\?\?()/i; 
     7600        jsre = /(\=)\?(&|$)|\?\?/i; 
    70287601 
    70297602// Default jsonp settings 
     
    70387611jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) { 
    70397612 
    7040         var dataIsString = ( typeof s.data === "string" ); 
     7613        var inspectData = s.contentType === "application/x-www-form-urlencoded" && 
     7614                ( typeof s.data === "string" ); 
    70417615 
    70427616        if ( s.dataTypes[ 0 ] === "jsonp" || 
    7043                 originalSettings.jsonpCallback || 
    7044                 originalSettings.jsonp != null || 
    70457617                s.jsonp !== false && ( jsre.test( s.url ) || 
    7046                                 dataIsString && jsre.test( s.data ) ) ) { 
     7618                                inspectData && jsre.test( s.data ) ) ) { 
    70477619 
    70487620                var responseContainer, 
     
    70527624                        url = s.url, 
    70537625                        data = s.data, 
    7054                         replace = "$1" + jsonpCallback + "$2", 
    7055                         cleanUp = function() { 
    7056                                 // Set callback back to previous value 
    7057                                 window[ jsonpCallback ] = previous; 
    7058                                 // Call if it was a function and we have a response 
    7059                                 if ( responseContainer && jQuery.isFunction( previous ) ) { 
    7060                                         window[ jsonpCallback ]( responseContainer[ 0 ] ); 
    7061                                 } 
    7062                         }; 
     7626                        replace = "$1" + jsonpCallback + "$2"; 
    70637627 
    70647628                if ( s.jsonp !== false ) { 
    70657629                        url = url.replace( jsre, replace ); 
    70667630                        if ( s.url === url ) { 
    7067                                 if ( dataIsString ) { 
     7631                                if ( inspectData ) { 
    70687632                                        data = data.replace( jsre, replace ); 
    70697633                                } 
     
    70837647                }; 
    70847648 
    7085                 // Install cleanUp function 
    7086                 jqXHR.then( cleanUp, cleanUp ); 
     7649                // Clean-up function 
     7650                jqXHR.always(function() { 
     7651                        // Set callback back to previous value 
     7652                        window[ jsonpCallback ] = previous; 
     7653                        // Call if it was a function and we have a response 
     7654                        if ( responseContainer && jQuery.isFunction( previous ) ) { 
     7655                                window[ jsonpCallback ]( responseContainer[ 0 ] ); 
     7656                        } 
     7657                }); 
    70877658 
    70887659                // Use data converter to retrieve json after script execution 
     
    71007671                return "script"; 
    71017672        } 
    7102 } ); 
     7673}); 
    71037674 
    71047675 
     
    71307701                s.global = false; 
    71317702        } 
    7132 } ); 
     7703}); 
    71337704 
    71347705// Bind script tag hack transport 
     
    71587729                                script.onload = script.onreadystatechange = function( _, isAbort ) { 
    71597730 
    7160                                         if ( !script.readyState || /loaded|complete/.test( script.readyState ) ) { 
     7731                                        if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) { 
    71617732 
    71627733                                                // Handle memory leak in IE 
     
    71897760                }; 
    71907761        } 
    7191 } ); 
    7192  
    7193  
    7194  
    7195  
    7196 var // #5280: next active xhr id and list of active xhrs' callbacks 
    7197         xhrId = jQuery.now(), 
    7198         xhrCallbacks, 
    7199  
    7200         // XHR used to determine supports properties 
    7201         testXHR; 
    7202  
    7203 // #5280: Internet Explorer will keep connections alive if we don't abort on unload 
    7204 function xhrOnUnloadAbort() { 
    7205         jQuery( window ).unload(function() { 
     7762}); 
     7763 
     7764 
     7765 
     7766 
     7767var // #5280: Internet Explorer will keep connections alive if we don't abort on unload 
     7768        xhrOnUnloadAbort = window.ActiveXObject ? function() { 
    72067769                // Abort all pending requests 
    72077770                for ( var key in xhrCallbacks ) { 
    72087771                        xhrCallbacks[ key ]( 0, 1 ); 
    72097772                } 
    7210         }); 
    7211 } 
     7773        } : false, 
     7774        xhrId = 0, 
     7775        xhrCallbacks; 
    72127776 
    72137777// Functions to create xhrs 
     
    72397803        createStandardXHR; 
    72407804 
    7241 // Test if we can create an xhr object 
    7242 testXHR = jQuery.ajaxSettings.xhr(); 
    7243 jQuery.support.ajax = !!testXHR; 
    7244  
    7245 // Does this browser support crossDomain XHR requests 
    7246 jQuery.support.cors = testXHR && ( "withCredentials" in testXHR ); 
    7247  
    7248 // No need for the temporary xhr anymore 
    7249 testXHR = undefined; 
     7805// Determine support properties 
     7806(function( xhr ) { 
     7807        jQuery.extend( jQuery.support, { 
     7808                ajax: !!xhr, 
     7809                cors: !!xhr && ( "withCredentials" in xhr ) 
     7810        }); 
     7811})( jQuery.ajaxSettings.xhr() ); 
    72507812 
    72517813// Create transport if the browser can provide an xhr 
     
    72867848                                        } 
    72877849 
    7288                                         // Requested-With header 
    7289                                         // Not set for crossDomain requests with no content 
    7290                                         // (see why at http://trac.dojotoolkit.org/ticket/9486) 
    7291                                         // Won't change header if already provided 
    7292                                         if ( !( s.crossDomain && !s.hasContent ) && !headers["X-Requested-With"] ) { 
     7850                                        // X-Requested-With header 
     7851                                        // For cross-domain requests, seeing as conditions for a preflight are 
     7852                                        // akin to a jigsaw puzzle, we simply never set it to be sure. 
     7853                                        // (it can always be set on a per-request basis or even using ajaxSetup) 
     7854                                        // For same-domain requests, won't change header if already provided. 
     7855                                        if ( !s.crossDomain && !headers["X-Requested-With"] ) { 
    72937856                                                headers[ "X-Requested-With" ] = "XMLHttpRequest"; 
    72947857                                        } 
     
    73297892                                                                if ( handle ) { 
    73307893                                                                        xhr.onreadystatechange = jQuery.noop; 
    7331                                                                         delete xhrCallbacks[ handle ]; 
     7894                                                                        if ( xhrOnUnloadAbort ) { 
     7895                                                                                delete xhrCallbacks[ handle ]; 
     7896                                                                        } 
    73327897                                                                } 
    73337898 
     
    73907955                                                callback(); 
    73917956                                        } else { 
    7392                                                 // Create the active xhrs callbacks list if needed 
    7393                                                 // and attach the unload handler 
    7394                                                 if ( !xhrCallbacks ) { 
    7395                                                         xhrCallbacks = {}; 
    7396                                                         xhrOnUnloadAbort(); 
     7957                                                handle = ++xhrId; 
     7958                                                if ( xhrOnUnloadAbort ) { 
     7959                                                        // Create the active xhrs callbacks list if needed 
     7960                                                        // and attach the unload handler 
     7961                                                        if ( !xhrCallbacks ) { 
     7962                                                                xhrCallbacks = {}; 
     7963                                                                jQuery( window ).unload( xhrOnUnloadAbort ); 
     7964                                                        } 
     7965                                                        // Add to list of active xhrs callbacks 
     7966                                                        xhrCallbacks[ handle ] = callback; 
    73977967                                                } 
    7398                                                 // Add to list of active xhrs callbacks 
    7399                                                 handle = xhrId++; 
    7400                                                 xhr.onreadystatechange = xhrCallbacks[ handle ] = callback; 
     7968                                                xhr.onreadystatechange = callback; 
    74017969                                        } 
    74027970                                }, 
     
    74167984 
    74177985var elemdisplay = {}, 
     7986        iframe, iframeDoc, 
    74187987        rfxtypes = /^(?:toggle|show|hide)$/, 
    74197988        rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i, 
     
    74267995                // opacity animations 
    74277996                [ "opacity" ] 
    7428         ]; 
     7997        ], 
     7998        fxNow, 
     7999        requestAnimationFrame = window.webkitRequestAnimationFrame || 
     8000                window.mozRequestAnimationFrame || 
     8001                window.oRequestAnimationFrame; 
    74298002 
    74308003jQuery.fn.extend({ 
     
    74388011                        for ( var i = 0, j = this.length; i < j; i++ ) { 
    74398012                                elem = this[i]; 
    7440                                 display = elem.style.display; 
    7441  
    7442                                 // Reset the inline display of this element to learn if it is 
    7443                                 // being hidden by cascaded rules or not 
    7444                                 if ( !jQuery._data(elem, "olddisplay") && display === "none" ) { 
    7445                                         display = elem.style.display = ""; 
    7446                                 } 
    7447  
    7448                                 // Set elements which have been overridden with display: none 
    7449                                 // in a stylesheet to whatever the default browser style is 
    7450                                 // for such an element 
    7451                                 if ( display === "" && jQuery.css( elem, "display" ) === "none" ) { 
    7452                                         jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName)); 
     8013 
     8014                                if ( elem.style ) { 
     8015                                        display = elem.style.display; 
     8016 
     8017                                        // Reset the inline display of this element to learn if it is 
     8018                                        // being hidden by cascaded rules or not 
     8019                                        if ( !jQuery._data(elem, "olddisplay") && display === "none" ) { 
     8020                                                display = elem.style.display = ""; 
     8021                                        } 
     8022 
     8023                                        // Set elements which have been overridden with display: none 
     8024                                        // in a stylesheet to whatever the default browser style is 
     8025                                        // for such an element 
     8026                                        if ( display === "" && jQuery.css( elem, "display" ) === "none" ) { 
     8027                                                jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName)); 
     8028                                        } 
    74538029                                } 
    74548030                        } 
     
    74588034                        for ( i = 0; i < j; i++ ) { 
    74598035                                elem = this[i]; 
    7460                                 display = elem.style.display; 
    7461  
    7462                                 if ( display === "" || display === "none" ) { 
    7463                                         elem.style.display = jQuery._data(elem, "olddisplay") || ""; 
     8036 
     8037                                if ( elem.style ) { 
     8038                                        display = elem.style.display; 
     8039 
     8040                                        if ( display === "" || display === "none" ) { 
     8041                                                elem.style.display = jQuery._data(elem, "olddisplay") || ""; 
     8042                                        } 
    74648043                                } 
    74658044                        } 
     
    74758054                } else { 
    74768055                        for ( var i = 0, j = this.length; i < j; i++ ) { 
    7477                                 var display = jQuery.css( this[i], "display" ); 
    7478  
    7479                                 if ( display !== "none" && !jQuery._data( this[i], "olddisplay" ) ) { 
    7480                                         jQuery._data( this[i], "olddisplay", display ); 
     8056                                if ( this[i].style ) { 
     8057                                        var display = jQuery.css( this[i], "display" ); 
     8058 
     8059                                        if ( display !== "none" && !jQuery._data( this[i], "olddisplay" ) ) { 
     8060                                                jQuery._data( this[i], "olddisplay", display ); 
     8061                                        } 
    74818062                                } 
    74828063                        } 
     
    74858066                        // to avoid the constant reflow 
    74868067                        for ( i = 0; i < j; i++ ) { 
    7487                                 this[i].style.display = "none"; 
     8068                                if ( this[i].style ) { 
     8069                                        this[i].style.display = "none"; 
     8070                                } 
    74888071                        } 
    74898072 
     
    75238106 
    75248107                if ( jQuery.isEmptyObject( prop ) ) { 
    7525                         return this.each( optall.complete ); 
    7526                 } 
     8108                        return this.each( optall.complete, [ false ] ); 
     8109                } 
     8110 
     8111                // Do not change referenced properties as per-property easing will be lost 
     8112                prop = jQuery.extend( {}, prop ); 
    75278113 
    75288114                return this[ optall.queue === false ? "each" : "queue" ](function() { 
     
    75308116                        // test suite 
    75318117 
    7532                         var opt = jQuery.extend({}, optall), p, 
     8118                        if ( optall.queue === false ) { 
     8119                                jQuery._mark( this ); 
     8120                        } 
     8121 
     8122                        var opt = jQuery.extend( {}, optall ), 
    75338123                                isElement = this.nodeType === 1, 
    75348124                                hidden = isElement && jQuery(this).is(":hidden"), 
    7535                                 self = this; 
     8125                                name, val, p, 
     8126                                display, e, 
     8127                                parts, start, end, unit; 
     8128 
     8129                        // will store per property easing and be used to determine when an animation is complete 
     8130                        opt.animatedProperties = {}; 
    75368131 
    75378132                        for ( p in prop ) { 
    7538                                 var name = jQuery.camelCase( p ); 
    7539  
     8133 
     8134                                // property name normalization 
     8135                                name = jQuery.camelCase( p ); 
    75408136                                if ( p !== name ) { 
    75418137                                        prop[ name ] = prop[ p ]; 
    75428138                                        delete prop[ p ]; 
    7543                                         p = name; 
    7544                                 } 
    7545  
    7546                                 if ( prop[p] === "hide" && hidden || prop[p] === "show" && !hidden ) { 
    7547                                         return opt.complete.call(this); 
    7548                                 } 
    7549  
    7550                                 if ( isElement && ( p === "height" || p === "width" ) ) { 
     8139                                } 
     8140 
     8141                                val = prop[ name ]; 
     8142 
     8143                                // easing resolution: per property > opt.specialEasing > opt.easing > 'swing' (default) 
     8144                                if ( jQuery.isArray( val ) ) { 
     8145                                        opt.animatedProperties[ name ] = val[ 1 ]; 
     8146                                        val = prop[ name ] = val[ 0 ]; 
     8147                                } else { 
     8148                                        opt.animatedProperties[ name ] = opt.specialEasing && opt.specialEasing[ name ] || opt.easing || 'swing'; 
     8149                                } 
     8150 
     8151                                if ( val === "hide" && hidden || val === "show" && !hidden ) { 
     8152                                        return opt.complete.call( this ); 
     8153                                } 
     8154 
     8155                                if ( isElement && ( name === "height" || name === "width" ) ) { 
    75518156                                        // Make sure that nothing sneaks out 
    75528157                                        // Record all 3 overflow attributes because IE does not 
     
    75648169 
    75658170                                                } else { 
    7566                                                         var display = defaultDisplay(this.nodeName); 
     8171                                                        display = defaultDisplay( this.nodeName ); 
    75678172 
    75688173                                                        // inline-level elements accept inline-block; 
     
    75788183                                        } 
    75798184                                } 
    7580  
    7581                                 if ( jQuery.isArray( prop[p] ) ) { 
    7582                                         // Create (if needed) and add to specialEasing 
    7583                                         (opt.specialEasing = opt.specialEasing || {})[p] = prop[p][1]; 
    7584                                         prop[p] = prop[p][0]; 
    7585                                 } 
    75868185                        } 
    75878186 
     
    75908189                        } 
    75918190 
    7592                         opt.curAnim = jQuery.extend({}, prop); 
    7593  
    7594                         jQuery.each( prop, function( name, val ) { 
    7595                                 var e = new jQuery.fx( self, opt, name ); 
     8191                        for ( p in prop ) { 
     8192                                e = new jQuery.fx( this, opt, p ); 
     8193                                val = prop[ p ]; 
    75968194 
    75978195                                if ( rfxtypes.test(val) ) { 
    7598                                         e[ val === "toggle" ? hidden ? "show" : "hide" : val ]( prop ); 
     8196                                        e[ val === "toggle" ? hidden ? "show" : "hide" : val ](); 
    75998197 
    76008198                                } else { 
    7601                                         var parts = rfxnum.exec(val), 
    7602                                                 start = e.cur(); 
     8199                                        parts = rfxnum.exec( val ); 
     8200                                        start = e.cur(); 
    76038201 
    76048202                                        if ( parts ) { 
    7605                                                 var end = parseFloat( parts[2] ), 
    7606                                                         unit = parts[3] || ( jQuery.cssNumber[ name ] ? "" : "px" ); 
     8203                                                end = parseFloat( parts[2] ); 
     8204                                                unit = parts[3] || ( jQuery.cssNumber[ p ] ? "" : "px" ); 
    76078205 
    76088206                                                // We need to compute starting value 
    76098207                                                if ( unit !== "px" ) { 
    7610                                                         jQuery.style( self, name, (end || 1) + unit); 
     8208                                                        jQuery.style( this, p, (end || 1) + unit); 
    76118209                                                        start = ((end || 1) / e.cur()) * start; 
    7612                                                         jQuery.style( self, name, start + unit); 
     8210                                                        jQuery.style( this, p, start + unit); 
    76138211                                                } 
    76148212 
    76158213                                                // If a +=/-= token was provided, we're doing a relative animation 
    76168214                                                if ( parts[1] ) { 
    7617                                                         end = ((parts[1] === "-=" ? -1 : 1) * end) + start; 
     8215                                                        end = ( (parts[ 1 ] === "-=" ? -1 : 1) * end ) + start; 
    76188216                                                } 
    76198217 
     
    76248222                                        } 
    76258223                                } 
    7626                         }); 
     8224                        } 
    76278225 
    76288226                        // For JS strict compliance 
     
    76328230 
    76338231        stop: function( clearQueue, gotoEnd ) { 
    7634                 var timers = jQuery.timers; 
    7635  
    76368232                if ( clearQueue ) { 
    76378233                        this.queue([]); 
     
    76398235 
    76408236                this.each(function() { 
    7641                         // go in reverse order so anything added to the queue during the loop is ignored 
    7642                         for ( var i = timers.length - 1; i >= 0; i-- ) { 
     8237                        var timers = jQuery.timers, 
     8238                                i = timers.length; 
     8239                        // clear marker counters if we know they won't be 
     8240                        if ( !gotoEnd ) { 
     8241                                jQuery._unmark( true, this ); 
     8242                        } 
     8243                        while ( i-- ) { 
    76438244                                if ( timers[i].elem === this ) { 
    76448245                                        if (gotoEnd) { 
     
    76628263}); 
    76638264 
     8265// Animations created synchronously will run synchronously 
     8266function createFxNow() { 
     8267        setTimeout( clearFxNow, 0 ); 
     8268        return ( fxNow = jQuery.now() ); 
     8269} 
     8270 
     8271function clearFxNow() { 
     8272        fxNow = undefined; 
     8273} 
     8274 
     8275// Generate parameters to create a standard animation 
    76648276function genFx( type, num ) { 
    76658277        var obj = {}; 
     
    77008312                // Queueing 
    77018313                opt.old = opt.complete; 
    7702                 opt.complete = function() { 
    7703                         if ( opt.queue !== false ) { 
    7704                                 jQuery(this).dequeue(); 
    7705                         } 
     8314                opt.complete = function( noUnmark ) { 
    77068315                        if ( jQuery.isFunction( opt.old ) ) { 
    77078316                                opt.old.call( this ); 
     8317                        } 
     8318 
     8319                        if ( opt.queue !== false ) { 
     8320                                jQuery.dequeue( this ); 
     8321                        } else if ( noUnmark !== false ) { 
     8322                                jQuery._unmark( this ); 
    77088323                        } 
    77098324                }; 
     
    77288343                this.prop = prop; 
    77298344 
    7730                 if ( !options.orig ) { 
    7731                         options.orig = {}; 
    7732                 } 
     8345                options.orig = options.orig || {}; 
    77338346        } 
    77348347 
     
    77628375        custom: function( from, to, unit ) { 
    77638376                var self = this, 
    7764                         fx = jQuery.fx; 
    7765  
    7766                 this.startTime = jQuery.now(); 
     8377                        fx = jQuery.fx, 
     8378                        raf; 
     8379 
     8380                this.startTime = fxNow || createFxNow(); 
    77678381                this.start = from; 
    77688382                this.end = to; 
     
    77788392 
    77798393                if ( t() && jQuery.timers.push(t) && !timerId ) { 
    7780                         timerId = setInterval(fx.tick, fx.interval); 
     8394                        // Use requestAnimationFrame instead of setInterval if available 
     8395                        if ( requestAnimationFrame ) { 
     8396                                timerId = true; 
     8397                                raf = function() { 
     8398                                        // When timerId gets set to null at any point, this stops 
     8399                                        if ( timerId ) { 
     8400                                                requestAnimationFrame( raf ); 
     8401                                                fx.tick(); 
     8402                                        } 
     8403                                }; 
     8404                                requestAnimationFrame( raf ); 
     8405                        } else { 
     8406                                timerId = setInterval( fx.tick, fx.interval ); 
     8407                        } 
    77818408                } 
    77828409        }, 
     
    78098436        // Each step of an animation 
    78108437        step: function( gotoEnd ) { 
    7811                 var t = jQuery.now(), done = true; 
    7812  
    7813                 if ( gotoEnd || t >= this.options.duration + this.startTime ) { 
     8438                var t = fxNow || createFxNow(), 
     8439                        done = true, 
     8440                        elem = this.elem, 
     8441                        options = this.options, 
     8442                        i, n; 
     8443 
     8444                if ( gotoEnd || t >= options.duration + this.startTime ) { 
    78148445                        this.now = this.end; 
    78158446                        this.pos = this.state = 1; 
    78168447                        this.update(); 
    78178448 
    7818                         this.options.curAnim[ this.prop ] = true; 
    7819  
    7820                         for ( var i in this.options.curAnim ) { 
    7821                                 if ( this.options.curAnim[i] !== true ) { 
     8449                        options.animatedProperties[ this.prop ] = true; 
     8450 
     8451                        for ( i in options.animatedProperties ) { 
     8452                                if ( options.animatedProperties[i] !== true ) { 
    78228453                                        done = false; 
    78238454                                } 
     
    78268457                        if ( done ) { 
    78278458                                // Reset the overflow 
    7828                                 if ( this.options.overflow != null && !jQuery.support.shrinkWrapBlocks ) { 
    7829                                         var elem = this.elem, 
    7830                                                 options = this.options; 
     8459                                if ( options.overflow != null && !jQuery.support.shrinkWrapBlocks ) { 
    78318460 
    78328461                                        jQuery.each( [ "", "X", "Y" ], function (index, value) { 
    78338462                                                elem.style[ "overflow" + value ] = options.overflow[index]; 
    7834                                         } ); 
     8463                                        }); 
    78358464                                } 
    78368465 
    78378466                                // Hide the element if the "hide" operation was done 
    7838                                 if ( this.options.hide ) { 
    7839                                         jQuery(this.elem).hide(); 
     8467                                if ( options.hide ) { 
     8468                                        jQuery(elem).hide(); 
    78408469                                } 
    78418470 
    78428471                                // Reset the properties, if the item has been hidden or shown 
    7843                                 if ( this.options.hide || this.options.show ) { 
    7844                                         for ( var p in this.options.curAnim ) { 
    7845                                                 jQuery.style( this.elem, p, this.options.orig[p] ); 
     8472                                if ( options.hide || options.show ) { 
     8473                                        for ( var p in options.animatedProperties ) { 
     8474                                                jQuery.style( elem, p, options.orig[p] ); 
    78468475                                        } 
    78478476                                } 
    78488477 
    78498478                                // Execute the complete function 
    7850                                 this.options.complete.call( this.elem ); 
     8479                                options.complete.call( elem ); 
    78518480                        } 
    78528481 
     
    78548483 
    78558484                } else { 
    7856                         var n = t - this.startTime; 
    7857                         this.state = n / this.options.duration; 
    7858  
    7859                         // Perform the easing function, defaults to swing 
    7860                         var specialEasing = this.options.specialEasing && this.options.specialEasing[this.prop]; 
    7861                         var defaultEasing = this.options.easing || (jQuery.easing.swing ? "swing" : "linear"); 
    7862                         this.pos = jQuery.easing[specialEasing || defaultEasing](this.state, n, 0, 1, this.options.duration); 
    7863                         this.now = this.start + ((this.end - this.start) * this.pos); 
    7864  
     8485                        // classical easing cannot be used with an Infinity duration 
     8486                        if ( options.duration == Infinity ) { 
     8487                                this.now = t; 
     8488                        } else { 
     8489                                n = t - this.startTime; 
     8490                                this.state = n / options.duration; 
     8491 
     8492                                // Perform the easing function, defaults to swing 
     8493                                this.pos = jQuery.easing[ options.animatedProperties[ this.prop ] ]( this.state, n, 0, 1, options.duration ); 
     8494                                this.now = this.start + ((this.end - this.start) * this.pos); 
     8495                        } 
    78658496                        // Perform the next step of the animation 
    78668497                        this.update(); 
     
    78738504jQuery.extend( jQuery.fx, { 
    78748505        tick: function() { 
    7875                 var timers = jQuery.timers; 
    7876  
    7877                 for ( var i = 0; i < timers.length; i++ ) { 
     8506                for ( var timers = jQuery.timers, i = 0 ; i < timers.length ; ++i ) { 
    78788507                        if ( !timers[i]() ) { 
    78798508                                timers.splice(i--, 1); 
     
    79238552} 
    79248553 
     8554// Try to restore the default display value of an element 
    79258555function defaultDisplay( nodeName ) { 
     8556 
    79268557        if ( !elemdisplay[ nodeName ] ) { 
    7927                 var elem = jQuery("<" + nodeName + ">").appendTo("body"), 
    7928                         display = elem.css("display"); 
     8558 
     8559                var body = document.body, 
     8560                        elem = jQuery( "<" + nodeName + ">" ).appendTo( body ), 
     8561                        display = elem.css( "display" ); 
    79298562 
    79308563                elem.remove(); 
    79318564 
     8565                // If the simple way fails, 
     8566                // get element's real default display by attaching it to a temp iframe 
    79328567                if ( display === "none" || display === "" ) { 
    7933                         display = "block"; 
    7934                 } 
    7935  
     8568                        // No iframe to use yet, so create it 
     8569                        if ( !iframe ) { 
     8570                                iframe = document.createElement( "iframe" ); 
     8571                                iframe.frameBorder = iframe.width = iframe.height = 0; 
     8572                        } 
     8573 
     8574                        body.appendChild( iframe ); 
     8575 
     8576                        // Create a cacheable copy of the iframe document on first call. 
     8577                        // IE and Opera will allow us to reuse the iframeDoc without re-writing the fake HTML 
     8578                        // document to it; WebKit & Firefox won't allow reusing the iframe document. 
     8579                        if ( !iframeDoc || !iframe.createElement ) { 
     8580                                iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document; 
     8581                                iframeDoc.write( ( document.compatMode === "CSS1Compat" ? "<!doctype html>" : "" ) + "<html><body>" ); 
     8582                                iframeDoc.close(); 
     8583                        } 
     8584 
     8585                        elem = iframeDoc.createElement( nodeName ); 
     8586 
     8587                        iframeDoc.body.appendChild( elem ); 
     8588 
     8589                        display = jQuery.css( elem, "display" ); 
     8590 
     8591                        body.removeChild( iframe ); 
     8592                } 
     8593 
     8594                // Store the correct default display 
    79368595                elemdisplay[ nodeName ] = display; 
    79378596        } 
     
    79808639                        clientTop  = docElem.clientTop  || body.clientTop  || 0, 
    79818640                        clientLeft = docElem.clientLeft || body.clientLeft || 0, 
    7982                         scrollTop  = (win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop  || body.scrollTop ), 
    7983                         scrollLeft = (win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft), 
     8641                        scrollTop  = win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop  || body.scrollTop, 
     8642                        scrollLeft = win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft, 
    79848643                        top  = box.top  + scrollTop  - clientTop, 
    79858644                        left = box.left + scrollLeft - clientLeft; 
     
    80948753 
    80958754                body.removeChild( container ); 
    8096                 body = container = innerDiv = checkDiv = table = td = null; 
    80978755                jQuery.offset.initialize = jQuery.noop; 
    80988756        }, 
     
    81248782                        curCSSTop = jQuery.css( elem, "top" ), 
    81258783                        curCSSLeft = jQuery.css( elem, "left" ), 
    8126                         calculatePosition = (position === "absolute" && jQuery.inArray('auto', [curCSSTop, curCSSLeft]) > -1), 
     8784                        calculatePosition = (position === "absolute" || position === "fixed") && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1, 
    81278785                        props = {}, curPosition = {}, curTop, curLeft; 
    81288786 
    8129                 // need to be able to calculate position if either top or left is auto and position is absolute 
     8787                // need to be able to calculate position if either top or left is auto and position is either absolute or fixed 
    81308788                if ( calculatePosition ) { 
    81318789                        curPosition = curElem.position(); 
    8132                 } 
    8133  
    8134                 curTop  = calculatePosition ? curPosition.top  : parseInt( curCSSTop,  10 ) || 0; 
    8135                 curLeft = calculatePosition ? curPosition.left : parseInt( curCSSLeft, 10 ) || 0; 
     8790                        curTop = curPosition.top; 
     8791                        curLeft = curPosition.left; 
     8792                } else { 
     8793                        curTop = parseFloat( curCSSTop ) || 0; 
     8794                        curLeft = parseFloat( curCSSLeft ) || 0; 
     8795                } 
    81368796 
    81378797                if ( jQuery.isFunction( options ) ) { 
     
    82038863        var method = "scroll" + name; 
    82048864 
    8205         jQuery.fn[ method ] = function(val) { 
    8206                 var elem = this[0], win; 
    8207  
    8208                 if ( !elem ) { 
    8209                         return null; 
    8210                 } 
    8211  
    8212                 if ( val !== undefined ) { 
    8213                         // Set the scroll offset 
    8214                         return this.each(function() { 
    8215                                 win = getWindow( this ); 
    8216  
    8217                                 if ( win ) { 
    8218                                         win.scrollTo( 
    8219                                                 !i ? val : jQuery(win).scrollLeft(), 
    8220                                                 i ? val : jQuery(win).scrollTop() 
    8221                                         ); 
    8222  
    8223                                 } else { 
    8224                                         this[ method ] = val; 
    8225                                 } 
    8226                         }); 
    8227                 } else { 
     8865        jQuery.fn[ method ] = function( val ) { 
     8866                var elem, win; 
     8867 
     8868                if ( val === undefined ) { 
     8869                        elem = this[ 0 ]; 
     8870 
     8871                        if ( !elem ) { 
     8872                                return null; 
     8873                        } 
     8874 
    82288875                        win = getWindow( elem ); 
    82298876 
     
    82348881                                elem[ method ]; 
    82358882                } 
     8883 
     8884                // Set the scroll offset 
     8885                return this.each(function() { 
     8886                        win = getWindow( this ); 
     8887 
     8888                        if ( win ) { 
     8889                                win.scrollTo( 
     8890                                        !i ? val : jQuery( win ).scrollLeft(), 
     8891                                         i ? val : jQuery( win ).scrollTop() 
     8892                                ); 
     8893 
     8894                        } else { 
     8895                                this[ method ] = val; 
     8896                        } 
     8897                }); 
    82368898        }; 
    82378899}); 
     
    82488910 
    82498911 
    8250 // Create innerHeight, innerWidth, outerHeight and outerWidth methods 
     8912// Create width, height, innerHeight, innerWidth, outerHeight and outerWidth methods 
    82518913jQuery.each([ "Height", "Width" ], function( i, name ) { 
    82528914 
     
    82548916 
    82558917        // innerHeight and innerWidth 
    8256         jQuery.fn["inner" + name] = function() { 
    8257                 return this[0] ? 
    8258                         parseFloat( jQuery.css( this[0], type, "padding" ) ) : 
     8918        jQuery.fn[ "inner" + name ] = function() { 
     8919                var elem = this[0]; 
     8920                return elem && elem.style ? 
     8921                        parseFloat( jQuery.css( elem, type, "padding" ) ) : 
    82598922                        null; 
    82608923        }; 
    82618924 
    82628925        // outerHeight and outerWidth 
    8263         jQuery.fn["outer" + name] = function( margin ) { 
    8264                 return this[0] ? 
    8265                         parseFloat( jQuery.css( this[0], type, margin ? "margin" : "border" ) ) : 
     8926        jQuery.fn[ "outer" + name ] = function( margin ) { 
     8927                var elem = this[0]; 
     8928                return elem && elem.style ? 
     8929                        parseFloat( jQuery.css( elem, type, margin ? "margin" : "border" ) ) : 
    82668930                        null; 
    82678931        }; 
     
    83138977 
    83148978 
     8979// Expose jQuery to the global object 
    83158980window.jQuery = window.$ = jQuery; 
    83168981})(window); 
  • trunk/themes/default/js/jquery.min.js

    r9553 r12040  
    11/*! 
    2  * jQuery JavaScript Library v1.5.1 
     2 * jQuery JavaScript Library v1.6.2 
    33 * http://jquery.com/ 
    44 * 
     
    1212 * Released under the MIT, BSD, and GPL Licenses. 
    1313 * 
    14  * Date: Wed Feb 23 13:55:29 2011 -0500 
     14 * Date: Thu Jun 30 14:16:56 2011 -0400 
    1515 */ 
    16 (function(a,b){function cg(a){return d.isWindow(a)?a:a.nodeType===9?a.defaultView||a.parentWindow:!1}function cd(a){if(!bZ[a]){var b=d("<"+a+">").appendTo("body"),c=b.css("display");b.remove();if(c==="none"||c==="")c="block";bZ[a]=c}return bZ[a]}function cc(a,b){var c={};d.each(cb.concat.apply([],cb.slice(0,b)),function(){c[this]=a});return c}function bY(){try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}}function bX(){try{return new a.XMLHttpRequest}catch(b){}}function bW(){d(a).unload(function(){for(var a in bU)bU[a](0,1)})}function bQ(a,c){a.dataFilter&&(c=a.dataFilter(c,a.dataType));var e=a.dataTypes,f={},g,h,i=e.length,j,k=e[0],l,m,n,o,p;for(g=1;g<i;g++){if(g===1)for(h in a.converters)typeof h==="string"&&(f[h.toLowerCase()]=a.converters[h]);l=k,k=e[g];if(k==="*")k=l;else if(l!=="*"&&l!==k){m=l+" "+k,n=f[m]||f["* "+k];if(!n){p=b;for(o in f){j=o.split(" ");if(j[0]===l||j[0]==="*"){p=f[j[1]+" "+k];if(p){o=f[o],o===!0?n=p:p===!0&&(n=o);break}}}}!n&&!p&&d.error("No conversion from "+m.replace(" "," to ")),n!==!0&&(c=n?n(c):p(o(c)))}}return c}function bP(a,c,d){var e=a.contents,f=a.dataTypes,g=a.responseFields,h,i,j,k;for(i in g)i in d&&(c[g[i]]=d[i]);while(f[0]==="*")f.shift(),h===b&&(h=a.mimeType||c.getResponseHeader("content-type"));if(h)for(i in e)if(e[i]&&e[i].test(h)){f.unshift(i);break}if(f[0]in d)j=f[0];else{for(i in d){if(!f[0]||a.converters[i+" "+f[0]]){j=i;break}k||(k=i)}j=j||k}if(j){j!==f[0]&&f.unshift(j);return d[j]}}function bO(a,b,c,e){if(d.isArray(b)&&b.length)d.each(b,function(b,f){c||bq.test(a)?e(a,f):bO(a+"["+(typeof f==="object"||d.isArray(f)?b:"")+"]",f,c,e)});else if(c||b==null||typeof b!=="object")e(a,b);else if(d.isArray(b)||d.isEmptyObject(b))e(a,"");else for(var f in b)bO(a+"["+f+"]",b[f],c,e)}function bN(a,c,d,e,f,g){f=f||c.dataTypes[0],g=g||{},g[f]=!0;var h=a[f],i=0,j=h?h.length:0,k=a===bH,l;for(;i<j&&(k||!l);i++)l=h[i](c,d,e),typeof l==="string"&&(!k||g[l]?l=b:(c.dataTypes.unshift(l),l=bN(a,c,d,e,l,g)));(k||!l)&&!g["*"]&&(l=bN(a,c,d,e,"*",g));return l}function bM(a){return function(b,c){typeof b!=="string"&&(c=b,b="*");if(d.isFunction(c)){var e=b.toLowerCase().split(bB),f=0,g=e.length,h,i,j;for(;f<g;f++)h=e[f],j=/^\+/.test(h),j&&(h=h.substr(1)||"*"),i=a[h]=a[h]||[],i[j?"unshift":"push"](c)}}}function bo(a,b,c){var e=b==="width"?bi:bj,f=b==="width"?a.offsetWidth:a.offsetHeight;if(c==="border")return f;d.each(e,function(){c||(f-=parseFloat(d.css(a,"padding"+this))||0),c==="margin"?f+=parseFloat(d.css(a,"margin"+this))||0:f-=parseFloat(d.css(a,"border"+this+"Width"))||0});return f}function ba(a,b){b.src?d.ajax({url:b.src,async:!1,dataType:"script"}):d.globalEval(b.text||b.textContent||b.innerHTML||""),b.parentNode&&b.parentNode.removeChild(b)}function _(a){return"getElementsByTagName"in a?a.getElementsByTagName("*"):"querySelectorAll"in a?a.querySelectorAll("*"):[]}function $(a,b){if(b.nodeType===1){var c=b.nodeName.toLowerCase();b.clearAttributes(),b.mergeAttributes(a);if(c==="object")b.outerHTML=a.outerHTML;else if(c!=="input"||a.type!=="checkbox"&&a.type!=="radio"){if(c==="option")b.selected=a.defaultSelected;else if(c==="input"||c==="textarea")b.defaultValue=a.defaultValue}else a.checked&&(b.defaultChecked=b.checked=a.checked),b.value!==a.value&&(b.value=a.value);b.removeAttribute(d.expando)}}function Z(a,b){if(b.nodeType===1&&d.hasData(a)){var c=d.expando,e=d.data(a),f=d.data(b,e);if(e=e[c]){var g=e.events;f=f[c]=d.extend({},e);if(g){delete f.handle,f.events={};for(var h in g)for(var i=0,j=g[h].length;i<j;i++)d.event.add(b,h+(g[h][i].namespace?".":"")+g[h][i].namespace,g[h][i],g[h][i].data)}}}}function Y(a,b){return d.nodeName(a,"table")?a.getElementsByTagName("tbody")[0]||a.appendChild(a.ownerDocument.createElement("tbody")):a}function O(a,b,c){if(d.isFunction(b))return d.grep(a,function(a,d){var e=!!b.call(a,d,a);return e===c});if(b.nodeType)return d.grep(a,function(a,d){return a===b===c});if(typeof b==="string"){var e=d.grep(a,function(a){return a.nodeType===1});if(J.test(b))return d.filter(b,e,!c);b=d.filter(b,e)}return d.grep(a,function(a,e){return d.inArray(a,b)>