Make WordPress Core

Ticket #22975: jquery.1.9.1.diff

File jquery.1.9.1.diff, 41.5 KB (added by wonderboymusic, 9 years ago)
  • wp-includes/js/jquery/jquery-migrate.js

    diff --git wp-includes/js/jquery/jquery-migrate.js wp-includes/js/jquery/jquery-migrate.js
    index 27111d8..3185ed1 100644
     
    11/*!
    2  * jQuery Migrate - v1.0.0 - 2013-01-14
     2 * jQuery Migrate - v1.1.0 - 2013-01-31
    33 * https://github.com/jquery/jquery-migrate
    44 * Copyright 2005, 2013 jQuery Foundation, Inc. and other contributors; Licensed MIT
    55 */
    jQuery.migrateWarnings = []; 
    1515// Set to true to prevent console output; migrateWarnings still maintained
    1616// jQuery.migrateMute = false;
    1717
     18// Show a message on the console so devs know we're active
     19if ( !jQuery.migrateMute && window.console && console.log ) {
     20        console.log("JQMIGRATE: Logging is active");
     21}
     22
     23// Set to false to disable traces that appear with warnings
     24if ( jQuery.migrateTrace === undefined ) {
     25        jQuery.migrateTrace = true;
     26}
     27
    1828// Forget any warnings we've already given; public
    1929jQuery.migrateReset = function() {
    2030        warnedAbout = {};
    function migrateWarn( msg) { 
    2737                jQuery.migrateWarnings.push( msg );
    2838                if ( window.console && console.warn && !jQuery.migrateMute ) {
    2939                        console.warn( "JQMIGRATE: " + msg );
     40                        if ( jQuery.migrateTrace && console.trace ) {
     41                                console.trace();
     42                        }
    3043                }
    3144        }
    3245}
    if ( document.compatMode === "BackCompat" ) { 
    6679
    6780
    6881var attrFn = {},
    69         attr = jQuery.attr,
     82        oldAttr = jQuery.attr,
    7083        valueAttrGet = jQuery.attrHooks.value && jQuery.attrHooks.value.get ||
    7184                function() { return null; },
    7285        valueAttrSet = jQuery.attrHooks.value && jQuery.attrHooks.value.set ||
    jQuery.attr = function( elem, name, value, pass ) { 
    8396        var lowerName = name.toLowerCase(),
    8497                nType = elem && elem.nodeType;
    8598
    86         if ( pass ) {
     99        // Since pass is used internally, we only warn and shim for new jQuery
     100        // versions where there isn't a pass arg in the formal params
     101        if ( pass && oldAttr.length < 4 ) {
    87102                migrateWarn("jQuery.fn.attr( props, pass ) is deprecated");
    88103                if ( elem && !rnoAttrNodeType.test( nType ) && jQuery.isFunction( jQuery.fn[ name ] ) ) {
    89104                        return jQuery( elem )[ name ]( value );
    90105                }
    91106        }
    92107
    93         // Warn if user tries to set `type` since it breaks on IE 6/7/8
    94         if ( name === "type" && value !== undefined && rnoType.test( elem.nodeName ) ) {
     108        // Warn if user tries to set `type`, since it breaks on IE 6/7/8; by checking
     109        // for disconnected elements we don't warn on $( "<button>", { type: "button" } ).
     110        if ( name === "type" && value !== undefined && rnoType.test( elem.nodeName ) && elem.parentNode ) {
    95111                migrateWarn("Can't change the 'type' of an input or button in IE 6/7/8");
    96112        }
    97113
    jQuery.attr = function( elem, name, value, pass ) { 
    131147
    132148                // Warn only for attributes that can remain distinct from their properties post-1.9
    133149                if ( ruseDefault.test( lowerName ) ) {
    134                         migrateWarn( "jQuery.fn.attr(" + lowerName + ") may use property instead of attribute" );
     150                        migrateWarn( "jQuery.fn.attr('" + lowerName + "') may use property instead of attribute" );
    135151                }
    136152        }
    137153
    138         return attr.call( jQuery, elem, name, value );
     154        return oldAttr.call( jQuery, elem, name, value );
    139155};
    140156
    141157// attrHooks: value
    jQuery.attrHooks.value = { 
    146162                        return valueAttrGet.apply( this, arguments );
    147163                }
    148164                if ( nodeName !== "input" && nodeName !== "option" ) {
    149                         migrateWarn("property-based jQuery.fn.attr('value') is deprecated");
     165                        migrateWarn("jQuery.fn.attr('value') no longer gets properties");
    150166                }
    151167                return name in elem ?
    152168                        elem.value :
    jQuery.attrHooks.value = { 
    158174                        return valueAttrSet.apply( this, arguments );
    159175                }
    160176                if ( nodeName !== "input" && nodeName !== "option" ) {
    161                         migrateWarn("property-based jQuery.fn.attr('value', val) is deprecated");
     177                        migrateWarn("jQuery.fn.attr('value', val) no longer sets properties");
    162178                }
    163179                // Does not return so that setAttribute is also used
    164180                elem.value = value;
    jQuery.attrHooks.value = { 
    168184
    169185var matched, browser,
    170186        oldInit = jQuery.fn.init,
    171         // Note this does NOT include the # XSS fix from 1.7!
    172         rquickExpr = /^(?:.*(<[\w\W]+>)[^>]*|#([\w\-]*))$/;
     187        oldParseJSON = jQuery.parseJSON,
     188        // Note this does NOT include the #9521 XSS fix from 1.7!
     189        rquickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*|#([\w\-]*))$/;
    173190
    174191// $(html) "looks like html" rule change
    175192jQuery.fn.init = function( selector, context, rootjQuery ) {
    jQuery.fn.init = function( selector, context, rootjQuery ) { 
    195212};
    196213jQuery.fn.init.prototype = jQuery.fn;
    197214
     215// Let $.parseJSON(falsy_value) return null
     216jQuery.parseJSON = function( json ) {
     217        if ( !json && json !== null ) {
     218                migrateWarn("jQuery.parseJSON requires a valid JSON string");
     219                return null;
     220        }
     221        return oldParseJSON.apply( this, arguments );
     222};
     223
    198224jQuery.uaMatch = function( ua ) {
    199225        ua = ua.toLowerCase();
    200226
    jQuery.fn.data = function( name ) { 
    274300
    275301
    276302var rscriptType = /\/(java|ecma)script/i,
    277         oldSelf = jQuery.fn.andSelf || jQuery.fn.addBack,
    278         oldFragment = jQuery.buildFragment;
     303        oldSelf = jQuery.fn.andSelf || jQuery.fn.addBack;
    279304
    280305jQuery.fn.andSelf = function() {
    281306        migrateWarn("jQuery.fn.andSelf() replaced by jQuery.fn.addBack()");
    if ( !jQuery.clean ) { 
    332357        };
    333358}
    334359
    335 jQuery.buildFragment = function( elems, context, scripts, selection ) {
    336         var ret,
    337                 warning = "jQuery.buildFragment() is deprecated";
    338 
    339         // Set context per 1.8 logic
    340         context = context || document;
    341         context = !context.nodeType && context[0] || context;
    342         context = context.ownerDocument || context;
    343 
    344         try {
    345                 ret = oldFragment.call( jQuery, elems, context, scripts, selection );
    346 
    347         // jQuery < 1.8 required arrayish context; jQuery 1.9 fails on it
    348         } catch( x ) {
    349                 ret = oldFragment.call( jQuery, elems, context.nodeType ? [ context ] : context[ 0 ], scripts, selection );
    350 
    351                 // Success from tweaking context means buildFragment was called by the user
    352                 migrateWarn( warning );
    353         }
    354 
    355         // jQuery < 1.9 returned an object instead of the fragment itself
    356         if ( !ret.fragment ) {
    357                 migrateWarnProp( ret, "fragment", ret, warning );
    358                 migrateWarnProp( ret, "cacheable", false, warning );
    359         }
    360 
    361         return ret;
    362 };
    363 
    364360var eventAdd = jQuery.event.add,
    365361        eventRemove = jQuery.event.remove,
    366362        eventTrigger = jQuery.event.trigger,
    if ( jQuery.event.props && jQuery.event.props[ 0 ] !== "attrChange" ) { 
    386382}
    387383
    388384// Undocumented jQuery.event.handle was "deprecated" in jQuery 1.7
    389 migrateWarnProp( jQuery.event, "handle", jQuery.event.dispatch, "jQuery.event.handle is undocumented and deprecated" );
     385if ( jQuery.event.dispatch ) {
     386        migrateWarnProp( jQuery.event, "handle", jQuery.event.dispatch, "jQuery.event.handle is undocumented and deprecated" );
     387}
    390388
    391389// Support for 'hover' pseudo-event and ajax event warnings
    392390jQuery.event.add = function( elem, types, handler, data, selector ){
    jQuery.each( ajaxEvents.split("|"), 
    495493);
    496494
    497495
    498 })( jQuery, window );
     496})( jQuery, window );
     497 No newline at end of file
  • wp-includes/js/jquery/jquery.js

    diff --git wp-includes/js/jquery/jquery.js wp-includes/js/jquery/jquery.js
    index 840e179..a569f12 100644
     
    11/*!
    2  * jQuery JavaScript Library v1.9.0
     2 * jQuery JavaScript Library v1.9.1
    33 * http://jquery.com/
    44 *
    55 * Includes Sizzle.js
     
    99 * Released under the MIT license
    1010 * http://jquery.org/license
    1111 *
    12  * Date: 2013-1-14
     12 * Date: 2013-2-4
    1313 */
    1414(function( window, undefined ) {
    15 "use strict";
     15
     16// Can't do this because several apps including ASP.NET trace
     17// the stack via arguments.caller.callee and Firefox dies if
     18// you try to trace through "use strict" call chains. (#13335)
     19// Support: Firefox 18+
     20//"use strict";
    1621var
     22        // The deferred used on DOM ready
     23        readyList,
     24
    1725        // A central reference to the root jQuery(document)
    1826        rootjQuery,
    1927
    20         // The deferred used on DOM ready
    21         readyList,
     28        // Support: IE<9
     29        // For `typeof node.method` instead of `node.method !== undefined`
     30        core_strundefined = typeof undefined,
    2231
    2332        // Use the correct document accordingly with window argument (sandbox)
    2433        document = window.document,
    var 
    3645        // List of deleted data cache ids, so we can reuse them
    3746        core_deletedIds = [],
    3847
    39         core_version = "1.9.0",
     48        core_version = "1.9.1",
    4049
    4150        // Save a reference to some core methods
    4251        core_concat = core_deletedIds.concat,
    var 
    8594                return letter.toUpperCase();
    8695        },
    8796
    88         // The ready event handler and self cleanup method
    89         DOMContentLoaded = function() {
    90                 if ( document.addEventListener ) {
    91                         document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
    92                         jQuery.ready();
    93                 } else if ( document.readyState === "complete" ) {
    94                         // we're here because readyState === "complete" in oldIE
    95                         // which is good enough for us to call the dom ready!
    96                         document.detachEvent( "onreadystatechange", DOMContentLoaded );
     97        // The ready event handler
     98        completed = function( event ) {
     99
     100                // readyState === "complete" is good enough for us to call the dom ready in oldIE
     101                if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) {
     102                        detach();
    97103                        jQuery.ready();
    98104                }
     105        },
     106        // Clean-up method for dom ready events
     107        detach = function() {
     108                if ( document.addEventListener ) {
     109                        document.removeEventListener( "DOMContentLoaded", completed, false );
     110                        window.removeEventListener( "load", completed, false );
     111
     112                } else {
     113                        document.detachEvent( "onreadystatechange", completed );
     114                        window.detachEvent( "onload", completed );
     115                }
    99116        };
    100117
    101118jQuery.fn = jQuery.prototype = {
    jQuery.fn = jQuery.prototype = { 
    299316jQuery.fn.init.prototype = jQuery.fn;
    300317
    301318jQuery.extend = jQuery.fn.extend = function() {
    302         var options, name, src, copy, copyIsArray, clone,
     319        var src, copyIsArray, copy, name, options, clone,
    303320                target = arguments[0] || {},
    304321                i = 1,
    305322                length = arguments.length,
    jQuery.extend({ 
    781798        // Bind a function to a context, optionally partially applying any
    782799        // arguments.
    783800        proxy: function( fn, context ) {
    784                 var tmp, args, proxy;
     801                var args, proxy, tmp;
    785802
    786803                if ( typeof context === "string" ) {
    787804                        tmp = fn[ context ];
    jQuery.ready.promise = function( obj ) { 
    880897                // Standards-based browsers support DOMContentLoaded
    881898                } else if ( document.addEventListener ) {
    882899                        // Use the handy event callback
    883                         document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
     900                        document.addEventListener( "DOMContentLoaded", completed, false );
    884901
    885902                        // A fallback to window.onload, that will always work
    886                         window.addEventListener( "load", jQuery.ready, false );
     903                        window.addEventListener( "load", completed, false );
    887904
    888905                // If IE event model is used
    889906                } else {
    890907                        // Ensure firing before onload, maybe late but safe also for iframes
    891                         document.attachEvent( "onreadystatechange", DOMContentLoaded );
     908                        document.attachEvent( "onreadystatechange", completed );
    892909
    893910                        // A fallback to window.onload, that will always work
    894                         window.attachEvent( "onload", jQuery.ready );
     911                        window.attachEvent( "onload", completed );
    895912
    896913                        // If IE and not a frame
    897914                        // continually check to see if the document is ready
    jQuery.ready.promise = function( obj ) { 
    913930                                                        return setTimeout( doScrollCheck, 50 );
    914931                                                }
    915932
     933                                                // detach all dom ready events
     934                                                detach();
     935
    916936                                                // and execute any waiting functions
    917937                                                jQuery.ready();
    918938                                        }
    jQuery.Callbacks = function( options ) { 
    9891009                ( optionsCache[ options ] || createOptions( options ) ) :
    9901010                jQuery.extend( {}, options );
    9911011
    992         var // Last fire value (for non-forgettable lists)
     1012        var // Flag to know if list is currently firing
     1013                firing,
     1014                // Last fire value (for non-forgettable lists)
    9931015                memory,
    9941016                // Flag to know if list was already fired
    9951017                fired,
    996                 // Flag to know if list is currently firing
    997                 firing,
    998                 // First callback to fire (used internally by add and fireWith)
    999                 firingStart,
    10001018                // End of the loop when firing
    10011019                firingLength,
    10021020                // Index of currently firing callback (modified by remove if needed)
    10031021                firingIndex,
     1022                // First callback to fire (used internally by add and fireWith)
     1023                firingStart,
    10041024                // Actual callback list
    10051025                list = [],
    10061026                // Stack of fire calls for repeatable lists
    jQuery.Callbacks = function( options ) { 
    10861106                                }
    10871107                                return this;
    10881108                        },
    1089                         // Control if a given callback is in the list
     1109                        // Check if a given callback is in the list.
     1110                        // If no argument is given, return whether or not list has callbacks attached.
    10901111                        has: function( fn ) {
    1091                                 return jQuery.inArray( fn, list ) > -1;
     1112                                return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );
    10921113                        },
    10931114                        // Remove all callbacks from the list
    10941115                        empty: function() {
    jQuery.extend({ 
    12851306});
    12861307jQuery.support = (function() {
    12871308
    1288         var support, all, a, select, opt, input, fragment, eventName, isSupported, i,
     1309        var support, all, a,
     1310                input, select, fragment,
     1311                opt, eventName, isSupported, i,
    12891312                div = document.createElement("div");
    12901313
    12911314        // Setup
    jQuery.support = (function() { 
    14861509                                !parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight );
    14871510                }
    14881511
    1489                 if ( typeof div.style.zoom !== "undefined" ) {
     1512                if ( typeof div.style.zoom !== core_strundefined ) {
    14901513                        // Support: IE<8
    14911514                        // Check if natively block-level elements act like inline-block
    14921515                        // elements when setting their display to 'inline' and giving
    jQuery.support = (function() { 
    15021525                        div.firstChild.style.width = "5px";
    15031526                        support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
    15041527
    1505                         // Prevent IE 6 from affecting layout for positioned elements #11048
    1506                         // Prevent IE from shrinking the body in IE 7 mode #12869
    1507                         body.style.zoom = 1;
     1528                        if ( support.inlineBlockNeedsLayout ) {
     1529                                // Prevent IE 6 from affecting layout for positioned elements #11048
     1530                                // Prevent IE from shrinking the body in IE 7 mode #12869
     1531                                // Support: IE<8
     1532                                body.style.zoom = 1;
     1533                        }
    15081534                }
    15091535
    15101536                body.removeChild( container );
    jQuery.support = (function() { 
    15211547
    15221548var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
    15231549        rmultiDash = /([A-Z])/g;
    1524        
     1550
    15251551function internalData( elem, name, data, pvt /* Internal Use Only */ ){
    15261552        if ( !jQuery.acceptData( elem ) ) {
    15271553                return;
    function internalData( elem, name, data, pvt /* Internal Use Only */ ){ 
    16161642        return ret;
    16171643}
    16181644
    1619 function internalRemoveData( elem, name, pvt /* For internal use only */ ){
     1645function internalRemoveData( elem, name, pvt ) {
    16201646        if ( !jQuery.acceptData( elem ) ) {
    16211647                return;
    16221648        }
    16231649
    1624         var thisCache, i, l,
    1625 
     1650        var i, l, thisCache,
    16261651                isNode = elem.nodeType,
    16271652
    16281653                // See jQuery.data for more information
    jQuery.extend({ 
    17261751        },
    17271752
    17281753        data: function( elem, name, data ) {
    1729                 return internalData( elem, name, data, false );
     1754                return internalData( elem, name, data );
    17301755        },
    17311756
    17321757        removeData: function( elem, name ) {
    1733                 return internalRemoveData( elem, name, false );
     1758                return internalRemoveData( elem, name );
    17341759        },
    17351760
    17361761        // For internal use only.
    17371762        _data: function( elem, name, data ) {
    17381763                return internalData( elem, name, data, true );
    17391764        },
    1740        
     1765
    17411766        _removeData: function( elem, name ) {
    17421767                return internalRemoveData( elem, name, true );
    17431768        },
    17441769
    17451770        // A method for determining if a DOM node can handle the data expando
    17461771        acceptData: function( elem ) {
     1772                // Do not set data on non-element because it will not be cleared (#8335).
     1773                if ( elem.nodeType && elem.nodeType !== 1 && elem.nodeType !== 9 ) {
     1774                        return false;
     1775                }
     1776
    17471777                var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ];
    17481778
    17491779                // nodes accept data unless otherwise specified; rejection can be conditional
    jQuery.fn.extend({ 
    17691799                                                name = attrs[i].name;
    17701800
    17711801                                                if ( !name.indexOf( "data-" ) ) {
    1772                                                         name = jQuery.camelCase( name.substring(5) );
     1802                                                        name = jQuery.camelCase( name.slice(5) );
    17731803
    17741804                                                        dataAttr( elem, name, data[ name ] );
    17751805                                                }
    function dataAttr( elem, key, data ) { 
    18201850                if ( typeof data === "string" ) {
    18211851                        try {
    18221852                                data = data === "true" ? true :
    1823                                 data === "false" ? false :
    1824                                 data === "null" ? null :
    1825                                 // Only convert to a number if it doesn't change the string
    1826                                 +data + "" === data ? +data :
    1827                                 rbrace.test( data ) ? jQuery.parseJSON( data ) :
    1828                                         data;
     1853                                        data === "false" ? false :
     1854                                        data === "null" ? null :
     1855                                        // Only convert to a number if it doesn't change the string
     1856                                        +data + "" === data ? +data :
     1857                                        rbrace.test( data ) ? jQuery.parseJSON( data ) :
     1858                                                data;
    18291859                        } catch( e ) {}
    18301860
    18311861                        // Make sure we set the data so it isn't changed later
    jQuery.fn.extend({ 
    21412171                                }
    21422172
    21432173                        // Toggle whole class name
    2144                         } else if ( type === "undefined" || type === "boolean" ) {
     2174                        } else if ( type === core_strundefined || type === "boolean" ) {
    21452175                                if ( this.className ) {
    21462176                                        // store className if set
    21472177                                        jQuery._data( this, "__className__", this.className );
    jQuery.fn.extend({ 
    21702200        },
    21712201
    21722202        val: function( value ) {
    2173                 var hooks, ret, isFunction,
     2203                var ret, hooks, isFunction,
    21742204                        elem = this[0];
    21752205
    21762206                if ( !arguments.length ) {
    jQuery.extend({ 
    22942324        },
    22952325
    22962326        attr: function( elem, name, value ) {
    2297                 var ret, hooks, notxml,
     2327                var hooks, notxml, ret,
    22982328                        nType = elem.nodeType;
    22992329
    23002330                // don't get/set attributes on text, comment and attribute nodes
    jQuery.extend({ 
    23032333                }
    23042334
    23052335                // Fallback to prop when attributes are not supported
    2306                 if ( typeof elem.getAttribute === "undefined" ) {
     2336                if ( typeof elem.getAttribute === core_strundefined ) {
    23072337                        return jQuery.prop( elem, name, value );
    23082338                }
    23092339
    jQuery.extend({ 
    23362366
    23372367                        // In IE9+, Flash objects don't have .getAttribute (#12945)
    23382368                        // Support: IE9+
    2339                         if ( typeof elem.getAttribute !== "undefined" ) {
     2369                        if ( typeof elem.getAttribute !== core_strundefined ) {
    23402370                                ret =  elem.getAttribute( name );
    23412371                        }
    23422372
    jQuery.event = { 
    26862716        global: {},
    26872717
    26882718        add: function( elem, types, handler, data, selector ) {
     2719                var tmp, events, t, handleObjIn,
     2720                        special, eventHandle, handleObj,
     2721                        handlers, type, namespaces, origType,
     2722                        elemData = jQuery._data( elem );
    26892723
    2690                 var handleObjIn, eventHandle, tmp,
    2691                         events, t, handleObj,
    2692                         special, handlers, type, namespaces, origType,
    2693                         // Don't attach events to noData or text/comment nodes (but allow plain objects)
    2694                         elemData = elem.nodeType !== 3 && elem.nodeType !== 8 && jQuery._data( elem );
    2695 
     2724                // Don't attach events to noData or text/comment nodes (but allow plain objects)
    26962725                if ( !elemData ) {
    26972726                        return;
    26982727                }
    jQuery.event = { 
    27172746                        eventHandle = elemData.handle = function( e ) {
    27182747                                // Discard the second event of a jQuery.event.trigger() and
    27192748                                // when an event is called after a page has unloaded
    2720                                 return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
     2749                                return typeof jQuery !== core_strundefined && (!e || jQuery.event.triggered !== e.type) ?
    27212750                                        jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
    27222751                                        undefined;
    27232752                        };
    jQuery.event = { 
    27972826
    27982827        // Detach an event or set of events from an element
    27992828        remove: function( elem, types, handler, selector, mappedTypes ) {
    2800 
    2801                 var j, origCount, tmp,
    2802                         events, t, handleObj,
    2803                         special, handlers, type, namespaces, origType,
     2829                var j, handleObj, tmp,
     2830                        origCount, t, events,
     2831                        special, handlers, type,
     2832                        namespaces, origType,
    28042833                        elemData = jQuery.hasData( elem ) && jQuery._data( elem );
    28052834
    28062835                if ( !elemData || !(events = elemData.events) ) {
    jQuery.event = { 
    28702899        },
    28712900
    28722901        trigger: function( event, data, elem, onlyHandlers ) {
    2873 
    2874                 var i, cur, tmp, bubbleType, ontype, handle, special,
     2902                var handle, ontype, cur,
     2903                        bubbleType, special, tmp, i,
    28752904                        eventPath = [ elem || document ],
    2876                         type = event.type || event,
    2877                         namespaces = event.namespace ? event.namespace.split(".") : [];
     2905                        type = core_hasOwn.call( event, "type" ) ? event.type : event,
     2906                        namespaces = core_hasOwn.call( event, "namespace" ) ? event.namespace.split(".") : [];
    28782907
    28792908                cur = tmp = elem = elem || document;
    28802909
    jQuery.event = { 
    30083037                // Make a writable jQuery.Event from the native event object
    30093038                event = jQuery.event.fix( event );
    30103039
    3011                 var i, j, ret, matched, handleObj,
     3040                var i, ret, handleObj, matched, j,
    30123041                        handlerQueue = [],
    30133042                        args = core_slice.call( arguments ),
    30143043                        handlers = ( jQuery._data( this, "events" ) || {} )[ event.type ] || [],
    jQuery.event = { 
    30633092        },
    30643093
    30653094        handlers: function( event, handlers ) {
    3066                 var i, matches, sel, handleObj,
     3095                var sel, handleObj, matches, i,
    30673096                        handlerQueue = [],
    30683097                        delegateCount = handlers.delegateCount,
    30693098                        cur = event.target;
    jQuery.event = { 
    30753104
    30763105                        for ( ; cur != this; cur = cur.parentNode || this ) {
    30773106
     3107                                // Don't check non-elements (#13208)
    30783108                                // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
    3079                                 if ( cur.disabled !== true || event.type !== "click" ) {
     3109                                if ( cur.nodeType === 1 && (cur.disabled !== true || event.type !== "click") ) {
    30803110                                        matches = [];
    30813111                                        for ( i = 0; i < delegateCount; i++ ) {
    30823112                                                handleObj = handlers[ i ];
    jQuery.event = { 
    31143144                }
    31153145
    31163146                // Create a writable copy of the event object and normalize some properties
    3117                 var i, prop,
     3147                var i, prop, copy,
     3148                        type = event.type,
    31183149                        originalEvent = event,
    3119                         fixHook = jQuery.event.fixHooks[ event.type ] || {},
    3120                         copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
     3150                        fixHook = this.fixHooks[ type ];
     3151
     3152                if ( !fixHook ) {
     3153                        this.fixHooks[ type ] = fixHook =
     3154                                rmouseEvent.test( type ) ? this.mouseHooks :
     3155                                rkeyEvent.test( type ) ? this.keyHooks :
     3156                                {};
     3157                }
     3158                copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
    31213159
    31223160                event = new jQuery.Event( originalEvent );
    31233161
    jQuery.event = { 
    31673205        mouseHooks: {
    31683206                props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
    31693207                filter: function( event, original ) {
    3170                         var eventDoc, doc, body,
     3208                        var body, eventDoc, doc,
    31713209                                button = original.button,
    31723210                                fromElement = original.fromElement;
    31733211
    jQuery.removeEvent = document.removeEventListener ? 
    32833321
    32843322                        // #8545, #7054, preventing memory leaks for custom events in IE6-8
    32853323                        // detachEvent needed property on element, by name of that event, to properly expose it to GC
    3286                         if ( typeof elem[ name ] === "undefined" ) {
     3324                        if ( typeof elem[ name ] === core_strundefined ) {
    32873325                                elem[ name ] = null;
    32883326                        }
    32893327
    if ( !jQuery.support.focusinBubbles ) { 
    35323570jQuery.fn.extend({
    35333571
    35343572        on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
    3535                 var origFn, type;
     3573                var type, origFn;
    35363574
    35373575                // Types can be a map of types/handlers
    35383576                if ( typeof types === "object" ) {
    jQuery.fn.extend({ 
    36443682                if ( elem ) {
    36453683                        return jQuery.event.trigger( type, data, elem, true );
    36463684                }
    3647         },
    3648 
    3649         hover: function( fnOver, fnOut ) {
    3650                 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
    3651         }
    3652 });
    3653 
    3654 jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
    3655         "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
    3656         "change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
    3657 
    3658         // Handle event binding
    3659         jQuery.fn[ name ] = function( data, fn ) {
    3660                 return arguments.length > 0 ?
    3661                         this.on( name, null, data, fn ) :
    3662                         this.trigger( name );
    3663         };
    3664 
    3665         if ( rkeyEvent.test( name ) ) {
    3666                 jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks;
    3667         }
    3668 
    3669         if ( rmouseEvent.test( name ) ) {
    3670                 jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks;
    36713685        }
    36723686});
    36733687/*!
    var i, 
    37813795
    37823796        rsibling = /[\x20\t\r\n\f]*[+~]/,
    37833797
    3784         rnative = /\{\s*\[native code\]\s*\}/,
     3798        rnative = /^[^{]+\{\s*\[native code/,
    37853799
    37863800        // Easily-parseable/retrievable ID or TAG or CLASS selectors
    37873801        rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
    var i, 
    38083822
    38093823// Use a stripped-down slice if we can't use a native one
    38103824try {
    3811         slice.call( docElem.childNodes, 0 )[0].nodeType;
     3825        slice.call( preferredDoc.documentElement.childNodes, 0 )[0].nodeType;
    38123826} catch ( e ) {
    38133827        slice = function( i ) {
    38143828                var elem,
    38153829                        results = [];
    3816                 for ( ; (elem = this[i]); i++ ) {
     3830                while ( (elem = this[i++]) ) {
    38173831                        results.push( elem );
    38183832                }
    38193833                return results;
    setDocument = Sizzle.setDocument = function( node ) { 
    41324146
    41334147                        // Filter out possible comments
    41344148                        if ( tag === "*" ) {
    4135                                 for ( ; (elem = results[i]); i++ ) {
     4149                                while ( (elem = results[i++]) ) {
    41364150                                        if ( elem.nodeType === 1 ) {
    41374151                                                tmp.push( elem );
    41384152                                        }
    setDocument = Sizzle.setDocument = function( node ) { 
    42904304                        ap = [ a ],
    42914305                        bp = [ b ];
    42924306
    4293                 // The nodes are identical, we can exit early
     4307                // Exit early if the nodes are identical
    42944308                if ( a === b ) {
    42954309                        hasDuplicate = true;
    42964310                        return 0;
    42974311
    4298                 // Fallback to using sourceIndex (in IE) if it's available on both nodes
    4299                 } else if ( a.sourceIndex && b.sourceIndex ) {
    4300                         return ( ~b.sourceIndex || MAX_NEGATIVE ) - ( contains( preferredDoc, a ) && ~a.sourceIndex || MAX_NEGATIVE );
    4301 
    43024312                // Parentless nodes are either documents or disconnected
    43034313                } else if ( !aup || !bup ) {
    43044314                        return a === doc ? -1 :
    Sizzle.uniqueSort = function( results ) { 
    44374447};
    44384448
    44394449function siblingCheck( a, b ) {
    4440         var cur = a && b && a.nextSibling;
     4450        var cur = b && a,
     4451                diff = cur && ( ~b.sourceIndex || MAX_NEGATIVE ) - ( ~a.sourceIndex || MAX_NEGATIVE );
    44414452
    4442         for ( ; cur; cur = cur.nextSibling ) {
    4443                 if ( cur === b ) {
    4444                         return -1;
     4453        // Use IE sourceIndex if available on both nodes
     4454        if ( diff ) {
     4455                return diff;
     4456        }
     4457
     4458        // Check if b follows a
     4459        if ( cur ) {
     4460                while ( (cur = cur.nextSibling) ) {
     4461                        if ( cur === b ) {
     4462                                return -1;
     4463                        }
    44454464                }
    44464465        }
    44474466
    Expr = Sizzle.selectors = { 
    46514670                                        operator === "!=" ? result !== check :
    46524671                                        operator === "^=" ? check && result.indexOf( check ) === 0 :
    46534672                                        operator === "*=" ? check && result.indexOf( check ) > -1 :
    4654                                         operator === "$=" ? check && result.substr( result.length - check.length ) === check :
     4673                                        operator === "$=" ? check && result.slice( -check.length ) === check :
    46554674                                        operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
    4656                                         operator === "|=" ? result === check || result.substr( 0, check.length + 1 ) === check + "-" :
     4675                                        operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
    46574676                                        false;
    46584677                        };
    46594678                },
    function toSelector( tokens ) { 
    50715090
    50725091function addCombinator( matcher, combinator, base ) {
    50735092        var dir = combinator.dir,
    5074                 checkNonElements = base && combinator.dir === "parentNode",
     5093                checkNonElements = base && dir === "parentNode",
    50755094                doneName = done++;
    50765095
    50775096        return combinator.first ?
    function matcherFromGroupMatchers( elementMatchers, setMatchers ) { 
    53145333                                contextBackup = outermostContext,
    53155334                                // We must always have either seed elements or context
    53165335                                elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ),
    5317                                 // Nested matchers should use non-integer dirruns
    5318                                 dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.E);
     5336                                // Use integer dirruns iff this is the outermost matcher
     5337                                dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1);
    53195338
    53205339                        if ( outermost ) {
    53215340                                outermostContext = context !== document && context;
    function matcherFromGroupMatchers( elementMatchers, setMatchers ) { 
    53235342                        }
    53245343
    53255344                        // Add elements passing elementMatchers directly to results
     5345                        // Keep `i` a string if there are no elements so `matchedCount` will be "00" below
    53265346                        for ( ; (elem = elems[i]) != null; i++ ) {
    53275347                                if ( byElement && elem ) {
    5328                                         for ( j = 0; (matcher = elementMatchers[j]); j++ ) {
     5348                                        j = 0;
     5349                                        while ( (matcher = elementMatchers[j++]) ) {
    53295350                                                if ( matcher( elem, context, xml ) ) {
    53305351                                                        results.push( elem );
    53315352                                                        break;
    function matcherFromGroupMatchers( elementMatchers, setMatchers ) { 
    53525373                        }
    53535374
    53545375                        // Apply set filters to unmatched elements
    5355                         // `i` starts as a string, so matchedCount would equal "00" if there are no elements
    53565376                        matchedCount += i;
    53575377                        if ( bySet && i !== matchedCount ) {
    5358                                 for ( j = 0; (matcher = setMatchers[j]); j++ ) {
     5378                                j = 0;
     5379                                while ( (matcher = setMatchers[j++]) ) {
    53595380                                        matcher( unmatched, setMatched, context, xml );
    53605381                                }
    53615382
    function select( selector, context, results, seed ) { 
    54575478                        }
    54585479
    54595480                        // Fetch a seed set for right-to-left matching
    5460                         for ( i = matchExpr["needsContext"].test( selector ) ? -1 : tokens.length - 1; i >= 0; i-- ) {
     5481                        i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
     5482                        while ( i-- ) {
    54615483                                token = tokens[i];
    54625484
    54635485                                // Abort if we hit a combinator
    var runtil = /Until$/, 
    55355557
    55365558jQuery.fn.extend({
    55375559        find: function( selector ) {
    5538                 var i, ret, self;
     5560                var i, ret, self,
     5561                        len = this.length;
    55395562
    55405563                if ( typeof selector !== "string" ) {
    55415564                        self = this;
    55425565                        return this.pushStack( jQuery( selector ).filter(function() {
    5543                                 for ( i = 0; i < self.length; i++ ) {
     5566                                for ( i = 0; i < len; i++ ) {
    55445567                                        if ( jQuery.contains( self[ i ], this ) ) {
    55455568                                                return true;
    55465569                                        }
    jQuery.fn.extend({ 
    55495572                }
    55505573
    55515574                ret = [];
    5552                 for ( i = 0; i < this.length; i++ ) {
     5575                for ( i = 0; i < len; i++ ) {
    55535576                        jQuery.find( selector, this[ i ], ret );
    55545577                }
    55555578
    55565579                // Needed because $( selector, context ) becomes $( context ).find( selector )
    5557                 ret = this.pushStack( jQuery.unique( ret ) );
     5580                ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );
    55585581                ret.selector = ( this.selector ? this.selector + " " : "" ) + selector;
    55595582                return ret;
    55605583        },
    jQuery.fn.extend({ 
    60666089                        var next = this.nextSibling,
    60676090                                parent = this.parentNode;
    60686091
    6069                         if ( parent && this.nodeType === 1 || this.nodeType === 11 ) {
    6070 
     6092                        if ( parent ) {
    60716093                                jQuery( this ).remove();
    6072 
    6073                                 if ( next ) {
    6074                                         next.parentNode.insertBefore( elem, next );
    6075                                 } else {
    6076                                         parent.appendChild( elem );
    6077                                 }
     6094                                parent.insertBefore( elem, next );
    60786095                        }
    60796096                });
    60806097        },
    jQuery.fn.extend({ 
    60886105                // Flatten any nested arrays
    60896106                args = core_concat.apply( [], args );
    60906107
    6091                 var fragment, first, scripts, hasScripts, node, doc,
     6108                var first, node, hasScripts,
     6109                        scripts, doc, fragment,
    60926110                        i = 0,
    60936111                        l = this.length,
    60946112                        set = this,
    function cloneCopyEvent( src, dest ) { 
    62396257}
    62406258
    62416259function fixCloneNodeIssues( src, dest ) {
    6242         var nodeName, data, e;
     6260        var nodeName, e, data;
    62436261
    62446262        // We do not need to do anything for non-Elements
    62456263        if ( dest.nodeType !== 1 ) {
    jQuery.each({ 
    63346352function getAll( context, tag ) {
    63356353        var elems, elem,
    63366354                i = 0,
    6337                 found = typeof context.getElementsByTagName !== "undefined" ? context.getElementsByTagName( tag || "*" ) :
    6338                         typeof context.querySelectorAll !== "undefined" ? context.querySelectorAll( tag || "*" ) :
     6355                found = typeof context.getElementsByTagName !== core_strundefined ? context.getElementsByTagName( tag || "*" ) :
     6356                        typeof context.querySelectorAll !== core_strundefined ? context.querySelectorAll( tag || "*" ) :
    63396357                        undefined;
    63406358
    63416359        if ( !found ) {
    function fixDefaultChecked( elem ) { 
    63626380
    63636381jQuery.extend({
    63646382        clone: function( elem, dataAndEvents, deepDataAndEvents ) {
    6365                 var destElements, srcElements, node, i, clone,
     6383                var destElements, node, clone, i, srcElements,
    63666384                        inPage = jQuery.contains( elem.ownerDocument, elem );
    63676385
    63686386                if ( jQuery.support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test( "<" + elem.nodeName + ">" ) ) {
    jQuery.extend({ 
    64176435        },
    64186436
    64196437        buildFragment: function( elems, context, scripts, selection ) {
    6420                 var contains, elem, tag, tmp, wrap, tbody, j,
     6438                var j, elem, contains,
     6439                        tmp, tag, tbody, wrap,
    64216440                        l = elems.length,
    64226441
    64236442                        // Ensure a safe fragment
    jQuery.extend({ 
    65436562        },
    65446563
    65456564        cleanData: function( elems, /* internal */ acceptData ) {
    6546                 var data, id, elem, type,
     6565                var elem, type, id, data,
    65476566                        i = 0,
    65486567                        internalKey = jQuery.expando,
    65496568                        cache = jQuery.cache,
    jQuery.extend({ 
    65816600                                                if ( deleteExpando ) {
    65826601                                                        delete elem[ internalKey ];
    65836602
    6584                                                 } else if ( typeof elem.removeAttribute !== "undefined" ) {
     6603                                                } else if ( typeof elem.removeAttribute !== core_strundefined ) {
    65856604                                                        elem.removeAttribute( internalKey );
    65866605
    65876606                                                } else {
    jQuery.extend({ 
    65956614                }
    65966615        }
    65976616});
    6598 var curCSS, getStyles, iframe,
     6617var iframe, getStyles, curCSS,
    65996618        ralpha = /alpha\([^)]*\)/i,
    66006619        ropacity = /opacity\s*=\s*([^)]*)/,
    66016620        rposition = /^(top|right|bottom|left)$/,
    function isHidden( elem, el ) { 
    66486667}
    66496668
    66506669function showHide( elements, show ) {
    6651         var elem,
     6670        var display, elem, hidden,
    66526671                values = [],
    66536672                index = 0,
    66546673                length = elements.length;
    function showHide( elements, show ) { 
    66586677                if ( !elem.style ) {
    66596678                        continue;
    66606679                }
     6680
    66616681                values[ index ] = jQuery._data( elem, "olddisplay" );
     6682                display = elem.style.display;
    66626683                if ( show ) {
    66636684                        // Reset the inline display of this element to learn if it is
    66646685                        // being hidden by cascaded rules or not
    6665                         if ( !values[ index ] && elem.style.display === "none" ) {
     6686                        if ( !values[ index ] && display === "none" ) {
    66666687                                elem.style.display = "";
    66676688                        }
    66686689
    function showHide( elements, show ) { 
    66726693                        if ( elem.style.display === "" && isHidden( elem ) ) {
    66736694                                values[ index ] = jQuery._data( elem, "olddisplay", css_defaultDisplay(elem.nodeName) );
    66746695                        }
    6675                 } else if ( !values[ index ] && !isHidden( elem ) ) {
    6676                         jQuery._data( elem, "olddisplay", jQuery.css( elem, "display" ) );
     6696                } else {
     6697
     6698                        if ( !values[ index ] ) {
     6699                                hidden = isHidden( elem );
     6700
     6701                                if ( display && display !== "none" || !hidden ) {
     6702                                        jQuery._data( elem, "olddisplay", hidden ? display : jQuery.css( elem, "display" ) );
     6703                                }
     6704                        }
    66776705                }
    66786706        }
    66796707
    function showHide( elements, show ) { 
    66956723jQuery.fn.extend({
    66966724        css: function( name, value ) {
    66976725                return jQuery.access( this, function( elem, name, value ) {
    6698                         var styles, len,
     6726                        var len, styles,
    66996727                                map = {},
    67006728                                i = 0;
    67016729
    jQuery.extend({ 
    68366864        },
    68376865
    68386866        css: function( elem, name, extra, styles ) {
    6839                 var val, num, hooks,
     6867                var num, val, hooks,
    68406868                        origName = jQuery.camelCase( name );
    68416869
    68426870                // Make sure that we're working with the right name
    jQuery.extend({ 
    68626890                }
    68636891
    68646892                // Return, converting to number if forced or a qualifier was provided and val looks numeric
    6865                 if ( extra ) {
     6893                if ( extra === "" || extra ) {
    68666894                        num = parseFloat( val );
    68676895                        return extra === true || jQuery.isNumeric( num ) ? num || 0 : val;
    68686896                }
    jQuery(function() { 
    72277255
    72287256if ( jQuery.expr && jQuery.expr.filters ) {
    72297257        jQuery.expr.filters.hidden = function( elem ) {
    7230                 return ( elem.offsetWidth === 0 && elem.offsetHeight === 0 ) || (!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || jQuery.css( elem, "display" )) === "none");
     7258                // Support: Opera <= 12.12
     7259                // Opera reports offsetWidths and offsetHeights less than zero on some elements
     7260                return elem.offsetWidth <= 0 && elem.offsetHeight <= 0 ||
     7261                        (!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || jQuery.css( elem, "display" )) === "none");
    72317262        };
    72327263
    72337264        jQuery.expr.filters.visible = function( elem ) {
    jQuery.each({ 
    72657296var r20 = /%20/g,
    72667297        rbracket = /\[\]$/,
    72677298        rCRLF = /\r?\n/g,
    7268         rsubmitterTypes = /^(?:submit|button|image|reset)$/i,
     7299        rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
    72697300        rsubmittable = /^(?:input|select|textarea|keygen)/i;
    72707301
    72717302jQuery.fn.extend({
    function buildParams( prefix, obj, traditional, add ) { 
    73617392                add( prefix, obj );
    73627393        }
    73637394}
     7395jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
     7396        "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
     7397        "change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
     7398
     7399        // Handle event binding
     7400        jQuery.fn[ name ] = function( data, fn ) {
     7401                return arguments.length > 0 ?
     7402                        this.on( name, null, data, fn ) :
     7403                        this.trigger( name );
     7404        };
     7405});
     7406
     7407jQuery.fn.hover = function( fnOver, fnOut ) {
     7408        return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
     7409};
    73647410var
    73657411        // Document location
    73667412        ajaxLocParts,
    73677413        ajaxLocation,
    7368        
    73697414        ajax_nonce = jQuery.now(),
    73707415
    73717416        ajax_rquery = /\?/,
    function inspectPrefiltersOrTransports( structure, options, originalOptions, jqX 
    74787523// that takes "flat" options (not to be deep extended)
    74797524// Fixes #9887
    74807525function ajaxExtend( target, src ) {
    7481         var key, deep,
     7526        var deep, key,
    74827527                flatOptions = jQuery.ajaxSettings.flatOptions || {};
    74837528
    74847529        for ( key in src ) {
    jQuery.fn.load = function( url, params, callback ) { 
    74987543                return _load.apply( this, arguments );
    74997544        }
    75007545
    7501         var selector, type, response,
     7546        var selector, response, type,
    75027547                self = this,
    75037548                off = url.indexOf(" ");
    75047549
    jQuery.extend({ 
    76797724                // Force options to be an object
    76807725                options = options || {};
    76817726
    7682                 var transport,
     7727                var // Cross-domain detection vars
     7728                        parts,
     7729                        // Loop variable
     7730                        i,
    76837731                        // URL without anti-cache param
    76847732                        cacheURL,
    7685                         // Response headers
     7733                        // Response headers as string
    76867734                        responseHeadersString,
    7687                         responseHeaders,
    76887735                        // timeout handle
    76897736                        timeoutTimer,
    7690                         // Cross-domain detection vars
    7691                         parts,
     7737
    76927738                        // To know if global events are to be dispatched
    76937739                        fireGlobals,
    7694                         // Loop variable
    7695                         i,
     7740
     7741                        transport,
     7742                        // Response headers
     7743                        responseHeaders,
    76967744                        // Create the final options object
    76977745                        s = jQuery.ajaxSetup( {}, options ),
    76987746                        // Callbacks context
    jQuery.extend({ 
    79878035                                        }
    79888036                                }
    79898037
    7990                                 // If not modified
    7991                                 if ( status === 304 ) {
     8038                                // if no content
     8039                                if ( status === 204 ) {
     8040                                        isSuccess = true;
     8041                                        statusText = "nocontent";
     8042
     8043                                // if not modified
     8044                                } else if ( status === 304 ) {
    79928045                                        isSuccess = true;
    79938046                                        statusText = "notmodified";
    79948047
    7995                                 // If we have data
     8048                                // If we have data, let's convert it
    79968049                                } else {
    79978050                                        isSuccess = ajaxConvert( s, response );
    79988051                                        statusText = isSuccess.state;
    jQuery.extend({ 
    80628115 * - returns the corresponding response
    80638116 */
    80648117function ajaxHandleResponses( s, jqXHR, responses ) {
    8065 
    8066         var ct, type, finalDataType, firstDataType,
     8118        var firstDataType, ct, finalDataType, type,
    80678119                contents = s.contents,
    80688120                dataTypes = s.dataTypes,
    80698121                responseFields = s.responseFields;
    function ajaxHandleResponses( s, jqXHR, responses ) { 
    81248176
    81258177// Chain conversions given the request and the original response
    81268178function ajaxConvert( s, response ) {
    8127 
    8128         var conv, conv2, current, tmp,
     8179        var conv2, current, conv, tmp,
    81298180                converters = {},
    81308181                i = 0,
    81318182                // Work with a copy of dataTypes in case we need to modify it for conversion
    if ( xhrSupported ) { 
    84768527
    84778528                                        // Listener
    84788529                                        callback = function( _, isAbort ) {
    8479 
    8480                                                 var status,
    8481                                                         statusText,
    8482                                                         responseHeaders,
    8483                                                         responses,
    8484                                                         xml;
     8530                                                var status, responseHeaders, statusText, responses;
    84858531
    84868532                                                // Firefox throws exceptions when accessing properties
    84878533                                                // of an xhr when a network error occurred
    if ( xhrSupported ) { 
    85118557                                                                } else {
    85128558                                                                        responses = {};
    85138559                                                                        status = xhr.status;
    8514                                                                         xml = xhr.responseXML;
    85158560                                                                        responseHeaders = xhr.getAllResponseHeaders();
    85168561
    8517                                                                         // Construct response list
    8518                                                                         if ( xml && xml.documentElement /* #4958 */ ) {
    8519                                                                                 responses.xml = xml;
    8520                                                                         }
    8521 
    85228562                                                                        // When requesting binary data, IE6-9 will throw an exception
    85238563                                                                        // on any attempt to access responseText (#11426)
    85248564                                                                        if ( typeof xhr.responseText === "string" ) {
    function Animation( elem, properties, options ) { 
    87688808}
    87698809
    87708810function propFilter( props, specialEasing ) {
    8771         var index, name, easing, value, hooks;
     8811        var value, name, index, easing, hooks;
    87728812
    87738813        // camelCase, specialEasing and expand cssHook pass
    87748814        for ( index in props ) {
    jQuery.Animation = jQuery.extend( Animation, { 
    88368876
    88378877function defaultPrefilter( elem, props, opts ) {
    88388878        /*jshint validthis:true */
    8839         var index, prop, value, length, dataShow, toggle, tween, hooks, oldfire,
     8879        var prop, index, length,
     8880                value, dataShow, toggle,
     8881                tween, hooks, oldfire,
    88408882                anim = this,
    88418883                style = elem.style,
    88428884                orig = {},
    function defaultPrefilter( elem, props, opts ) { 
    88968938        if ( opts.overflow ) {
    88978939                style.overflow = "hidden";
    88988940                if ( !jQuery.support.shrinkWrapBlocks ) {
    8899                         anim.done(function() {
     8941                        anim.always(function() {
    89008942                                style.overflow = opts.overflow[ 0 ];
    89018943                                style.overflowX = opts.overflow[ 1 ];
    89028944                                style.overflowY = opts.overflow[ 2 ];
    Tween.propHooks = { 
    90209062                                return tween.elem[ tween.prop ];
    90219063                        }
    90229064
    9023                         // passing a non empty string as a 3rd parameter to .css will automatically
     9065                        // passing an empty string as a 3rd parameter to .css will automatically
    90249066                        // attempt a parseFloat and fallback to a string if the parse fails
    90259067                        // so, simple values such as "10px" are parsed to Float.
    90269068                        // complex values such as "rotate(1rad)" are returned as is.
    9027                         result = jQuery.css( tween.elem, tween.prop, "auto" );
     9069                        result = jQuery.css( tween.elem, tween.prop, "" );
    90289070                        // Empty strings, null, undefined and "auto" are converted to 0.
    90299071                        return !result || result === "auto" ? 0 : result;
    90309072                },
    jQuery.fn.offset = function( options ) { 
    93469388
    93479389        // If we don't have gBCR, just use 0,0 rather than error
    93489390        // BlackBerry 5, iOS 3 (original iPhone)
    9349         if ( typeof elem.getBoundingClientRect !== "undefined" ) {
     9391        if ( typeof elem.getBoundingClientRect !== core_strundefined ) {
    93509392                box = elem.getBoundingClientRect();
    93519393        }
    93529394        win = getWindow( doc );