WordPress.org

Make WordPress Core

Ticket #24426: 24426.3.patch

File 24426.3.patch, 14.0 KB (added by ocean90, 5 years ago)

1.10.2

  • wp-includes/js/jquery/jquery.js

     
    11/*!
    2  * jQuery JavaScript Library v1.10.1
     2 * jQuery JavaScript Library v1.10.2
    33 * http://jquery.com/
    44 *
    55 * Includes Sizzle.js
     
    99 * Released under the MIT license
    1010 * http://jquery.org/license
    1111 *
    12  * Date: 2013-05-30T21:49Z
     12 * Date: 2013-07-03T13:48Z
    1313 */
    1414(function( window, undefined ) {
    1515
     
    4646        // List of deleted data cache ids, so we can reuse them
    4747        core_deletedIds = [],
    4848
    49         core_version = "1.10.1",
     49        core_version = "1.10.2",
    5050
    5151        // Save a reference to some core methods
    5252        core_concat = core_deletedIds.concat,
     
    10001000// All jQuery objects should point back to these
    10011001rootjQuery = jQuery(document);
    10021002/*!
    1003  * Sizzle CSS Selector Engine v1.9.4-pre
     1003 * Sizzle CSS Selector Engine v1.10.2
    10041004 * http://sizzlejs.com/
    10051005 *
    10061006 * Copyright 2013 jQuery Foundation, Inc. and other contributors
    10071007 * Released under the MIT license
    10081008 * http://jquery.org/license
    10091009 *
    1010  * Date: 2013-05-27
     1010 * Date: 2013-07-03
    10111011 */
    10121012(function( window, undefined ) {
    10131013
     
    10401040        tokenCache = createCache(),
    10411041        compilerCache = createCache(),
    10421042        hasDuplicate = false,
    1043         sortOrder = function() { return 0; },
     1043        sortOrder = function( a, b ) {
     1044                if ( a === b ) {
     1045                        hasDuplicate = true;
     1046                        return 0;
     1047                }
     1048                return 0;
     1049        },
    10441050
    10451051        // General-purpose constants
    10461052        strundefined = typeof undefined,
     
    12841290}
    12851291
    12861292/**
    1287  * For feature detection
    1288  * @param {Function} fn The function to test for native support
    1289  */
    1290 function isNative( fn ) {
    1291         return rnative.test( fn + "" );
    1292 }
    1293 
    1294 /**
    12951293 * Create key-value caches of limited size
    12961294 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
    12971295 *      property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
     
    13441342/**
    13451343 * Adds the same handler for all of the specified attrs
    13461344 * @param {String} attrs Pipe-separated list of attributes
    1347  * @param {Function} handler The method that will be applied if the test fails
    1348  * @param {Boolean} test The result of a test. If true, null will be set as the handler in leiu of the specified handler
     1345 * @param {Function} handler The method that will be applied
    13491346 */
    1350 function addHandle( attrs, handler, test ) {
    1351         attrs = attrs.split("|");
    1352         var current,
    1353                 i = attrs.length,
    1354                 setHandle = test ? null : handler;
     1347function addHandle( attrs, handler ) {
     1348        var arr = attrs.split("|"),
     1349                i = attrs.length;
    13551350
    13561351        while ( i-- ) {
    1357                 // Don't override a user's handler
    1358                 if ( !(current = Expr.attrHandle[ attrs[i] ]) || current === handler ) {
    1359                         Expr.attrHandle[ attrs[i] ] = setHandle;
    1360                 }
     1352                Expr.attrHandle[ arr[i] ] = handler;
    13611353        }
    13621354}
    13631355
    13641356/**
    1365  * Fetches boolean attributes by node
    1366  * @param {Element} elem
    1367  * @param {String} name
    1368  */
    1369 function boolHandler( elem, name ) {
    1370         // XML does not need to be checked as this will not be assigned for XML documents
    1371         var val = elem.getAttributeNode( name );
    1372         return val && val.specified ?
    1373                 val.value :
    1374                 elem[ name ] === true ? name.toLowerCase() : null;
    1375 }
    1376 
    1377 /**
    1378  * Fetches attributes without interpolation
    1379  * http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
    1380  * @param {Element} elem
    1381  * @param {String} name
    1382  */
    1383 function interpolationHandler( elem, name ) {
    1384         // XML does not need to be checked as this will not be assigned for XML documents
    1385         return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
    1386 }
    1387 
    1388 /**
    1389  * Uses defaultValue to retrieve value in IE6/7
    1390  * @param {Element} elem
    1391  * @param {String} name
    1392  */
    1393 function valueHandler( elem ) {
    1394         // Ignore the value *property* on inputs by using defaultValue
    1395         // Fallback to Sizzle.attr by returning undefined where appropriate
    1396         // XML does not need to be checked as this will not be assigned for XML documents
    1397         if ( elem.nodeName.toLowerCase() === "input" ) {
    1398                 return elem.defaultValue;
    1399         }
    1400 }
    1401 
    1402 /**
    14031357 * Checks document order of two siblings
    14041358 * @param {Element} a
    14051359 * @param {Element} b
    1406  * @returns Returns -1 if a precedes b, 1 if a follows b
     1360 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
    14071361 */
    14081362function siblingCheck( a, b ) {
    14091363        var cur = b && a,
     
    14931447 */
    14941448setDocument = Sizzle.setDocument = function( node ) {
    14951449        var doc = node ? node.ownerDocument || node : preferredDoc,
    1496                 parent = doc.parentWindow;
     1450                parent = doc.defaultView;
    14971451
    14981452        // If no document and documentElement is available, return
    14991453        if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
     
    15101464        // Support: IE>8
    15111465        // If iframe document is assigned to "document" variable and if iframe has been reloaded,
    15121466        // IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
    1513         if ( parent && parent.frameElement ) {
     1467        // IE6-8 do not support the defaultView property so parent will be undefined
     1468        if ( parent && parent.attachEvent && parent !== parent.top ) {
    15141469                parent.attachEvent( "onbeforeunload", function() {
    15151470                        setDocument();
    15161471                });
     
    15221477        // Support: IE<8
    15231478        // Verify that getAttribute really returns attributes and not properties (excepting IE8 booleans)
    15241479        support.attributes = assert(function( div ) {
    1525 
    1526                 // Support: IE<8
    1527                 // Prevent attribute/property "interpolation"
    1528                 div.innerHTML = "<a href='#'></a>";
    1529                 addHandle( "type|href|height|width", interpolationHandler, div.firstChild.getAttribute("href") === "#" );
    1530 
    1531                 // Support: IE<9
    1532                 // Use getAttributeNode to fetch booleans when getAttribute lies
    1533                 addHandle( booleans, boolHandler, div.getAttribute("disabled") == null );
    1534 
    15351480                div.className = "i";
    15361481                return !div.getAttribute("className");
    15371482        });
    15381483
    1539         // Support: IE<9
    1540         // Retrieving value should defer to defaultValue
    1541         support.input = assert(function( div ) {
    1542                 div.innerHTML = "<input>";
    1543                 div.firstChild.setAttribute( "value", "" );
    1544                 return div.firstChild.getAttribute( "value" ) === "";
    1545         });
    1546 
    1547         // IE6/7 still return empty string for value,
    1548         // but are actually retrieving the property
    1549         addHandle( "value", valueHandler, support.attributes && support.input );
    1550 
    15511484        /* getElement(s)By*
    15521485        ---------------------------------------------------------------------- */
    15531486
     
    16561589        // See http://bugs.jquery.com/ticket/13378
    16571590        rbuggyQSA = [];
    16581591
    1659         if ( (support.qsa = isNative(doc.querySelectorAll)) ) {
     1592        if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {
    16601593                // Build QSA regex
    16611594                // Regex strategy adopted from Diego Perini
    16621595                assert(function( div ) {
     
    17081641                });
    17091642        }
    17101643
    1711         if ( (support.matchesSelector = isNative( (matches = docElem.webkitMatchesSelector ||
     1644        if ( (support.matchesSelector = rnative.test( (matches = docElem.webkitMatchesSelector ||
    17121645                docElem.mozMatchesSelector ||
    17131646                docElem.oMatchesSelector ||
    17141647                docElem.msMatchesSelector) )) ) {
     
    17341667        // Element contains another
    17351668        // Purposefully does not implement inclusive descendent
    17361669        // As in, an element does not contain itself
    1737         contains = isNative(docElem.contains) || docElem.compareDocumentPosition ?
     1670        contains = rnative.test( docElem.contains ) || docElem.compareDocumentPosition ?
    17381671                function( a, b ) {
    17391672                        var adown = a.nodeType === 9 ? a.documentElement : a,
    17401673                                bup = b && b.parentNode;
     
    17581691        /* Sorting
    17591692        ---------------------------------------------------------------------- */
    17601693
    1761         // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
    1762         // Detached nodes confoundingly follow *each other*
    1763         support.sortDetached = assert(function( div1 ) {
    1764                 // Should return 1, but returns 4 (following)
    1765                 return div1.compareDocumentPosition( doc.createElement("div") ) & 1;
    1766         });
    1767 
    17681694        // Document order sorting
    17691695        sortOrder = docElem.compareDocumentPosition ?
    17701696        function( a, b ) {
     
    19071833
    19081834        var fn = Expr.attrHandle[ name.toLowerCase() ],
    19091835                // Don't get fooled by Object.prototype properties (jQuery #13807)
    1910                 val = ( fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
     1836                val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
    19111837                        fn( elem, name, !documentIsHTML ) :
    1912                         undefined );
     1838                        undefined;
    19131839
    19141840        return val === undefined ?
    19151841                support.attributes || !documentIsHTML ?
     
    24542380        }
    24552381};
    24562382
     2383Expr.pseudos["nth"] = Expr.pseudos["eq"];
     2384
    24572385// Add button/input type pseudos
    24582386for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
    24592387        Expr.pseudos[ i ] = createInputPseudo( i );
     
    24622390        Expr.pseudos[ i ] = createButtonPseudo( i );
    24632391}
    24642392
     2393// Easy API for creating new setFilters
     2394function setFilters() {}
     2395setFilters.prototype = Expr.filters = Expr.pseudos;
     2396Expr.setFilters = new setFilters();
     2397
    24652398function tokenize( selector, parseOnly ) {
    24662399        var matched, match, tokens, type,
    24672400                soFar, groups, preFilters,
     
    29732906        return results;
    29742907}
    29752908
    2976 // Deprecated
    2977 Expr.pseudos["nth"] = Expr.pseudos["eq"];
    2978 
    2979 // Easy API for creating new setFilters
    2980 function setFilters() {}
    2981 setFilters.prototype = Expr.filters = Expr.pseudos;
    2982 Expr.setFilters = new setFilters();
    2983 
    29842909// One-time assignments
    29852910
    29862911// Sort stability
    29872912support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
    29882913
     2914// Support: Chrome<14
     2915// Always assume duplicates if they aren't passed to the comparison function
     2916support.detectDuplicates = hasDuplicate;
     2917
    29892918// Initialize against the default document
    29902919setDocument();
    29912920
    2992 // Support: Chrome<<14
    2993 // Always assume duplicates if they aren't passed to the comparison function
    2994 [0, 0].sort( sortOrder );
    2995 support.detectDuplicates = hasDuplicate;
     2921// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
     2922// Detached nodes confoundingly follow *each other*
     2923support.sortDetached = assert(function( div1 ) {
     2924        // Should return 1, but returns 4 (following)
     2925        return div1.compareDocumentPosition( document.createElement("div") ) & 1;
     2926});
    29962927
     2928// Support: IE<8
     2929// Prevent attribute/property "interpolation"
     2930// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
     2931if ( !assert(function( div ) {
     2932        div.innerHTML = "<a href='#'></a>";
     2933        return div.firstChild.getAttribute("href") === "#" ;
     2934}) ) {
     2935        addHandle( "type|href|height|width", function( elem, name, isXML ) {
     2936                if ( !isXML ) {
     2937                        return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
     2938                }
     2939        });
     2940}
     2941
     2942// Support: IE<9
     2943// Use defaultValue in place of getAttribute("value")
     2944if ( !support.attributes || !assert(function( div ) {
     2945        div.innerHTML = "<input/>";
     2946        div.firstChild.setAttribute( "value", "" );
     2947        return div.firstChild.getAttribute( "value" ) === "";
     2948}) ) {
     2949        addHandle( "value", function( elem, name, isXML ) {
     2950                if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
     2951                        return elem.defaultValue;
     2952                }
     2953        });
     2954}
     2955
     2956// Support: IE<9
     2957// Use getAttributeNode to fetch booleans when getAttribute lies
     2958if ( !assert(function( div ) {
     2959        return div.getAttribute("disabled") == null;
     2960}) ) {
     2961        addHandle( booleans, function( elem, name, isXML ) {
     2962                var val;
     2963                if ( !isXML ) {
     2964                        return (val = elem.getAttributeNode( name )) && val.specified ?
     2965                                val.value :
     2966                                elem[ name ] === true ? name.toLowerCase() : null;
     2967                }
     2968        });
     2969}
     2970
    29972971jQuery.find = Sizzle;
    29982972jQuery.expr = Sizzle.selectors;
    29992973jQuery.expr[":"] = jQuery.expr.pseudos;
     
    31773151                        },
    31783152                        // Call all callbacks with the given context and arguments
    31793153                        fireWith: function( context, args ) {
    3180                                 args = args || [];
    3181                                 args = [ context, args.slice ? args.slice() : args ];
    31823154                                if ( list && ( !fired || stack ) ) {
     3155                                        args = args || [];
     3156                                        args = [ context, args.slice ? args.slice() : args ];
    31833157                                        if ( firing ) {
    31843158                                                stack.push( args );
    31853159                                        } else {
     
    41834157        },
    41844158
    41854159        toggleClass: function( value, stateVal ) {
    4186                 var type = typeof value,
    4187                         isBool = typeof stateVal === "boolean";
     4160                var type = typeof value;
    41884161
     4162                if ( typeof stateVal === "boolean" && type === "string" ) {
     4163                        return stateVal ? this.addClass( value ) : this.removeClass( value );
     4164                }
     4165
    41894166                if ( jQuery.isFunction( value ) ) {
    41904167                        return this.each(function( i ) {
    41914168                                jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
     
    41984175                                var className,
    41994176                                        i = 0,
    42004177                                        self = jQuery( this ),
    4201                                         state = stateVal,
    42024178                                        classNames = value.match( core_rnotwhite ) || [];
    42034179
    42044180                                while ( (className = classNames[ i++ ]) ) {
    42054181                                        // check each className given, space separated list
    4206                                         state = isBool ? state : !self.hasClass( className );
    4207                                         self[ state ? "addClass" : "removeClass" ]( className );
     4182                                        if ( self.hasClass( className ) ) {
     4183                                                self.removeClass( className );
     4184                                        } else {
     4185                                                self.addClass( className );
     4186                                        }
    42084187                                }
    42094188
    42104189                        // Toggle whole class name
     
    69486927                return showHide( this );
    69496928        },
    69506929        toggle: function( state ) {
    6951                 var bool = typeof state === "boolean";
     6930                if ( typeof state === "boolean" ) {
     6931                        return state ? this.show() : this.hide();
     6932                }
    69526933
    69536934                return this.each(function() {
    6954                         if ( bool ? state : isHidden( this ) ) {
     6935                        if ( isHidden( this ) ) {
    69556936                                jQuery( this ).show();
    69566937                        } else {
    69576938                                jQuery( this ).hide();
     
    69826963                "fontWeight": true,
    69836964                "lineHeight": true,
    69846965                "opacity": true,
     6966                "order": true,
    69856967                "orphans": true,
    69866968                "widows": true,
    69876969                "zIndex": true,
  • wp-includes/script-loader.php

     
    132132        $scripts->add( 'cropper', '/wp-includes/js/crop/cropper.js', array('scriptaculous-dragdrop') );
    133133
    134134        // jQuery
    135         $scripts->add( 'jquery', false, array( 'jquery-core', 'jquery-migrate' ), '1.10.1' );
    136         $scripts->add( 'jquery-core', '/wp-includes/js/jquery/jquery.js', array(), '1.10.1' );
     135        $scripts->add( 'jquery', false, array( 'jquery-core', 'jquery-migrate' ), '1.10.2' );
     136        $scripts->add( 'jquery-core', '/wp-includes/js/jquery/jquery.js', array(), '1.10.2' );
    137137        $scripts->add( 'jquery-migrate', '/wp-includes/js/jquery/jquery-migrate.js', array(), '1.2.1' );
    138138
    139139        // full jQuery UI