WordPress.org

Make WordPress Core

Ticket #22975: 22975.rc1.patch

File 22975.rc1.patch, 42.5 KB (added by ocean90, 9 years ago)
  • wp-includes/js/jquery/jquery.js

     
    11/*!
    2  * jQuery JavaScript Library v1.9.0b1
     2 * jQuery JavaScript Library v1.9.0rc1
    33 * http://jquery.com/
    44 *
    55 * Includes Sizzle.js
     
    99 * Released under the MIT license
    1010 * http://jquery.org/license
    1111 *
    12  * Date: 2012-12-16
     12 * Date: 2013-1-8
    1313 */
    1414(function( window, undefined ) {
    1515"use strict";
     
    3636        // List of deleted data cache ids, so we can reuse them
    3737        core_deletedIds = [],
    3838
    39         core_version = "1.9.0b1",
     39        core_version = "1.9.0rc1",
    4040
    4141        // Save a reference to some core methods
    4242        core_concat = core_deletedIds.concat,
     
    111111                        return this;
    112112                }
    113113
    114                 // HANDLE: $(DOMElement)
    115                 if ( selector.nodeType ) {
    116                         this.context = this[0] = selector;
    117                         this.length = 1;
    118                         return this;
    119                 }
    120 
    121114                // Handle HTML strings
    122115                if ( typeof selector === "string" ) {
    123116                        if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
     
    191184                                return this.constructor( context ).find( selector );
    192185                        }
    193186
     187                // HANDLE: $(DOMElement)
     188                } else if ( selector.nodeType ) {
     189                        this.context = this[0] = selector;
     190                        this.length = 1;
     191                        return this;
     192
    194193                // HANDLE: $(function)
    195194                // Shortcut for document ready
    196195                } else if ( jQuery.isFunction( selector ) ) {
     
    442441        },
    443442
    444443        type: function( obj ) {
    445                 return obj == null ?
    446                         String( obj ) :
    447                         class2type[ core_toString.call(obj) ] || "object";
     444                if ( obj == null ) {
     445                        return String( obj );
     446                }
     447                return typeof obj === "object" || typeof obj === "function" ?
     448                        class2type[ core_toString.call(obj) ] || "object" :
     449                        typeof obj;
    448450        },
    449451
    450452        isPlainObject: function( obj ) {
     
    509511                        return [ context.createElement( parsed[1] ) ];
    510512                }
    511513
    512                 parsed = context.createDocumentFragment();
    513                 jQuery.clean( [ data ], context, parsed, scripts );
     514                parsed = jQuery.buildFragment( [ data ], context, scripts );
    514515                if ( scripts ) {
    515516                        jQuery( scripts ).remove();
    516517                }
     
    11641165                                        return jQuery.Deferred(function( newDefer ) {
    11651166                                                jQuery.each( tuples, function( i, tuple ) {
    11661167                                                        var action = tuple[ 0 ],
    1167                                                                 fn = fns[ i ];
     1168                                                                fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
    11681169                                                        // deferred[ done | fail | progress ] for forwarding actions to newDefer
    1169                                                         deferred[ tuple[1] ]( jQuery.isFunction( fn ) ?
    1170                                                                 function() {
    1171                                                                         var returned = fn.apply( this, arguments );
    1172                                                                         if ( returned && jQuery.isFunction( returned.promise ) ) {
    1173                                                                                 returned.promise()
    1174                                                                                         .done( newDefer.resolve )
    1175                                                                                         .fail( newDefer.reject )
    1176                                                                                         .progress( newDefer.notify );
    1177                                                                         } else {
    1178                                                                                 newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, [ returned ] );
    1179                                                                         }
    1180                                                                 } :
    1181                                                                 newDefer[ action ]
    1182                                                         );
     1170                                                        deferred[ tuple[1] ](function() {
     1171                                                                var returned = fn && fn.apply( this, arguments );
     1172                                                                if ( returned && jQuery.isFunction( returned.promise ) ) {
     1173                                                                        returned.promise()
     1174                                                                                .done( newDefer.resolve )
     1175                                                                                .fail( newDefer.reject )
     1176                                                                                .progress( newDefer.notify );
     1177                                                                } else {
     1178                                                                        newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
     1179                                                                }
     1180                                                        });
    11831181                                                });
    11841182                                                fns = null;
    11851183                                        }).promise();
     
    12151213
    12161214                        // deferred[ resolve | reject | notify ]
    12171215                        deferred[ tuple[0] ] = function() {
    1218                                 deferred[ tuple[0] + "With" ]( promise, arguments );
     1216                                deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
    12191217                                return this;
    12201218                        };
    12211219                        deferred[ tuple[0] + "With" ] = list.fireWith;
     
    12871285});
    12881286jQuery.support = (function() {
    12891287
    1290         var support,
    1291                 all,
    1292                 a,
    1293                 select,
    1294                 opt,
    1295                 input,
    1296                 fragment,
    1297                 eventName,
    1298                 i,
    1299                 isSupported,
    1300                 clickFn,
     1288        var support, all, a, select, opt, input, fragment, eventName, isSupported, i,
    13011289                div = document.createElement("div");
    13021290
    13031291        // Setup
     
    13671355                boxModel: document.compatMode === "CSS1Compat",
    13681356
    13691357                // Will be defined later
    1370                 submitBubbles: true,
    1371                 changeBubbles: true,
    1372                 focusinBubbles: false,
    13731358                deleteExpando: true,
    13741359                noCloneEvent: true,
    13751360                inlineBlockNeedsLayout: false,
     
    13881373        select.disabled = true;
    13891374        support.optDisabled = !opt.disabled;
    13901375
    1391         // Test to see if it's possible to delete an expando from an element
    1392         // Fails in Internet Explorer
     1376        // Support: IE<9
    13931377        try {
    13941378                delete div.test;
    13951379        } catch( e ) {
    13961380                support.deleteExpando = false;
    13971381        }
    13981382
    1399         if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
    1400                 div.attachEvent( "onclick", clickFn = function() {
    1401                         // Cloning a node shouldn't copy over any
    1402                         // bound event handlers (IE does this)
    1403                         support.noCloneEvent = false;
    1404                 });
    1405                 div.cloneNode( true ).fireEvent("onclick");
    1406                 div.detachEvent( "onclick", clickFn );
    1407         }
    1408 
    14091383        // Check if we can trust getAttribute("value")
    14101384        input = document.createElement("input");
    14111385        input.setAttribute( "value", "" );
     
    14171391        support.radioValue = input.value === "t";
    14181392
    14191393        // #11217 - WebKit loses check when the name is after the checked attribute
    1420         input.setAttribute( "checked", "checked" );
     1394        input.setAttribute( "checked", "t" );
    14211395        input.setAttribute( "name", "t" );
    14221396
    1423         div.appendChild( input );
    14241397        fragment = document.createDocumentFragment();
    1425         fragment.appendChild( div.lastChild );
     1398        fragment.appendChild( input );
    14261399
    1427         // WebKit doesn't clone checked state correctly in fragments
    1428         support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
    1429 
    14301400        // Check if a disconnected checkbox will retain its checked
    14311401        // value of true after appended to the DOM (IE6/7)
    14321402        support.appendChecked = input.checked;
    14331403
    1434         fragment.removeChild( input );
    1435         fragment.appendChild( div );
     1404        // WebKit doesn't clone checked state correctly in fragments
     1405        support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
    14361406
    1437         // Technique from Juriy Zaytsev
    1438         // http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
    1439         // We only care about the case where non-standard event systems
    1440         // are used, namely in IE. Short-circuiting here helps us to
    1441         // avoid an eval call (in setAttribute) which can cause CSP
    1442         // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
     1407        // Support: IE<9
     1408        // Opera does not clone events (and typeof div.attachEvent === undefined).
     1409        // IE9-10 clones events bound via attachEvent, but they don't trigger with .click()
    14431410        if ( div.attachEvent ) {
    1444                 for ( i in {
    1445                         submit: true,
    1446                         change: true,
    1447                         focusin: true
    1448                 }) {
    1449                         eventName = "on" + i;
    1450                         isSupported = ( eventName in div );
    1451                         if ( !isSupported ) {
    1452                                 div.setAttribute( eventName, "return;" );
    1453                                 isSupported = ( typeof div[ eventName ] === "function" );
    1454                         }
    1455                         support[ i + "Bubbles" ] = isSupported;
    1456                 }
     1411                div.attachEvent( "onclick", function() {
     1412                        support.noCloneEvent = false;
     1413                });
     1414
     1415                div.cloneNode( true ).click();
    14571416        }
    14581417
     1418        // Support: IE<9 (lack submit/change bubble), Firefox 17+ (lack focusin event)
     1419        // Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP), test/csp.php
     1420        for ( i in { submit: true, change: true, focusin: true }) {
     1421                div.setAttribute( eventName = "on" + i, "t" );
     1422
     1423                support[ i + "Bubbles" ] = eventName in window || div.attributes[ eventName ].expando === false;
     1424        }
     1425
     1426        div.style.backgroundClip = "content-box";
     1427        div.cloneNode( true ).style.backgroundClip = "";
     1428        support.clearCloneStyle = div.style.backgroundClip === "content-box";
     1429
    14591430        // Run tests that need a body at doc ready
    14601431        jQuery(function() {
    1461                 var container, div, tds, marginDiv,
    1462                         divReset = "padding:0;margin:0;border:0;display:block;overflow:hidden;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;",
     1432                var container, marginDiv, tds,
     1433                        divReset = "padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;",
    14631434                        body = document.getElementsByTagName("body")[0];
    14641435
    14651436                if ( !body ) {
     
    14681439                }
    14691440
    14701441                container = document.createElement("div");
    1471                 container.style.cssText = "visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px";
    1472                 body.insertBefore( container, body.firstChild );
     1442                container.style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px";
    14731443
    1474                 // Construct the test element
    1475                 div = document.createElement("div");
    1476                 container.appendChild( div );
     1444                body.appendChild( container ).appendChild( div );
    14771445
     1446                // Support: IE8
    14781447                // Check if table cells still have offsetWidth/Height when they are set
    14791448                // to display:none and there are still other visible table cells in a
    14801449                // table row; if so, offsetWidth/Height are not reliable for use when
    14811450                // determining if an element has been hidden directly using
    14821451                // display:none (it is still safe to use offsets if a parent element is
    14831452                // hidden; don safety goggles and see bug #4512 for more information).
    1484                 // (only IE 8 fails this test)
    14851453                div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
    14861454                tds = div.getElementsByTagName("td");
    14871455                tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none";
     
    14901458                tds[ 0 ].style.display = "";
    14911459                tds[ 1 ].style.display = "none";
    14921460
     1461                // Support: IE8
    14931462                // Check if empty table cells still have offsetWidth/Height
    1494                 // (IE <= 8 fail this test)
    14951463                support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
    14961464
    14971465                // Check box-sizing and margin behavior
     
    15001468                support.boxSizing = ( div.offsetWidth === 4 );
    15011469                support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 );
    15021470
    1503                 // NOTE: To any future maintainer, we've window.getComputedStyle
    1504                 // because jsdom on node.js will break without it.
     1471                // Use window.getComputedStyle because jsdom on node.js will break without it.
    15051472                if ( window.getComputedStyle ) {
    15061473                        support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
    15071474                        support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
    15081475
    15091476                        // Check if div with explicit width and no margin-right incorrectly
    1510                         // gets computed margin-right based on width of container. For more
    1511                         // info see bug #3333
     1477                        // gets computed margin-right based on width of container. (#3333)
    15121478                        // Fails in WebKit before Feb 2011 nightlies
    15131479                        // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
    1514                         marginDiv = document.createElement("div");
     1480                        marginDiv = div.appendChild( document.createElement("div") );
    15151481                        marginDiv.style.cssText = div.style.cssText = divReset;
    15161482                        marginDiv.style.marginRight = marginDiv.style.width = "0";
    15171483                        div.style.width = "1px";
    1518                         div.appendChild( marginDiv );
     1484
    15191485                        support.reliableMarginRight =
    15201486                                !parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight );
    15211487                }
    15221488
    15231489                if ( typeof div.style.zoom !== "undefined" ) {
     1490                        // Support: IE<8
    15241491                        // Check if natively block-level elements act like inline-block
    15251492                        // elements when setting their display to 'inline' and giving
    15261493                        // them layout
    1527                         // (IE < 8 does this)
    15281494                        div.innerHTML = "";
    15291495                        div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
    15301496                        support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
    15311497
     1498                        // Support: IE6
    15321499                        // Check if elements with layout shrink-wrap their children
    1533                         // (IE 6 does this)
    15341500                        div.style.display = "block";
    1535                         div.style.overflow = "visible";
    15361501                        div.innerHTML = "<div></div>";
    15371502                        div.firstChild.style.width = "5px";
    15381503                        support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
     
    15421507                        body.style.zoom = 1;
    15431508                }
    15441509
     1510                body.removeChild( container );
     1511
    15451512                // Null elements to avoid leaks in IE
    1546                 body.removeChild( container );
    15471513                container = div = tds = marginDiv = null;
    15481514        });
    15491515
    15501516        // Null elements to avoid leaks in IE
    1551         fragment.removeChild( div );
    1552         all = a = select = opt = input = fragment = div = null;
     1517        all = select = fragment = opt = a = input = null;
    15531518
    15541519        return support;
    15551520})();
     1521
    15561522var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
    15571523        rmultiDash = /([A-Z])/g;
    15581524
     
    19261892                        startLength--;
    19271893                }
    19281894
     1895                hooks.cur = fn;
    19291896                if ( fn ) {
    19301897
    19311898                        // Add a progress sentinel to prevent the fx queue from being
     
    23672334
    23682335                } else {
    23692336
    2370                         ret = elem.getAttribute( name );
     2337                        // In IE9+, Flash objects don't have .getAttribute (#12945)
     2338                        // Support: IE9+
     2339                        if ( typeof elem.getAttribute !== "undefined" ) {
     2340                                ret =  elem.getAttribute( name );
     2341                        }
    23712342
    23722343                        // Non-existent attributes return null, we normalize to undefined
    23732344                        return ret == null ?
     
    26372608        jQuery.attrHooks.style = {
    26382609                get: function( elem ) {
    26392610                        // Return undefined in the case of empty string
    2640                         // Normalize to lowercase since IE uppercases css property names
    2641                         return elem.style.cssText.toLowerCase() || undefined;
     2611                        // Note: IE uppercases css property names, but if we were to .toLowerCase()
     2612                        // .cssText, that would destroy case senstitivity in URL's, like in "background"
     2613                        return elem.style.cssText || undefined;
    26422614                },
    26432615                set: function( elem, value ) {
    26442616                        return ( elem.style.cssText = value + "" );
     
    36333605                return this.off( types, null, fn );
    36343606        },
    36353607
    3636         live: function( types, data, fn ) {
    3637                 jQuery( this.context ).on( types, this.selector, data, fn );
    3638                 return this;
    3639         },
    3640         die: function( types, fn ) {
    3641                 jQuery( this.context ).off( types, this.selector || "**", fn );
    3642                 return this;
    3643         },
    3644 
    36453608        delegate: function( selector, types, data, fn ) {
    36463609                return this.on( types, selector, data, fn );
    36473610        },
     
    37133676        contains,
    37143677        sortOrder,
    37153678
     3679        // Instance-specific data
    37163680        expando = "sizzle" + -(new Date()),
     3681        preferredDoc = window.document,
     3682        support = {},
     3683        dirruns = 0,
     3684        done = 0,
     3685        classCache = createCache(),
     3686        tokenCache = createCache(),
     3687        compilerCache = createCache(),
    37173688
     3689        // General-purpose constants
     3690        Token = String,
    37183691        strundefined = typeof undefined,
    3719 
    3720         // Used in sorting
    37213692        MAX_NEGATIVE = 1 << 31,
    3722         preferredDoc = window.document,
    37233693
    3724         Token = String,
    3725         dirruns = 0,
    3726         done = 0,
    3727         support = {},
    3728 
    37293694        // Array methods
    37303695        arr = [],
    37313696        pop = arr.pop,
     
    37433708                return -1;
    37443709        },
    37453710
    3746         // Augment a function for special use by Sizzle
    3747         markFunction = function( fn, value ) {
    3748                 fn[ expando ] = value == null || value;
    3749                 return fn;
    3750         },
    37513711
    3752         createCache = function() {
    3753                 var cache = {},
    3754                         keys = [];
     3712        // Regular expressions
    37553713
    3756                 return markFunction(function( key, value ) {
    3757                         // Only keep the most recent entries
    3758                         if ( keys.push( key ) > Expr.cacheLength ) {
    3759                                 delete cache[ keys.shift() ];
    3760                         }
    3761 
    3762                         // Retrieve with (key + " ") to avoid collision with native Object.prototype properties (see Issue #157)
    3763                         return (cache[ key + " " ] = value);
    3764                 }, cache );
    3765         },
    3766 
    3767         classCache = createCache(),
    3768         tokenCache = createCache(),
    3769         compilerCache = createCache(),
    3770 
    3771         // Regex
    3772 
    37733714        // Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
    37743715        whitespace = "[\\x20\\t\\r\\n\\f]",
    37753716        // http://www.w3.org/TR/css3-syntax/#characters
    37763717        characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
    37773718
    37783719        // Loosely modeled on CSS identifier characters
    3779         // An unquoted value should be a CSS identifier (http://www.w3.org/TR/css3-selectors/#attribute-selectors)
     3720        // An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
    37803721        // Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
    37813722        identifier = characterEncoding.replace( "w", "w#" ),
    37823723
     
    37993740        rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
    38003741        rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ),
    38013742        rpseudo = new RegExp( pseudos ),
     3743        ridentifier = new RegExp( "^" + identifier + "$" ),
    38023744
    3803         // Easily-parseable/retrievable ID or TAG or CLASS selectors
    3804         rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
    3805 
    3806         rsibling = /[\x20\t\r\n\f]*[+~]/,
    3807 
    3808         rheader = /h\d/i,
    3809         rinputs = /input|select|textarea|button/i,
    3810 
    3811         rnative = /\{\s*\[native code\]\s*\}/,
    3812 
    3813         rbackslash = /\\(?!\\)/g,
    3814 
    3815         rescape = /'|\\/g,
    3816         rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,
    3817 
    38183745        matchExpr = {
    38193746                "ID": new RegExp( "^#(" + characterEncoding + ")" ),
    38203747                "CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
     
    38313758                        whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
    38323759        },
    38333760
    3834         /**
    3835          * For feature detection
    3836          * @param {Function} fn The function to test for native support
    3837          */
    3838         isNative = function( fn ) {
    3839                 return rnative.test( fn + "" );
    3840         },
     3761        rsibling = /[\x20\t\r\n\f]*[+~]/,
    38413762
    3842         /**
    3843          * Support testing using an element
    3844          * @param {Function} fn Passed the created div and expects a boolean result
    3845          */
    3846         assert = function( fn ) {
    3847                 var div = document.createElement("div");
     3763        rnative = /\{\s*\[native code\]\s*\}/,
    38483764
    3849                 try {
    3850                         return fn( div );
    3851                 } catch (e) {
    3852                         return false;
    3853                 } finally {
    3854                         // release memory in IE
    3855                         div = null;
    3856                 }
     3765        // Easily-parseable/retrievable ID or TAG or CLASS selectors
     3766        rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
     3767
     3768        rinputs = /^(?:input|select|textarea|button)$/i,
     3769        rheader = /^h\d$/i,
     3770
     3771        rescape = /'|\\/g,
     3772        rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,
     3773
     3774        // CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
     3775        runescape = /\\([\da-fA-F]{1,6}[\x20\t\r\n\f]?|.)/g,
     3776        funescape = function( _, escaped ) {
     3777                var high = "0x" + escaped - 0x10000;
     3778                // NaN means non-codepoint
     3779                return high !== high ?
     3780                        escaped :
     3781                        // BMP codepoint
     3782                        high < 0 ?
     3783                                String.fromCharCode( high + 0x10000 ) :
     3784                                // Supplemental Plane codepoint (surrogate pair)
     3785                                String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
    38573786        };
    38583787
    38593788// Use a stripped-down slice if we can't use a native one
     
    38703799        };
    38713800}
    38723801
     3802/**
     3803 * For feature detection
     3804 * @param {Function} fn The function to test for native support
     3805 */
     3806function isNative( fn ) {
     3807        return rnative.test( fn + "" );
     3808}
     3809
     3810/**
     3811 * Create key-value caches of limited size
     3812 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
     3813 *      property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
     3814 *      deleting the oldest entry
     3815 */
     3816function createCache() {
     3817        var cache,
     3818                keys = [];
     3819
     3820        return (cache = function( key, value ) {
     3821                // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
     3822                if ( keys.push( key += " " ) > Expr.cacheLength ) {
     3823                        // Only keep the most recent entries
     3824                        delete cache[ keys.shift() ];
     3825                }
     3826                return (cache[ key ] = value);
     3827        });
     3828}
     3829
     3830/**
     3831 * Mark a function for special use by Sizzle
     3832 * @param {Function} fn The function to mark
     3833 */
     3834function markFunction( fn ) {
     3835        fn[ expando ] = true;
     3836        return fn;
     3837}
     3838
     3839/**
     3840 * Support testing using an element
     3841 * @param {Function} fn Passed the created div and expects a boolean result
     3842 */
     3843function assert( fn ) {
     3844        var div = document.createElement("div");
     3845
     3846        try {
     3847                return fn( div );
     3848        } catch (e) {
     3849                return false;
     3850        } finally {
     3851                // release memory in IE
     3852                div = null;
     3853        }
     3854}
     3855
    38733856function Sizzle( selector, context, results, seed ) {
    38743857        var match, elem, m, nodeType,
    38753858                // QSA vars
    38763859                i, groups, old, nid, newContext, newSelector;
    38773860
    3878         if ( context && (( context.ownerDocument || context ) !== document) ) {
     3861        if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
    38793862                setDocument( context );
    38803863        }
    38813864
     
    39963979 * @param {Element|Object} [doc] An element or document object to use to set the document
    39973980 * @returns {Object} Returns the current document
    39983981 */
    3999 setDocument = Sizzle.setDocument = function( doc ) {
    4000         doc = doc && doc.ownerDocument || doc || window.document;
     3982setDocument = Sizzle.setDocument = function( node ) {
     3983        var doc = node ? node.ownerDocument || node : preferredDoc;
    40013984
    40023985        // If no document and documentElement is available, return
    4003         if ( !doc || doc.nodeType !== 9 || !doc.documentElement || document === doc ) {
     3986        if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
    40043987                return document;
    40053988        }
    40063989
     
    40874070                        }
    40884071                };
    40894072                Expr.filter["ID"] = function( id ) {
    4090                         var attrId = id.replace( rbackslash, "" );
     4073                        var attrId = id.replace( runescape, funescape );
    40914074                        return function( elem ) {
    40924075                                return elem.getAttribute("id") === attrId;
    40934076                        };
     
    41054088                        }
    41064089                };
    41074090                Expr.filter["ID"] =  function( id ) {
    4108                         var attrId = id.replace( rbackslash, "" );
     4091                        var attrId = id.replace( runescape, funescape );
    41094092                        return function( elem ) {
    41104093                                var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
    41114094                                return node && node.value === attrId;
     
    41894172
    41904173                assert(function( div ) {
    41914174
    4192                         // Opera 10-12/IE9 - ^= $= *= and empty values
     4175                        // Opera 10-12/IE8 - ^= $= *= and empty values
    41934176                        // Should not select anything
    4194                         div.innerHTML = "<p test=''></p>";
    4195                         if ( div.querySelectorAll("[test^='']").length ) {
     4177                        div.innerHTML = "<input type='hidden' i=''/>";
     4178                        if ( div.querySelectorAll("[i^='']").length ) {
    41964179                                rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:\"\"|'')" );
    41974180                        }
    41984181
    41994182                        // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
    42004183                        // IE8 throws error here and will not see later tests
    4201                         div.innerHTML = "<input type='hidden'/>";
    42024184                        if ( !div.querySelectorAll(":enabled").length ) {
    42034185                                rbuggyQSA.push( ":enabled", ":disabled" );
    42044186                        }
     
    42224204
    42234205                        // This should fail with an exception
    42244206                        // Gecko does not error, returns false instead
    4225                         matches.call( div, "[test!='']:x" );
     4207                        matches.call( div, "[s!='']:x" );
    42264208                        rbuggyMatches.push( "!=", pseudos );
    42274209                });
    42284210        }
     
    43444326};
    43454327
    43464328Sizzle.matches = function( expr, elements ) {
    4347         return Sizzle( expr, window.document, null, elements );
     4329        return Sizzle( expr, null, null, elements );
    43484330};
    43494331
    43504332Sizzle.matchesSelector = function( elem, expr ) {
    43514333        // Set document vars if needed
    4352         if ( elem && (( elem.ownerDocument || elem ) !== document) ) {
     4334        if ( ( elem.ownerDocument || elem ) !== document ) {
    43534335                setDocument( elem );
    43544336        }
    43554337
     
    43764358
    43774359Sizzle.contains = function( context, elem ) {
    43784360        // Set document vars if needed
    4379         if ( context && (( context.ownerDocument || context ) !== document) ) {
     4361        if ( ( context.ownerDocument || context ) !== document ) {
    43804362                setDocument( context );
    43814363        }
    43824364        return contains( context, elem );
     
    43864368        var val;
    43874369
    43884370        // Set document vars if needed
    4389         if ( elem && (( elem.ownerDocument || elem ) !== document) ) {
     4371        if ( ( elem.ownerDocument || elem ) !== document ) {
    43904372                setDocument( elem );
    43914373        }
    43924374
     
    45354517
    45364518        preFilter: {
    45374519                "ATTR": function( match ) {
    4538                         match[1] = match[1].replace( rbackslash, "" );
     4520                        match[1] = match[1].replace( runescape, funescape );
    45394521
    45404522                        // Move the given value to match[3] whether quoted or unquoted
    4541                         match[3] = ( match[4] || match[5] || "" ).replace( rbackslash, "" );
     4523                        match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape );
    45424524
    45434525                        if ( match[2] === "~=" ) {
    45444526                                match[3] = " " + match[3] + " ";
     
    46154597                                return function() { return true; };
    46164598                        }
    46174599
    4618                         nodeName = nodeName.replace( rbackslash, "" ).toLowerCase();
     4600                        nodeName = nodeName.replace( runescape, funescape ).toLowerCase();
    46194601                        return function( elem ) {
    46204602                                return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
    46214603                        };
    46224604                },
    46234605
    46244606                "CLASS": function( className ) {
    4625                         var pattern = classCache[ expando ][ className + " " ];
     4607                        var pattern = classCache[ className + " " ];
    46264608
    46274609                        return pattern ||
    46284610                                (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
     
    48244806                        };
    48254807                }),
    48264808
     4809                // "Whether an element is represented by a :lang() selector
     4810                // is based solely on the element's language value
     4811                // being equal to the identifier C,
     4812                // or beginning with the identifier C immediately followed by "-".
     4813                // The matching of C against the element's language value is performed case-insensitively.
     4814                // The identifier C does not have to be a valid language name."
     4815                // http://www.w3.org/TR/selectors/#lang-pseudo
     4816                "lang": markFunction( function( lang ) {
     4817                        // lang value must be a valid identifider
     4818                        if ( !ridentifier.test(lang || "") ) {
     4819                                Sizzle.error( "unsupported lang: " + lang );
     4820                        }
     4821                        lang = lang.replace( runescape, funescape ).toLowerCase();
     4822                        return function( elem ) {
     4823                                var elemLang;
     4824                                do {
     4825                                        if ( (elemLang = documentIsXML ?
     4826                                                elem.getAttribute("xml:lang") || elem.getAttribute("lang") :
     4827                                                elem.lang) ) {
     4828
     4829                                                elemLang = elemLang.toLowerCase();
     4830                                                return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
     4831                                        }
     4832                                } while ( (elem = elem.parentNode) && elem.nodeType === 1 );
     4833                                return false;
     4834                        };
     4835                }),
     4836
    48274837                // Miscellaneous
    48284838                "target": function( elem ) {
    48294839                        var hash = window.location && window.location.hash;
     
    49644974function tokenize( selector, parseOnly ) {
    49654975        var matched, match, tokens, type,
    49664976                soFar, groups, preFilters,
    4967                 cached = tokenCache[ expando ][ selector + " " ];
     4977                cached = tokenCache[ selector + " " ];
    49684978
    49694979        if ( cached ) {
    49704980                return parseOnly ? 0 : cached.slice( 0 );
     
    53575367        var i,
    53585368                setMatchers = [],
    53595369                elementMatchers = [],
    5360                 cached = compilerCache[ expando ][ selector + " " ];
     5370                cached = compilerCache[ selector + " " ];
    53615371
    53625372        if ( !cached ) {
    53635373                // Generate a function of recursive functions that can be used to check each element
     
    54035413                                        context.nodeType === 9 && !documentIsXML &&
    54045414                                        Expr.relative[ tokens[1].type ] ) {
    54055415
    5406                                 context = Expr.find["ID"]( token.matches[0].replace( rbackslash, "" ), context )[0];
     5416                                context = Expr.find["ID"]( token.matches[0].replace( runescape, funescape ), context )[0];
    54075417                                if ( !context ) {
    54085418                                        return results;
    54095419                                }
     
    54225432                                if ( (find = Expr.find[ type ]) ) {
    54235433                                        // Search, expanding context for leading sibling combinators
    54245434                                        if ( (seed = find(
    5425                                                 token.matches[0].replace( rbackslash, "" ),
     5435                                                token.matches[0].replace( runescape, funescape ),
    54265436                                                rsibling.test( tokens[0].type ) && context.parentNode || context
    54275437                                        )) ) {
    54285438
     
    59445954                        while ( elem.firstChild ) {
    59455955                                elem.removeChild( elem.firstChild );
    59465956                        }
     5957
     5958                        // If this is a select, ensure that it displays empty (#12336)
     5959                        // Support: IE<9
     5960                        if ( elem.options && jQuery.nodeName( elem, "select" ) ) {
     5961                                elem.options.length = 0;
     5962                        }
    59475963                }
    59485964
    59495965                return this;
     
    60386054                var fragment, first, scripts, hasScripts, node, doc,
    60396055                        i = 0,
    60406056                        l = this.length,
     6057                        set = this,
    60416058                        iNoClone = l - 1,
    60426059                        value = args[0],
    60436060                        isFunction = jQuery.isFunction( value );
    60446061
    60456062                // We can't cloneNode fragments that contain checked, in WebKit
    60466063                if ( isFunction || !( l <= 1 || typeof value !== "string" || jQuery.support.checkClone || !rchecked.test( value ) ) ) {
    6047                         return this.each(function() {
    6048                                 var self = jQuery( this );
     6064                        return this.each(function( index ) {
     6065                                var self = set.eq( index );
    60496066                                if ( isFunction ) {
    6050                                         args[0] = value.call( this, i, table ? self.html() : undefined );
     6067                                        args[0] = value.call( this, index, table ? self.html() : undefined );
    60516068                                }
    60526069                                self.domManip( args, table, callback );
    60536070                        });
     
    60556072
    60566073                if ( this[0] ) {
    60576074                        doc = this[0].ownerDocument;
    6058                         fragment = doc.createDocumentFragment();
    6059                         jQuery.clean( args, doc, fragment, undefined, this );
     6075                        fragment = jQuery.buildFragment( args, doc, false, this );
    60606076                        first = fragment.firstChild;
    60616077
    60626078                        if ( fragment.childNodes.length === 1 ) {
     
    63016317                found;
    63026318}
    63036319
    6304 // Used in clean, fixes the defaultChecked property
     6320// Used in buildFragment, fixes the defaultChecked property
    63056321function fixDefaultChecked( elem ) {
    63066322        if ( manipulation_rcheckableType.test( elem.type ) ) {
    63076323                elem.defaultChecked = elem.checked;
     
    63646380                return clone;
    63656381        },
    63666382
    6367         clean: function( elems, context, fragment, scripts, selection ) {
     6383        buildFragment: function( elems, context, scripts, selection ) {
    63686384                var elem, i, j, tmp, tag, wrap, tbody,
    63696385                        ret = [],
     6386                        fragment = context.createDocumentFragment(),
    63706387                        safe = context === document && safeFragment;
    63716388
    63726389                // Ensure that context is a document
     
    64536470                        jQuery.grep( getAll( ret, "input" ), fixDefaultChecked );
    64546471                }
    64556472
    6456                 if ( fragment ) {
    6457                         for ( i = 0; (elem = ret[i]) != null; i++ ) {
    6458                                 safe = jQuery.contains( elem.ownerDocument, elem );
     6473                for ( i = 0; (elem = ret[i]) != null; i++ ) {
     6474                        safe = jQuery.contains( elem.ownerDocument, elem );
    64596475
    6460                                 // Append to fragment
    6461                                 // #4087 - If origin and destination elements are the same, and this is
    6462                                 // that element, do not append to fragment
    6463                                 if ( !selection || jQuery.inArray( elem, selection ) === -1 ) {
    6464                                         fragment.appendChild( elem );
    6465                                 }
    6466                                 tmp = getAll( elem, "script" );
     6476                        // Append to fragment
     6477                        // #4087 - If origin and destination elements are the same, and this is
     6478                        // that element, do not append to fragment
     6479                        if ( !selection || jQuery.inArray( elem, selection ) === -1 ) {
     6480                                fragment.appendChild( elem );
     6481                        }
     6482                        tmp = getAll( elem, "script" );
    64676483
    6468                                 // Preserve script evaluation history
    6469                                 if ( safe ) {
    6470                                         setGlobalEval( tmp );
    6471                                 }
     6484                        // Preserve script evaluation history
     6485                        if ( safe ) {
     6486                                setGlobalEval( tmp );
     6487                        }
    64726488
    6473                                 // Capture executables
    6474                                 if ( scripts ) {
    6475                                         for ( j = 0; (elem = tmp[j]) != null; j++ ) {
    6476                                                 if ( rscriptType.test( elem.type || "" ) ) {
    6477                                                         scripts.push( elem );
    6478                                                 }
     6489                        // Capture executables
     6490                        if ( scripts ) {
     6491                                for ( j = 0; (elem = tmp[j]) != null; j++ ) {
     6492                                        if ( rscriptType.test( elem.type || "" ) ) {
     6493                                                scripts.push( elem );
    64796494                                        }
    64806495                                }
    64816496                        }
     
    64836498
    64846499                elem = tmp = safe = null;
    64856500
    6486                 return ret;
     6501                return fragment;
    64876502        },
    64886503
    64896504        cleanData: function( elems, /* internal */ acceptData ) {
     
    65256540                                                if ( deleteExpando ) {
    65266541                                                        delete elem[ internalKey ];
    65276542
    6528                                                 } else if ( elem.removeAttribute ) {
     6543                                                } else if ( typeof elem.removeAttribute !== "undefined" ) {
    65296544                                                        elem.removeAttribute( internalKey );
    65306545
    65316546                                                } else {
     
    67546769
    67556770                        // Fixes #8908, it can be done more correctly by specifing setters in cssHooks,
    67566771                        // but it would mean to define eight (for every problematic property) identical functions
    6757                         if ( value === "" && name.indexOf("background") === 0 ) {
    6758                                 value = " ";
     6772                        if ( !jQuery.support.clearCloneStyle && value === "" && name.indexOf("background") === 0 ) {
     6773                                style[ name ] = "inherit";
    67596774                        }
    67606775
    67616776                        // If a hook was provided, use that value, otherwise just set the specified value
     
    86098624
    86108625function Animation( elem, properties, options ) {
    86118626        var result,
     8627                stopped,
    86128628                index = 0,
    86138629                length = animationPrefilters.length,
    86148630                deferred = jQuery.Deferred().always( function() {
     
    86168632                        delete tick.elem;
    86178633                }),
    86188634                tick = function() {
     8635                        if ( stopped ) {
     8636                                return false;
     8637                        }
    86198638                        var currentTime = fxNow || createFxNow(),
    86208639                                remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
    86218640                                // archaic crash bug won't allow us to use 1 - ( 0.5 || 0 ) (#12497)
     
    86578676                                        // if we are going to the end, we want to run all the tweens
    86588677                                        // otherwise we skip this part
    86598678                                        length = gotoEnd ? animation.tweens.length : 0;
    8660 
     8679                                if ( stopped ) {
     8680                                        return this;
     8681                                }
     8682                                stopped = true;
    86618683                                for ( ; index < length ; index++ ) {
    86628684                                        animation.tweens[ index ].run( 1 );
    86638685                                }
     
    90149036                        doAnimation = function() {
    90159037                                // Operate on a copy of prop so per-property easing won't be lost
    90169038                                var anim = Animation( this, jQuery.extend( {}, prop ), optall );
    9017 
    9018                                 // Empty animations resolve immediately
    9019                                 if ( empty ) {
     9039                                doAnimation.finish = function() {
    90209040                                        anim.stop( true );
     9041                                };
     9042                                // Empty animations, or finishing resolves immediately
     9043                                if ( empty || jQuery._data( this, "finish" ) ) {
     9044                                        anim.stop( true );
    90219045                                }
    90229046                        };
     9047                        doAnimation.finish = doAnimation;
    90239048
    90249049                return empty || optall.queue === false ?
    90259050                        this.each( doAnimation ) :
     
    90749099                                jQuery.dequeue( this, type );
    90759100                        }
    90769101                });
     9102        },
     9103        finish: function( type ) {
     9104                if ( type !== false ) {
     9105                        type = type || "fx";
     9106                }
     9107                return this.each(function() {
     9108                        var index,
     9109                                data = jQuery._data( this ),
     9110                                queue = data[ type + "queue" ],
     9111                                hooks = data[ type + "queueHooks" ],
     9112                                timers = jQuery.timers,
     9113                                length = queue ? queue.length : 0;
     9114
     9115                        // enable finishing flag on private data
     9116                        data.finish = true;
     9117
     9118                        // empty the queue first
     9119                        jQuery.queue( this, type, [] );
     9120
     9121                        if ( hooks && hooks.cur && hooks.cur.finish ) {
     9122                                hooks.cur.finish.call( this );
     9123                        }
     9124
     9125                        // look for any active animations, and finish them
     9126                        for ( index = timers.length; index--; ) {
     9127                                if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
     9128                                        timers[ index ].anim.stop( true );
     9129                                        timers.splice( index, 1 );
     9130                                }
     9131                        }
     9132
     9133                        // look for any animations in the old queue and finish them
     9134                        for ( index = 0; index < length; index++ ) {
     9135                                if ( queue[ index ] && queue[ index ].finish ) {
     9136                                        queue[ index ].finish.call( this );
     9137                                }
     9138                        }
     9139
     9140                        // turn off finishing flag
     9141                        delete data.finish;
     9142                });
    90779143        }
    90789144});
    90799145
  • wp-includes/js/jquery/jquery-migrate.js

     
    11/*!
    2  * jQuery Migrate - v1.0.0pre - 2012-12-17
     2 * jQuery Migrate - v1.0.0pre - 2013-01-09
    33 * https://github.com/jquery/jquery-migrate
    4  * Copyright 2012 jQuery Foundation and other contributors; Licensed MIT
     4 * Copyright 2013 jQuery Foundation and other contributors; Licensed MIT
    55 */
    6 
    76(function( jQuery, window, undefined ) {
    87"use strict";
    98
    109// Use Uglify to do conditional compilation of warning messages;
    11 // the minified version will set this to false and remove dead code.
    12 if ( typeof window.JQMIGRATE_WARN === "undefined" ) {
    13         window.JQMIGRATE_WARN = true;
    14 }
     10// the minified version will set this to false during compilation.
     11window.JQMIGRATE_WARN = typeof JQMIGRATE_WARN === "undefined";
    1512
    1613
    1714var warnedAbout = {};
     
    1916// List of warnings already given; public read only
    2017jQuery.migrateWarnings = [];
    2118
     19// Set to true to prevent console output; migrateWarnings still maintained
     20// Leave as undefined so that it can be set before plugin is loaded
     21//jQuery.migrateMute = false;
     22
    2223// Forget any warnings we've already given; public
    2324jQuery.migrateReset = function() {
    2425        warnedAbout = {};
     
    3031                if ( !warnedAbout[ msg ] ) {
    3132                        warnedAbout[ msg ] = true;
    3233                        jQuery.migrateWarnings.push( msg );
    33                         if ( window.console && console.warn ) {
     34                        if ( window.console && console.warn && !jQuery.migrateMute ) {
    3435                                console.warn( "JQMIGRATE: " + msg );
    3536                        }
    3637                }
     
    7879        valueAttrSet = jQuery.attrHooks.value && jQuery.attrHooks.value.set ||
    7980                function() { return undefined; },
    8081        rnoType = /^(?:input|button)$/i,
    81         rnoAttrNodeType = /^[238]$/;
     82        rnoAttrNodeType = /^[238]$/,
     83        rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
     84        ruseDefault = /^(?:checked|selected)$/i;
    8285
    8386// jQuery.attrFn
    8487migrateWarnProp( jQuery, "attrFn", attrFn, "jQuery.attrFn is deprecated" );
    8588
    8689jQuery.attr = function( elem, name, value, pass ) {
     90        var lowerName = name.toLowerCase(),
     91                nType = elem && elem.nodeType;
     92
    8793        if ( pass ) {
    8894                migrateWarn("jQuery.fn.attr( props, pass ) is deprecated");
    89                 if ( elem && !rnoAttrNodeType.test( elem.nodeType ) && jQuery.isFunction( jQuery.fn[ name ] ) ) {
     95                if ( elem && !rnoAttrNodeType.test( nType ) && jQuery.isFunction( jQuery.fn[ name ] ) ) {
    9096                        return jQuery( elem )[ name ]( value );
    9197                }
    9298        }
     
    96102                migrateWarn("Can't change the 'type' of an input or button in IE 6/7/8");
    97103        }
    98104
     105        // Restore boolHook for boolean property/attribute synchronization
     106        if ( !jQuery.attrHooks[ lowerName ] && rboolean.test( lowerName ) ) {
     107                jQuery.attrHooks[ lowerName ] = {
     108                        get: function( elem, name ) {
     109                                // Align boolean attributes with corresponding properties
     110                                // Fall back to attribute presence where some booleans are not supported
     111                                var attrNode,
     112                                        property = jQuery.prop( elem, name );
     113                                return property === true || typeof property !== "boolean" &&
     114                                        ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
     115
     116                                        name.toLowerCase() :
     117                                        undefined;
     118                        },
     119                        set: function( elem, value, name ) {
     120                                var propName;
     121                                if ( value === false ) {
     122                                        // Remove boolean attributes when set to false
     123                                        jQuery.removeAttr( elem, name );
     124                                } else {
     125                                        // value is true since we know at this point it's type boolean and not false
     126                                        // Set boolean attributes to the same name and set the DOM property
     127                                        propName = jQuery.propFix[ name ] || name;
     128                                        if ( propName in elem ) {
     129                                                // Only set the IDL specifically if it already exists on the element
     130                                                elem[ propName ] = true;
     131                                        }
     132
     133                                        elem.setAttribute( name, name.toLowerCase() );
     134                                }
     135                                return name;
     136                        }
     137                };
     138
     139                // Warn only for attributes that can remain distinct from their properties post-1.9
     140                if ( ruseDefault.test( lowerName ) ) {
     141                        migrateWarn( "jQuery.fn.attr(" + lowerName + ") may use property instead of attribute" );
     142                }
     143        }
     144
    99145        return attr.call( jQuery, elem, name, value );
    100146};
    101147
    102148// attrHooks: value
    103149jQuery.attrHooks.value = {
    104150        get: function( elem, name ) {
    105                 if ( jQuery.nodeName( elem, "button" ) ) {
     151                var nodeName = ( elem.nodeName || "" ).toLowerCase();
     152                if ( nodeName === "button" ) {
    106153                        return valueAttrGet.apply( this, arguments );
    107154                }
    108                 migrateWarn("property-based jQuery.fn.attr('value') is deprecated");
     155                if ( nodeName !== "input" && nodeName !== "option" ) {
     156                        migrateWarn("property-based jQuery.fn.attr('value') is deprecated");
     157                }
    109158                return name in elem ?
    110159                        elem.value :
    111160                        null;
    112161        },
    113         set: function( elem, value, name ) {
    114                 if ( jQuery.nodeName( elem, "button" ) ) {
     162        set: function( elem, value ) {
     163                var nodeName = ( elem.nodeName || "" ).toLowerCase();
     164                if ( nodeName === "button" ) {
    115165                        return valueAttrSet.apply( this, arguments );
    116166                }
    117                 migrateWarn("property-based jQuery.fn.attr('value', val) is deprecated");
     167                if ( nodeName !== "input" && nodeName !== "option" ) {
     168                        migrateWarn("property-based jQuery.fn.attr('value', val) is deprecated");
     169                }
    118170                // Does not return so that setAttribute is also used
    119171                elem.value = value;
    120172        }
     
    122174
    123175
    124176var matched, browser,
    125         oldAccess = jQuery.access,
    126177        oldInit = jQuery.fn.init,
    127178        // Note this does NOT include the # XSS fix from 1.7!
    128         rquickExpr = /^(?:.*(<[\w\W]+>)[^>]*|#([\w-]*))$/;
     179        rquickExpr = /^(?:.*(<[\w\W]+>)[^>]*|#([\w\-]*))$/;
    129180
    130181// $(html) "looks like html" rule change
    131182jQuery.fn.init = function( selector, context, rootjQuery ) {
     
    151202};
    152203jQuery.fn.init.prototype = jQuery.fn;
    153204
    154 if ( jQuery.fn.jquery >= "1.9" ) {
    155         // jQuery.access( ..., pass )
    156         jQuery.access = function( elems, fn, key, value, chainable, emptyGet, pass ) {
    157                 var i = 0,
    158                         length = elems.length;
    159 
    160                 if ( key && typeof key === "object" && value ) {
    161                         for ( i in key ) {
    162                                 jQuery.access( elems, fn, i, key[i], true, emptyGet, value );
    163                         }
    164                         return elems;
    165                 } else if ( pass && key != null && value !== undefined ) {
    166                         for ( ; i < length; i++ ) {
    167                                 fn( elems[i], key, value, true );
    168                         }
    169                         return elems;
    170                 }
    171                 return oldAccess.call( jQuery, elems, fn, key, value, chainable, emptyGet );
    172         };
    173 }
    174 
    175205jQuery.uaMatch = function( ua ) {
    176206        ua = ua.toLowerCase();
    177207
     
    250280};
    251281
    252282
    253 var oldSelf = jQuery.fn.andSelf || jQuery.fn.addBack,
    254         oldFragment = jQuery.buildFragment;
     283var oldSelf = jQuery.fn.andSelf || jQuery.fn.addBack;
    255284
    256285jQuery.fn.andSelf = function() {
    257286        migrateWarn("jQuery.fn.andSelf() replaced by jQuery.fn.addBack()");
    258287        return oldSelf.apply( this, arguments );
    259288};
    260289
    261 jQuery.buildFragment = function( args, context, scripts ) {
    262         var fragment;
     290// Since jQuery.clean is used internally on older versions, we only shim if it's missing
     291if ( !jQuery.clean ) {
     292        jQuery.clean = function( elems, context, fragment, scripts, selection ) {
     293                var newFragment = jQuery.buildFragment( elems, context || document, scripts, selection );
    263294
    264         if ( !oldFragment ) {
    265                 // Set context from what may come in as undefined or a jQuery collection or a node
    266                 // Updated to fix #12266 where accessing context[0] could throw an exception in IE9/10 &
    267                 // also doubles as fix for #8950 where plain objects caused createDocumentFragment exception
    268                 context = context || document;
    269                 context = !context.nodeType && context[0] || context;
    270                 context = context.ownerDocument || context;
     295                migrateWarn("jQuery.clean() is deprecated");
     296                if ( fragment ) {
     297                        fragment.appendChild( newFragment );
    271298
    272                 fragment = context.createDocumentFragment();
    273                 jQuery.clean( args, context, fragment, scripts );
     299                } else {
     300                        fragment = newFragment;
     301                }
    274302
    275                 migrateWarn("jQuery.buildFragment() is deprecated");
    276                 return { fragment: fragment, cacheable: false };
    277         }
    278         // Don't warn if we are in a version where buildFragment is used internally
    279         return oldFragment.apply( this, arguments );
    280 };
     303                return jQuery.merge( [], fragment.childNodes );
     304        };
     305}
    281306
    282307var eventAdd = jQuery.event.add,
    283308        eventRemove = jQuery.event.remove,
     
    314339        eventRemove.call( this, elem, hoverHack( types ) || "", handler, selector, mappedTypes );
    315340};
    316341
    317 jQuery.fn.error = function( data, fn ) {
     342jQuery.fn.error = function() {
    318343        var args = Array.prototype.slice.call( arguments, 0);
    319344        migrateWarn("jQuery.fn.error() is deprecated");
    320345        args.splice( 0, 0, "error" );
     
    387412jQuery.each( ajaxEvents.split("|"),
    388413        function( _, name ) {
    389414                jQuery.event.special[ name ] = {
    390                         setup: function( data ) {
     415                        setup: function() {
    391416                                var elem = this;
    392417
    393418                                // The document needs no shimming; must be !== for oldIE
    394419                                if ( elem !== document ) {
    395                                         jQuery.event.add( document, name + "." + jQuery.guid, function( event ) {
     420                                        jQuery.event.add( document, name + "." + jQuery.guid, function() {
    396421                                                jQuery.event.trigger( name, null, elem, true );
    397422                                        });
    398423                                        jQuery._data( this, name, jQuery.guid++ );
    399424                                }
    400425                                return false;
    401426                        },
    402                         teardown: function( data, handleObj ) {
     427                        teardown: function() {
    403428                                if ( this !== document ) {
    404429                                        jQuery.event.remove( document, name + "." + jQuery._data( this, name ) );
    405430                                }
    406431                                return false;
    407432                        }
    408                 }
     433                };
    409434        }
    410435);
    411436