Changeset 12040


Ignore:
Timestamp:
Sep 2, 2011, 9:29:08 PM (9 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)>=0===c})}function N(a){return!a||!a.parentNode||a.parentNode.nodeType===11}function F(a,b){return(a&&a!=="*"?a+".":"")+b.replace(r,"`").replace(s,"&")}function E(a){var b,c,e,f,g,h,i,j,k,l,m,n,o,q=[],r=[],s=d._data(this,"events");if(a.liveFired!==this&&s&&s.live&&!a.target.disabled&&(!a.button||a.type!=="click")){a.namespace&&(n=new RegExp("(^|\\.)"+a.namespace.split(".").join("\\.(?:.*\\.)?")+"(\\.|$)")),a.liveFired=this;var t=s.live.slice(0);for(i=0;i<t.length;i++)g=t[i],g.origType.replace(p,"")===a.type?r.push(g.selector):t.splice(i--,1);f=d(a.target).closest(r,a.currentTarget);for(j=0,k=f.length;j<k;j++){m=f[j];for(i=0;i<t.length;i++){g=t[i];if(m.selector===g.selector&&(!n||n.test(g.namespace))&&!m.elem.disabled){h=m.elem,e=null;if(g.preType==="mouseenter"||g.preType==="mouseleave")a.type=g.preType,e=d(a.relatedTarget).closest(g.selector)[0];(!e||e!==h)&&q.push({elem:h,handleObj:g,level:m.level})}}}for(j=0,k=q.length;j<k;j++){f=q[j];if(c&&f.level>c)break;a.currentTarget=f.elem,a.data=f.handleObj.data,a.handleObj=f.handleObj,o=f.handleObj.origHandler.apply(f.elem,arguments);if(o===!1||a.isPropagationStopped()){c=f.level,o===!1&&(b=!1);if(a.isImmediatePropagationStopped())break}}return b}}function C(a,c,e){var f=d.extend({},e[0]);f.type=a,f.originalEvent={},f.liveFired=b,d.event.handle.call(c,f),f.isDefaultPrevented()&&e[0].preventDefault()}function w(){return!0}function v(){return!1}function g(a){for(var b in a)if(b!=="toJSON")return!1;return!0}function f(a,c,f){if(f===b&&a.nodeType===1){f=a.getAttribute("data-"+c);if(typeof f==="string"){try{f=f==="true"?!0:f==="false"?!1:f==="null"?null:d.isNaN(f)?e.test(f)?d.parseJSON(f):f:parseFloat(f)}catch(g){}d.data(a,c,f)}else f=b}return f}var c=a.document,d=function(){function I(){if(!d.isReady){try{c.documentElement.doScroll("left")}catch(a){setTimeout(I,1);return}d.ready()}}var d=function(a,b){return new d.fn.init(a,b,g)},e=a.jQuery,f=a.$,g,h=/^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/,i=/\S/,j=/^\s+/,k=/\s+$/,l=/\d/,m=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,n=/^[\],:{}\s]*$/,o=/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,p=/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,q=/(?:^|:|,)(?:\s*\[)+/g,r=/(webkit)[ \/]([\w.]+)/,s=/(opera)(?:.*version)?[ \/]([\w.]+)/,t=/(msie) ([\w.]+)/,u=/(mozilla)(?:.*? rv:([\w.]+))?/,v=navigator.userAgent,w,x=!1,y,z="then done fail isResolved isRejected promise".split(" "),A,B=Object.prototype.toString,C=Object.prototype.hasOwnProperty,D=Array.prototype.push,E=Array.prototype.slice,F=String.prototype.trim,G=Array.prototype.indexOf,H={};d.fn=d.prototype={constructor:d,init:function(a,e,f){var g,i,j,k;if(!a)return this;if(a.nodeType){this.context=this[0]=a,this.length=1;return this}if(a==="body"&&!e&&c.body){this.context=c,this[0]=c.body,this.selector="body",this.length=1;return this}if(typeof a==="string"){g=h.exec(a);if(!g||!g[1]&&e)return!e||e.jquery?(e||f).find(a):this.constructor(e).find(a);if(g[1]){e=e instanceof d?e[0]:e,k=e?e.ownerDocument||e:c,j=m.exec(a),j?d.isPlainObject(e)?(a=[c.createElement(j[1])],d.fn.attr.call(a,e,!0)):a=[k.createElement(j[1])]:(j=d.buildFragment([g[1]],[k]),a=(j.cacheable?d.clone(j.fragment):j.fragment).childNodes);return d.merge(this,a)}i=c.getElementById(g[2]);if(i&&i.parentNode){if(i.id!==g[2])return f.find(a);this.length=1,this[0]=i}this.context=c,this.selector=a;return this}if(d.isFunction(a))return f.ready(a);a.selector!==b&&(this.selector=a.selector,this.context=a.context);return d.makeArray(a,this)},selector:"",jquery:"1.5.1",length:0,size:function(){return this.length},toArray:function(){return E.call(this,0)},get:function(a){return a==null?this.toArray():a<0?this[this.length+a]:this[a]},pushStack:function(a,b,c){var e=this.constructor();d.isArray(a)?D.apply(e,a):d.merge(e,a),e.prevObject=this,e.context=this.context,b==="find"?e.selector=this.selector+(this.selector?" ":"")+c:b&&(e.selector=this.selector+"."+b+"("+c+")");return e},each:function(a,b){return d.each(this,a,b)},ready:function(a){d.bindReady(),y.done(a);return this},eq:function(a){return a===-1?this.slice(a):this.slice(a,+a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(E.apply(this,arguments),"slice",E.call(arguments).join(","))},map:function(a){return this.pushStack(d.map(this,function(b,c){return a.call(b,c,b)}))},end:function(){return this.prevObject||this.constructor(null)},push:D,sort:[].sort,splice:[].splice},d.fn.init.prototype=d.fn,d.extend=d.fn.extend=function(){var a,c,e,f,g,h,i=arguments[0]||{},j=1,k=arguments.length,l=!1;typeof i==="boolean"&&(l=i,i=arguments[1]||{},j=2),typeof i!=="object"&&!d.isFunction(i)&&(i={}),k===j&&(i=this,--j);for(;j<k;j++)if((a=arguments[j])!=null)for(c in a){e=i[c],f=a[c];if(i===f)continue;l&&f&&(d.isPlainObject(f)||(g=d.isArray(f)))?(g?(g=!1,h=e&&d.isArray(e)?e:[]):h=e&&d.isPlainObject(e)?e:{},i[c]=d.extend(l,h,f)):f!==b&&(i[c]=f)}return i},d.extend({noConflict:function(b){a.$=f,b&&(a.jQuery=e);return d},isReady:!1,readyWait:1,ready:function(a){a===!0&&d.readyWait--;if(!d.readyWait||a!==!0&&!d.isReady){if(!c.body)return setTimeout(d.ready,1);d.isReady=!0;if(a!==!0&&--d.readyWait>0)return;y.resolveWith(c,[d]),d.fn.trigger&&d(c).trigger("ready").unbind("ready")}},bindReady:function(){if(!x){x=!0;if(c.readyState==="complete")return setTimeout(d.ready,1);if(c.addEventListener)c.addEventListener("DOMContentLoaded",A,!1),a.addEventListener("load",d.ready,!1);else if(c.attachEvent){c.attachEvent("onreadystatechange",A),a.attachEvent("onload",d.ready);var b=!1;try{b=a.frameElement==null}catch(e){}c.documentElement.doScroll&&b&&I()}}},isFunction:function(a){return d.type(a)==="function"},isArray:Array.isArray||function(a){return d.type(a)==="array"},isWindow:function(a){return a&&typeof a==="object"&&"setInterval"in a},isNaN:function(a){return a==null||!l.test(a)||isNaN(a)},type:function(a){return a==null?String(a):H[B.call(a)]||"object"},isPlainObject:function(a){if(!a||d.type(a)!=="object"||a.nodeType||d.isWindow(a))return!1;if(a.constructor&&!C.call(a,"constructor")&&!C.call(a.constructor.prototype,"isPrototypeOf"))return!1;var c;for(c in a){}return c===b||C.call(a,c)},isEmptyObject:function(a){for(var b in a)return!1;return!0},error:function(a){throw a},parseJSON:function(b){if(typeof b!=="string"||!b)return null;b=d.trim(b);if(n.test(b.replace(o,"@").replace(p,"]").replace(q,"")))return a.JSON&&a.JSON.parse?a.JSON.parse(b):(new Function("return "+b))();d.error("Invalid JSON: "+b)},parseXML:function(b,c,e){a.DOMParser?(e=new DOMParser,c=e.parseFromString(b,"text/xml")):(c=new ActiveXObject("Microsoft.XMLDOM"),c.async="false",c.loadXML(b)),e=c.documentElement,(!e||!e.nodeName||e.nodeName==="parsererror")&&d.error("Invalid XML: "+b);return c},noop:function(){},globalEval:function(a){if(a&&i.test(a)){var b=c.head||c.getElementsByTagName("head")[0]||c.documentElement,e=c.createElement("script");d.support.scriptEval()?e.appendChild(c.createTextNode(a)):e.text=a,b.insertBefore(e,b.firstChild),b.removeChild(e)}},nodeName:function(a,b){return a.nodeName&&a.nodeName.toUpperCase()===b.toUpperCase()},each:function(a,c,e){var f,g=0,h=a.length,i=h===b||d.isFunction(a);if(e){if(i){for(f in a)if(c.apply(a[f],e)===!1)break}else for(;g<h;)if(c.apply(a[g++],e)===!1)break}else if(i){for(f in a)if(c.call(a[f],f,a[f])===!1)break}else for(var j=a[0];g<h&&c.call(j,g,j)!==!1;j=a[++g]){}return a},trim:F?function(a){return a==null?"":F.call(a)}:function(a){return a==null?"":(a+"").replace(j,"").replace(k,"")},makeArray:function(a,b){var c=b||[];if(a!=null){var e=d.type(a);a.length==null||e==="string"||e==="function"||e==="regexp"||d.isWindow(a)?D.call(c,a):d.merge(c