WordPress.org

Make WordPress Core

Changeset 23421


Ignore:
Timestamp:
02/15/13 16:09:04 (5 years ago)
Author:
nacin
Message:

jQuery 1.9.1 and jQuery Migrate 1.1.0.

Remains uncompressed for now, until we work out all 1.9.x issues.
Fixes custom fields.

props ocean90, wonderboymusic. see #22975.

Location:
trunk/wp-includes
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/wp-includes/js/jquery/jquery-migrate.js

    r23301 r23421  
    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 
     
    1515// Set to true to prevent console output; migrateWarnings still maintained 
    1616// jQuery.migrateMute = false; 
     17 
     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} 
    1727 
    1828// Forget any warnings we've already given; public 
     
    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    } 
     
    6780 
    6881var attrFn = {}, 
    69     attr = jQuery.attr, 
     82    oldAttr = jQuery.attr, 
    7083    valueAttrGet = jQuery.attrHooks.value && jQuery.attrHooks.value.get || 
    7184        function() { return null; }, 
     
    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 ] ) ) { 
     
    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    } 
     
    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" ); 
    135         } 
    136     } 
    137  
    138     return attr.call( jQuery, elem, name, value ); 
     150            migrateWarn( "jQuery.fn.attr('" + lowerName + "') may use property instead of attribute" ); 
     151        } 
     152    } 
     153 
     154    return oldAttr.call( jQuery, elem, name, value ); 
    139155}; 
    140156 
     
    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 ? 
     
    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 
     
    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 
     
    195212}; 
    196213jQuery.fn.init.prototype = jQuery.fn; 
     214 
     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}; 
    197223 
    198224jQuery.uaMatch = function( ua ) { 
     
    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() { 
     
    332357    }; 
    333358} 
    334  
    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 }; 
    363359 
    364360var eventAdd = jQuery.event.add, 
     
    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 
  • trunk/wp-includes/js/jquery/jquery.js

    r23301 r23421  
    11/*! 
    2  * jQuery JavaScript Library v1.9.0 
     2 * jQuery JavaScript Library v1.9.1 
    33 * http://jquery.com/ 
    44 * 
     
    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) 
     
    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 
     
    8695    }, 
    8796 
    88     // The ready event handler and self cleanup method 
    89     DOMContentLoaded = function() { 
     97    // The ready event handler 
     98    completed = function( event ) { 
     99 
     100        // readyState === "complete" is good enough for us to call the dom ready in oldIE 
     101        if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) { 
     102            detach(); 
     103            jQuery.ready(); 
     104        } 
     105    }, 
     106    // Clean-up method for dom ready events 
     107    detach = function() { 
    90108        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             jQuery.ready(); 
     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 ); 
    98115        } 
    99116    }; 
     
    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, 
     
    782799    // arguments. 
    783800    proxy: function( fn, context ) { 
    784         var tmp, args, proxy; 
     801        var args, proxy, tmp; 
    785802 
    786803        if ( typeof context === "string" ) { 
     
    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 
     
    913930                            return setTimeout( doScrollCheck, 50 ); 
    914931                        } 
     932 
     933                        // detach all dom ready events 
     934                        detach(); 
    915935 
    916936                        // and execute any waiting functions 
     
    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 = [], 
     
    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 
     
    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 
     
    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 
     
    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 
     
    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 ) ) { 
     
    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 
     
    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 
     
    17381763        return internalData( elem, name, data, true ); 
    17391764    }, 
    1740      
     1765 
    17411766    _removeData: function( elem, name ) { 
    17421767        return internalRemoveData( elem, name, true ); 
     
    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 
     
    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 ] ); 
     
    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 
     
    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 
     
    21712201 
    21722202    val: function( value ) { 
    2173         var hooks, ret, isFunction, 
     2203        var ret, hooks, isFunction, 
    21742204            elem = this[0]; 
    21752205 
     
    22952325 
    22962326    attr: function( elem, name, value ) { 
    2297         var ret, hooks, notxml, 
     2327        var hooks, notxml, ret, 
    22982328            nType = elem.nodeType; 
    22992329 
     
    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        } 
     
    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            } 
     
    26872717 
    26882718    add: function( elem, types, handler, data, selector ) { 
    2689  
    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  
     2719        var tmp, events, t, handleObjIn, 
     2720            special, eventHandle, handleObj, 
     2721            handlers, type, namespaces, origType, 
     2722            elemData = jQuery._data( elem ); 
     2723 
     2724        // Don't attach events to noData or text/comment nodes (but allow plain objects) 
    26962725        if ( !elemData ) { 
    26972726            return; 
     
    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; 
     
    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 
     
    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; 
     
    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 ), 
     
    30643093 
    30653094    handlers: function( event, handlers ) { 
    3066         var i, matches, sel, handleObj, 
     3095        var sel, handleObj, matches, i, 
    30673096            handlerQueue = [], 
    30683097            delegateCount = handlers.delegateCount, 
     
    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++ ) { 
     
    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 ); 
     
    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; 
     
    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            } 
     
    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 
     
    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}); 
     
    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 
     
    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        } 
     
    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 ); 
     
    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; 
    4297  
    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 ); 
    43014311 
    43024312        // Parentless nodes are either documents or disconnected 
     
    44384448 
    44394449function siblingCheck( a, b ) { 
    4440     var cur = a && b && a.nextSibling; 
    4441  
    4442     for ( ; cur; cur = cur.nextSibling ) { 
    4443         if ( cur === b ) { 
    4444             return -1; 
     4450    var cur = b && a, 
     4451        diff = cur && ( ~b.sourceIndex || MAX_NEGATIVE ) - ( ~a.sourceIndex || MAX_NEGATIVE ); 
     4452 
     4453    // Use IE sourceIndex if available on both nodes 
     4454    if ( diff ) { 
     4455        return diff; 
     4456    } 
     4457 
     4458    // Check if b follows a 
     4459    if ( cur ) { 
     4460        while ( (cur = cur.nextSibling) ) { 
     4461            if ( cur === b ) { 
     4462                return -1; 
     4463            } 
    44454464        } 
    44464465    } 
     
    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            }; 
     
    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 
     
    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 ) { 
     
    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 ); 
     
    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                } 
     
    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 
     
    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; 
     
    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; 
     
    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        }); 
     
    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, 
     
    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 
     
    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 
     
    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 
     
    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 
     
    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, 
     
    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 
     
    65966615    } 
    65976616}); 
    6598 var curCSS, getStyles, iframe, 
     6617var iframe, getStyles, curCSS, 
    65996618    ralpha = /alpha\([^)]*\)/i, 
    66006619    ropacity = /opacity\s*=\s*([^)]*)/, 
     
    66496668 
    66506669function showHide( elements, show ) { 
    6651     var elem, 
     6670    var display, elem, hidden, 
    66526671        values = [], 
    66536672        index = 0, 
     
    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            } 
     
    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    } 
     
    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; 
     
    68376865 
    68386866    css: function( elem, name, extra, styles ) { 
    6839         var val, num, hooks, 
     6867        var num, val, hooks, 
    68406868            origName = jQuery.camelCase( name ); 
    68416869 
     
    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; 
     
    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 
     
    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 
     
    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 
     
    74797524// Fixes #9887 
    74807525function ajaxExtend( target, src ) { 
    7481     var key, deep, 
     7526    var deep, key, 
    74827527        flatOptions = jQuery.ajaxSettings.flatOptions || {}; 
    74837528 
     
    74997544    } 
    75007545 
    7501     var selector, type, response, 
     7546    var selector, response, type, 
    75027547        self = this, 
    75037548        off = url.indexOf(" "); 
     
    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 ), 
     
    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 ); 
     
    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, 
     
    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, 
     
    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 
     
    85128558                                    responses = {}; 
    85138559                                    status = xhr.status; 
    8514                                     xml = xhr.responseXML; 
    85158560                                    responseHeaders = xhr.getAllResponseHeaders(); 
    8516  
    8517                                     // Construct response list 
    8518                                     if ( xml && xml.documentElement /* #4958 */ ) { 
    8519                                         responses.xml = xml; 
    8520                                     } 
    85218561 
    85228562                                    // When requesting binary data, IE6-9 will throw an exception 
     
    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 
     
    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, 
     
    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 ]; 
     
    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; 
     
    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    } 
  • trunk/wp-includes/script-loader.php

    r23417 r23421  
    132132    // jQuery 
    133133    $scripts->add( 'jquery', false, array( 'jquery-core', 'jquery-migrate' ) ); 
    134     $scripts->add( 'jquery-core', '/wp-includes/js/jquery/jquery.js', array(), '1.9.0' ); 
    135     $scripts->add( 'jquery-migrate', '/wp-includes/js/jquery/jquery-migrate.js', array(), '1.0.0' ); 
     134    $scripts->add( 'jquery-core', '/wp-includes/js/jquery/jquery.js', array(), '1.9.1' ); 
     135    $scripts->add( 'jquery-migrate', '/wp-includes/js/jquery/jquery-migrate.js', array(), '1.1.0' ); 
    136136 
    137137    // full jQuery UI 
Note: See TracChangeset for help on using the changeset viewer.