Changeset 23301

Timestamp:

01/15/2013 05:52:42 PM (12 years ago)

Author:

nacin

Message:

jQuery 1.9 final. jQuery Migrate 1.0. Uncompressed for now, while we iron out kinks.

props jorbin. see #22975.

Location:

trunk/wp-includes

Files:

• js/jquery/jquery-migrate.js (modified) (18 diffs)
• js/jquery/jquery.js (modified) (109 diffs)
• script-loader.php (modified) (1 diff)

trunk/wp-includes/js/jquery/jquery-migrate.js

@@ -1 +1 @@
 /*!
- * jQuery Migrate - v1.0.0pre - 2012-12-17
+ * jQuery Migrate - v1.0.0 - 2013-01-14
  * https://github.com/jquery/jquery-migrate
- * Copyright 2012 jQuery Foundation and other contributors; Licensed MIT
+ * Copyright 2005, 2013 jQuery Foundation, Inc. and other contributors; Licensed MIT
  */
-
 (function( jQuery, window, undefined ) {
 "use strict";
 
-// Use Uglify to do conditional compilation of warning messages;
-// the minified version will set this to false and remove dead code.
-if ( typeof window.JQMIGRATE_WARN === "undefined" ) {
-    window.JQMIGRATE_WARN = true;
-}
-
 
 var warnedAbout = {};
@@ -19 +12 @@
 // List of warnings already given; public read only
 jQuery.migrateWarnings = [];
+
+// Set to true to prevent console output; migrateWarnings still maintained
+// jQuery.migrateMute = false;
 
 // Forget any warnings we've already given; public
@@ -27 +23 @@
 
 function migrateWarn( msg) {
-    if ( window.JQMIGRATE_WARN ) {
-        if ( !warnedAbout[ msg ] ) {
-            warnedAbout[ msg ] = true;
-            jQuery.migrateWarnings.push( msg );
-            if ( window.console && console.warn ) {
-                console.warn( "JQMIGRATE: " + msg );
-            }
+    if ( !warnedAbout[ msg ] ) {
+        warnedAbout[ msg ] = true;
+        jQuery.migrateWarnings.push( msg );
+        if ( window.console && console.warn && !jQuery.migrateMute ) {
+            console.warn( "JQMIGRATE: " + msg );
         }
     }
@@ -39 +33 @@
 
 function migrateWarnProp( obj, prop, value, msg ) {
-    if ( window.JQMIGRATE_WARN && Object.defineProperty ) {
+    if ( Object.defineProperty ) {
         // On ES5 browsers (non-oldIE), warn if the code tries to get prop;
         // allow property to be overwritten in case some other plugin wants it
@@ -66 +60 @@
 }
 
-if ( window.JQMIGRATE_WARN && document.compatMode === "BackCompat" ) {
+if ( document.compatMode === "BackCompat" ) {
     // jQuery has never supported or tested Quirks Mode
     migrateWarn( "jQuery is not compatible with Quirks Mode" );
@@ -79 +73 @@
         function() { return undefined; },
     rnoType = /^(?:input|button)$/i,
-    rnoAttrNodeType = /^[238]$/;
+    rnoAttrNodeType = /^[238]$/,
+    rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
+    ruseDefault = /^(?:checked|selected)$/i;
 
 // jQuery.attrFn
@@ -85 +81 @@
 
 jQuery.attr = function( elem, name, value, pass ) {
+    var lowerName = name.toLowerCase(),
+        nType = elem && elem.nodeType;
+
     if ( pass ) {
         migrateWarn("jQuery.fn.attr( props, pass ) is deprecated");
-        if ( elem && !rnoAttrNodeType.test( elem.nodeType ) && jQuery.isFunction( jQuery.fn[ name ] ) ) {
+        if ( elem && !rnoAttrNodeType.test( nType ) && jQuery.isFunction( jQuery.fn[ name ] ) ) {
             return jQuery( elem )[ name ]( value );
         }
@@ -97 +96 @@
     }
 
+    // Restore boolHook for boolean property/attribute synchronization
+    if ( !jQuery.attrHooks[ lowerName ] && rboolean.test( lowerName ) ) {
+        jQuery.attrHooks[ lowerName ] = {
+            get: function( elem, name ) {
+                // Align boolean attributes with corresponding properties
+                // Fall back to attribute presence where some booleans are not supported
+                var attrNode,
+                    property = jQuery.prop( elem, name );
+                return property === true || typeof property !== "boolean" &&
+                    ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
+
+                    name.toLowerCase() :
+                    undefined;
+            },
+            set: function( elem, value, name ) {
+                var propName;
+                if ( value === false ) {
+                    // Remove boolean attributes when set to false
+                    jQuery.removeAttr( elem, name );
+                } else {
+                    // value is true since we know at this point it's type boolean and not false
+                    // Set boolean attributes to the same name and set the DOM property
+                    propName = jQuery.propFix[ name ] || name;
+                    if ( propName in elem ) {
+                        // Only set the IDL specifically if it already exists on the element
+                        elem[ propName ] = true;
+                    }
+
+                    elem.setAttribute( name, name.toLowerCase() );
+                }
+                return name;
+            }
+        };
+
+        // Warn only for attributes that can remain distinct from their properties post-1.9
+        if ( ruseDefault.test( lowerName ) ) {
+            migrateWarn( "jQuery.fn.attr(" + lowerName + ") may use property instead of attribute" );
+        }
+    }
+
     return attr.call( jQuery, elem, name, value );
 };
@@ -103 +142 @@
 jQuery.attrHooks.value = {
     get: function( elem, name ) {
-        if ( jQuery.nodeName( elem, "button" ) ) {
+        var nodeName = ( elem.nodeName || "" ).toLowerCase();
+        if ( nodeName === "button" ) {
             return valueAttrGet.apply( this, arguments );
         }
-        migrateWarn("property-based jQuery.fn.attr('value') is deprecated");
+        if ( nodeName !== "input" && nodeName !== "option" ) {
+            migrateWarn("property-based jQuery.fn.attr('value') is deprecated");
+        }
         return name in elem ?
             elem.value :
             null;
     },
-    set: function( elem, value, name ) {
-        if ( jQuery.nodeName( elem, "button" ) ) {
+    set: function( elem, value ) {
+        var nodeName = ( elem.nodeName || "" ).toLowerCase();
+        if ( nodeName === "button" ) {
             return valueAttrSet.apply( this, arguments );
         }
-        migrateWarn("property-based jQuery.fn.attr('value', val) is deprecated");
+        if ( nodeName !== "input" && nodeName !== "option" ) {
+            migrateWarn("property-based jQuery.fn.attr('value', val) is deprecated");
+        }
         // Does not return so that setAttribute is also used
         elem.value = value;
@@ -123 +168 @@
 
 var matched, browser,
-    oldAccess = jQuery.access,
     oldInit = jQuery.fn.init,
     // Note this does NOT include the # XSS fix from 1.7!
-    rquickExpr = /^(?:.*(<[\w\W]+>)[^>]*|#([\w-]*))$/;
+    rquickExpr = /^(?:.*(<[\w\W]+>)[^>]*|#([\w\-]*))$/;
 
 // $(html) "looks like html" rule change
@@ -151 +195 @@
 };
 jQuery.fn.init.prototype = jQuery.fn;
-
-if ( jQuery.fn.jquery >= "1.9" ) {
-    // jQuery.access( ..., pass )
-    jQuery.access = function( elems, fn, key, value, chainable, emptyGet, pass ) {
-        var i = 0,
-            length = elems.length;
-
-        if ( key && typeof key === "object" && value ) {
-            for ( i in key ) {
-                jQuery.access( elems, fn, i, key[i], true, emptyGet, value );
-            }
-            return elems;
-        } else if ( pass && key != null && value !== undefined ) {
-            for ( ; i < length; i++ ) {
-                fn( elems[i], key, value, true );
-            }
-            return elems;
-        }
-        return oldAccess.call( jQuery, elems, fn, key, value, chainable, emptyGet );
-    };
-}
 
 jQuery.uaMatch = function( ua ) {
@@ -251 +274 @@
 
 
-var oldSelf = jQuery.fn.andSelf || jQuery.fn.addBack,
+var rscriptType = /\/(java|ecma)script/i,
+    oldSelf = jQuery.fn.andSelf || jQuery.fn.addBack,
     oldFragment = jQuery.buildFragment;
 
@@ -259 +283 @@
 };
 
-jQuery.buildFragment = function( args, context, scripts ) {
-    var fragment;
-
-    if ( !oldFragment ) {
-        // Set context from what may come in as undefined or a jQuery collection or a node
-        // Updated to fix #12266 where accessing context[0] could throw an exception in IE9/10 &
-        // also doubles as fix for #8950 where plain objects caused createDocumentFragment exception
+// Since jQuery.clean is used internally on older versions, we only shim if it's missing
+if ( !jQuery.clean ) {
+    jQuery.clean = function( elems, context, fragment, scripts ) {
+        // Set context per 1.8 logic
         context = context || document;
         context = !context.nodeType && context[0] || context;
         context = context.ownerDocument || context;
 
-        fragment = context.createDocumentFragment();
-        jQuery.clean( args, context, fragment, scripts );
-
-        migrateWarn("jQuery.buildFragment() is deprecated");
-        return { fragment: fragment, cacheable: false };
-    }
-    // Don't warn if we are in a version where buildFragment is used internally
-    return oldFragment.apply( this, arguments );
+        migrateWarn("jQuery.clean() is deprecated");
+
+        var i, elem, handleScript, jsTags,
+            ret = [];
+
+        jQuery.merge( ret, jQuery.buildFragment( elems, context ).childNodes );
+
+        // Complex logic lifted directly from jQuery 1.8
+        if ( fragment ) {
+            // Special handling of each script element
+            handleScript = function( elem ) {
+                // Check if we consider it executable
+                if ( !elem.type || rscriptType.test( elem.type ) ) {
+                    // Detach the script and store it in the scripts array (if provided) or the fragment
+                    // Return truthy to indicate that it has been handled
+                    return scripts ?
+                        scripts.push( elem.parentNode ? elem.parentNode.removeChild( elem ) : elem ) :
+                        fragment.appendChild( elem );
+                }
+            };
+
+            for ( i = 0; (elem = ret[i]) != null; i++ ) {
+                // Check if we're done after handling an executable script
+                if ( !( jQuery.nodeName( elem, "script" ) && handleScript( elem ) ) ) {
+                    // Append to fragment and handle embedded scripts
+                    fragment.appendChild( elem );
+                    if ( typeof elem.getElementsByTagName !== "undefined" ) {
+                        // handleScript alters the DOM, so use jQuery.merge to ensure snapshot iteration
+                        jsTags = jQuery.grep( jQuery.merge( [], elem.getElementsByTagName("script") ), handleScript );
+
+                        // Splice the scripts into ret after their former ancestor and advance our index beyond them
+                        ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
+                        i += jsTags.length;
+                    }
+                }
+            }
+        }
+
+        return ret;
+    };
+}
+
+jQuery.buildFragment = function( elems, context, scripts, selection ) {
+    var ret,
+        warning = "jQuery.buildFragment() is deprecated";
+
+    // Set context per 1.8 logic
+    context = context || document;
+    context = !context.nodeType && context[0] || context;
+    context = context.ownerDocument || context;
+
+    try {
+        ret = oldFragment.call( jQuery, elems, context, scripts, selection );
+
+    // jQuery < 1.8 required arrayish context; jQuery 1.9 fails on it
+    } catch( x ) {
+        ret = oldFragment.call( jQuery, elems, context.nodeType ? [ context ] : context[ 0 ], scripts, selection );
+
+        // Success from tweaking context means buildFragment was called by the user
+        migrateWarn( warning );
+    }
+
+    // jQuery < 1.9 returned an object instead of the fragment itself
+    if ( !ret.fragment ) {
+        migrateWarnProp( ret, "fragment", ret, warning );
+        migrateWarnProp( ret, "cacheable", false, warning );
+    }
+
+    return ret;
 };
 
@@ -304 +386 @@
 }
 
+// Undocumented jQuery.event.handle was "deprecated" in jQuery 1.7
+migrateWarnProp( jQuery.event, "handle", jQuery.event.dispatch, "jQuery.event.handle is undocumented and deprecated" );
+
 // Support for 'hover' pseudo-event and ajax event warnings
 jQuery.event.add = function( elem, types, handler, data, selector ){
@@ -315 +400 @@
 };
 
-jQuery.fn.error = function( data, fn ) {
+jQuery.fn.error = function() {
     var args = Array.prototype.slice.call( arguments, 0);
     migrateWarn("jQuery.fn.error() is deprecated");
@@ -388 +473 @@
     function( _, name ) {
         jQuery.event.special[ name ] = {
-            setup: function( data ) {
+            setup: function() {
                 var elem = this;
 
                 // The document needs no shimming; must be !== for oldIE
                 if ( elem !== document ) {
-                    jQuery.event.add( document, name + "." + jQuery.guid, function( event ) {
+                    jQuery.event.add( document, name + "." + jQuery.guid, function() {
                         jQuery.event.trigger( name, null, elem, true );
                     });
@@ -400 +485 @@
                 return false;
             },
-            teardown: function( data, handleObj ) {
+            teardown: function() {
                 if ( this !== document ) {
                     jQuery.event.remove( document, name + "." + jQuery._data( this, name ) );
@@ -406 +491 @@
                 return false;
             }
-        }
+        };
     }
 );

trunk/wp-includes/js/jquery/jquery.js

@@ -1 +1 @@
 /*!
- * jQuery JavaScript Library v1.9.0b1
+ * jQuery JavaScript Library v1.9.0
  * http://jquery.com/
  *
@@ -6 +6 @@
  * http://sizzlejs.com/
  *
- * Copyright 2012 jQuery Foundation and other contributors
+ * Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors
  * Released under the MIT license
  * http://jquery.org/license
  *
- * Date: 2012-12-16
+ * Date: 2013-1-14
  */
 (function( window, undefined ) {
@@ -37 +37 @@
     core_deletedIds = [],
 
-    core_version = "1.9.0b1",
+    core_version = "1.9.0",
 
     // Save a reference to some core methods
@@ -112 +112 @@
         }
 
-        // HANDLE: $(DOMElement)
-        if ( selector.nodeType ) {
-            this.context = this[0] = selector;
-            this.length = 1;
-            return this;
-        }
-
         // Handle HTML strings
         if ( typeof selector === "string" ) {
@@ -192 +185 @@
             }
 
+        // HANDLE: $(DOMElement)
+        } else if ( selector.nodeType ) {
+            this.context = this[0] = selector;
+            this.length = 1;
+            return this;
+
         // HANDLE: $(function)
         // Shortcut for document ready
@@ -443 +442 @@
 
     type: function( obj ) {
-        return obj == null ?
-            String( obj ) :
-            class2type[ core_toString.call(obj) ] || "object";
+        if ( obj == null ) {
+            return String( obj );
+        }
+        return typeof obj === "object" || typeof obj === "function" ?
+            class2type[ core_toString.call(obj) ] || "object" :
+            typeof obj;
     },
 
@@ -510 +512 @@
         }
 
-        parsed = context.createDocumentFragment();
-        jQuery.clean( [ data ], context, parsed, scripts );
+        parsed = jQuery.buildFragment( [ data ], context, scripts );
         if ( scripts ) {
             jQuery( scripts ).remove();
@@ -1165 +1166 @@
                         jQuery.each( tuples, function( i, tuple ) {
                             var action = tuple[ 0 ],
-                                fn = fns[ i ];
+                                fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
                             // deferred[ done | fail | progress ] for forwarding actions to newDefer
-                            deferred[ tuple[1] ]( jQuery.isFunction( fn ) ?
-                                function() {
-                                    var returned = fn.apply( this, arguments );
-                                    if ( returned && jQuery.isFunction( returned.promise ) ) {
-                                        returned.promise()
-                                            .done( newDefer.resolve )
-                                            .fail( newDefer.reject )
-                                            .progress( newDefer.notify );
-                                    } else {
-                                        newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, [ returned ] );
-                                    }
-                                } :
-                                newDefer[ action ]
-                            );
+                            deferred[ tuple[1] ](function() {
+                                var returned = fn && fn.apply( this, arguments );
+                                if ( returned && jQuery.isFunction( returned.promise ) ) {
+                                    returned.promise()
+                                        .done( newDefer.resolve )
+                                        .fail( newDefer.reject )
+                                        .progress( newDefer.notify );
+                                } else {
+                                    newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
+                                }
+                            });
                         });
                         fns = null;
@@ -1216 +1214 @@
             // deferred[ resolve | reject | notify ]
             deferred[ tuple[0] ] = function() {
-                deferred[ tuple[0] + "With" ]( promise, arguments );
+                deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
                 return this;
             };
@@ -1288 +1286 @@
 jQuery.support = (function() {
 
-    var support,
-        all,
-        a,
-        select,
-        opt,
-        input,
-        fragment,
-        eventName,
-        i,
-        isSupported,
-        clickFn,
+    var support, all, a, select, opt, input, fragment, eventName, isSupported, i,
         div = document.createElement("div");
 
@@ -1368 +1356 @@
 
         // Will be defined later
-        submitBubbles: true,
-        changeBubbles: true,
-        focusinBubbles: false,
         deleteExpando: true,
         noCloneEvent: true,
@@ -1389 +1374 @@
     support.optDisabled = !opt.disabled;
 
-    // Test to see if it's possible to delete an expando from an element
-    // Fails in Internet Explorer
+    // Support: IE<9
     try {
         delete div.test;
@@ -1397 +1381 @@
     }
 
-    if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
-        div.attachEvent( "onclick", clickFn = function() {
-            // Cloning a node shouldn't copy over any
-            // bound event handlers (IE does this)
-            support.noCloneEvent = false;
-        });
-        div.cloneNode( true ).fireEvent("onclick");
-        div.detachEvent( "onclick", clickFn );
-    }
-
     // Check if we can trust getAttribute("value")
     input = document.createElement("input");
@@ -1418 +1392 @@
 
     // #11217 - WebKit loses check when the name is after the checked attribute
-    input.setAttribute( "checked", "checked" );
+    input.setAttribute( "checked", "t" );
     input.setAttribute( "name", "t" );
 
-    div.appendChild( input );
     fragment = document.createDocumentFragment();
-    fragment.appendChild( div.lastChild );
-
-    // WebKit doesn't clone checked state correctly in fragments
-    support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
+    fragment.appendChild( input );
 
     // Check if a disconnected checkbox will retain its checked
@@ -1432 +1402 @@
     support.appendChecked = input.checked;
 
-    fragment.removeChild( input );
-    fragment.appendChild( div );
-
-    // Technique from Juriy Zaytsev
-    // http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
-    // We only care about the case where non-standard event systems
-    // are used, namely in IE. Short-circuiting here helps us to
-    // avoid an eval call (in setAttribute) which can cause CSP
-    // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
+    // WebKit doesn't clone checked state correctly in fragments
+    support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
+
+    // Support: IE<9
+    // Opera does not clone events (and typeof div.attachEvent === undefined).
+    // IE9-10 clones events bound via attachEvent, but they don't trigger with .click()
     if ( div.attachEvent ) {
-        for ( i in {
-            submit: true,
-            change: true,
-            focusin: true
-        }) {
-            eventName = "on" + i;
-            isSupported = ( eventName in div );
-            if ( !isSupported ) {
-                div.setAttribute( eventName, "return;" );
-                isSupported = ( typeof div[ eventName ] === "function" );
-            }
-            support[ i + "Bubbles" ] = isSupported;
-        }
-    }
+        div.attachEvent( "onclick", function() {
+            support.noCloneEvent = false;
+        });
+
+        div.cloneNode( true ).click();
+    }
+
+    // Support: IE<9 (lack submit/change bubble), Firefox 17+ (lack focusin event)
+    // Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP), test/csp.php
+    for ( i in { submit: true, change: true, focusin: true }) {
+        div.setAttribute( eventName = "on" + i, "t" );
+
+        support[ i + "Bubbles" ] = eventName in window || div.attributes[ eventName ].expando === false;
+    }
+
+    div.style.backgroundClip = "content-box";
+    div.cloneNode( true ).style.backgroundClip = "";
+    support.clearCloneStyle = div.style.backgroundClip === "content-box";
 
     // Run tests that need a body at doc ready
     jQuery(function() {
-        var container, div, tds, marginDiv,
-            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;",
+        var container, marginDiv, tds,
+            divReset = "padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;",
             body = document.getElementsByTagName("body")[0];
 
@@ -1469 +1440 @@
 
         container = document.createElement("div");
-        container.style.cssText = "visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px";
-        body.insertBefore( container, body.firstChild );
-
-        // Construct the test element
-        div = document.createElement("div");
-        container.appendChild( div );
-
+        container.style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px";
+
+        body.appendChild( container ).appendChild( div );
+
+        // Support: IE8
         // Check if table cells still have offsetWidth/Height when they are set
         // to display:none and there are still other visible table cells in a
@@ -1482 +1451 @@
         // display:none (it is still safe to use offsets if a parent element is
         // hidden; don safety goggles and see bug #4512 for more information).
-        // (only IE 8 fails this test)
         div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
         tds = div.getElementsByTagName("td");
@@ -1491 +1459 @@
         tds[ 1 ].style.display = "none";
 
+        // Support: IE8
         // Check if empty table cells still have offsetWidth/Height
-        // (IE <= 8 fail this test)
         support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
 
@@ -1501 +1469 @@
         support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 );
 
-        // NOTE: To any future maintainer, we've window.getComputedStyle
-        // because jsdom on node.js will break without it.
+        // Use window.getComputedStyle because jsdom on node.js will break without it.
         if ( window.getComputedStyle ) {
             support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
@@ -1508 +1475 @@
 
             // Check if div with explicit width and no margin-right incorrectly
-            // gets computed margin-right based on width of container. For more
-            // info see bug #3333
+            // gets computed margin-right based on width of container. (#3333)
             // Fails in WebKit before Feb 2011 nightlies
             // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
-            marginDiv = document.createElement("div");
+            marginDiv = div.appendChild( document.createElement("div") );
             marginDiv.style.cssText = div.style.cssText = divReset;
             marginDiv.style.marginRight = marginDiv.style.width = "0";
             div.style.width = "1px";
-            div.appendChild( marginDiv );
+
             support.reliableMarginRight =
                 !parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight );
@@ -1522 +1488 @@
 
         if ( typeof div.style.zoom !== "undefined" ) {
+            // Support: IE<8
             // Check if natively block-level elements act like inline-block
             // elements when setting their display to 'inline' and giving
             // them layout
-            // (IE < 8 does this)
             div.innerHTML = "";
             div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
             support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
 
+            // Support: IE6
             // Check if elements with layout shrink-wrap their children
-            // (IE 6 does this)
             div.style.display = "block";
-            div.style.overflow = "visible";
             div.innerHTML = "<div></div>";
             div.firstChild.style.width = "5px";
@@ -1543 +1508 @@
         }
 
+        body.removeChild( container );
+
         // Null elements to avoid leaks in IE
-        body.removeChild( container );
         container = div = tds = marginDiv = null;
     });
 
     // Null elements to avoid leaks in IE
-    fragment.removeChild( div );
-    all = a = select = opt = input = fragment = div = null;
+    all = select = fragment = opt = a = input = null;
 
     return support;
 })();
+
 var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
     rmultiDash = /([A-Z])/g;
-
+    
 function internalData( elem, name, data, pvt /* Internal Use Only */ ){
     if ( !jQuery.acceptData( elem ) ) {
@@ -1772 +1738 @@
         return internalData( elem, name, data, true );
     },
-
+    
     _removeData: function( elem, name ) {
         return internalRemoveData( elem, name, true );
@@ -1927 +1893 @@
         }
 
+        hooks.cur = fn;
         if ( fn ) {
 
@@ -2368 +2335 @@
         } else {
 
-            ret = elem.getAttribute( name );
+            // In IE9+, Flash objects don't have .getAttribute (#12945)
+            // Support: IE9+
+            if ( typeof elem.getAttribute !== "undefined" ) {
+                ret =  elem.getAttribute( name );
+            }
 
             // Non-existent attributes return null, we normalize to undefined
@@ -2638 +2609 @@
         get: function( elem ) {
             // Return undefined in the case of empty string
-            // Normalize to lowercase since IE uppercases css property names
-            return elem.style.cssText.toLowerCase() || undefined;
+            // Note: IE uppercases css property names, but if we were to .toLowerCase()
+            // .cssText, that would destroy case senstitivity in URL's, like in "background"
+            return elem.style.cssText || undefined;
         },
         set: function( elem, value ) {
@@ -2698 +2670 @@
     rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
 
+function returnTrue() {
+    return true;
+}
+
+function returnFalse() {
+    return false;
+}
+
 /*
  * Helper functions for managing events -- not part of the public interface.
@@ -2704 +2684 @@
 jQuery.event = {
 
+    global: {},
+
     add: function( elem, types, handler, data, selector ) {
-        var elemData, eventHandle, events,
-            tns, type, namespaces, handleObj,
-            handleObjIn, handlers, special,
-            t = 0;
-
-        // Don't attach events to noData or text/comment nodes (allow plain objects tho)
-        if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
+
+        var handleObjIn, eventHandle, tmp,
+            events, t, handleObj,
+            special, handlers, type, namespaces, origType,
+            // Don't attach events to noData or text/comment nodes (but allow plain objects)
+            elemData = elem.nodeType !== 3 && elem.nodeType !== 8 && jQuery._data( elem );
+
+        if ( !elemData ) {
             return;
         }
@@ -2728 +2711 @@
 
         // Init the element's event structure and main handler, if this is the first
-        events = elemData.events;
-        if ( !events ) {
-            elemData.events = events = {};
-        }
-        eventHandle = elemData.handle;
-        if ( !eventHandle ) {
-            elemData.handle = eventHandle = function( e ) {
+        if ( !(events = elemData.events) ) {
+            events = elemData.events = {};
+        }
+        if ( !(eventHandle = elemData.handle) ) {
+            eventHandle = elemData.handle = function( e ) {
                 // Discard the second event of a jQuery.event.trigger() and
                 // when an event is called after a page has unloaded
@@ -2748 +2729 @@
         // jQuery(...).bind("mouseover mouseout", fn);
         types = ( types || "" ).match( core_rnotwhite ) || [""];
-        for ( ; t < types.length; t++ ) {
-
-            tns = rtypenamespace.exec( types[t] ) || [];
-            type = tns[1];
-            namespaces = ( tns[2] || "" ).split( "." ).sort();
+        t = types.length;
+        while ( t-- ) {
+            tmp = rtypenamespace.exec( types[t] ) || [];
+            type = origType = tmp[1];
+            namespaces = ( tmp[2] || "" ).split( "." ).sort();
 
             // If event changes its type, use the special event handlers for the changed type
@@ -2766 +2747 @@
             handleObj = jQuery.extend({
                 type: type,
-                origType: tns[1],
+                origType: origType,
                 data: data,
                 handler: handler,
@@ -2776 +2757 @@
 
             // Init the event handler queue if we're the first
-            handlers = events[ type ];
-            if ( !handlers ) {
+            if ( !(handlers = events[ type ]) ) {
                 handlers = events[ type ] = [];
                 handlers.delegateCount = 0;
@@ -2816 +2796 @@
     },
 
-    global: {},
-
     // Detach an event or set of events from an element
     remove: function( elem, types, handler, selector, mappedTypes ) {
 
-        var tns, type, origType, namespaces, origCount,
-            j, events, special, eventType, handleObj,
-            t = 0,
+        var j, origCount, tmp,
+            events, t, handleObj,
+            special, handlers, type, namespaces, origType,
             elemData = jQuery.hasData( elem ) && jQuery._data( elem );
 
@@ -2832 +2810 @@
         // Once for each type.namespace in types; type may be omitted
         types = ( types || "" ).match( core_rnotwhite ) || [""];
-        for ( ; t < types.length; t++ ) {
-            tns = rtypenamespace.exec( types[t] ) || [];
-            type = origType = tns[1];
-            namespaces = tns[2];
+        t = types.length;
+        while ( t-- ) {
+            tmp = rtypenamespace.exec( types[t] ) || [];
+            type = origType = tmp[1];
+            namespaces = ( tmp[2] || "" ).split( "." ).sort();
 
             // Unbind all events (on this namespace, if provided) for the element
@@ -2846 +2825 @@
 
             special = jQuery.event.special[ type ] || {};
-            type = ( selector? special.delegateType : special.bindType ) || type;
-            eventType = events[ type ] || [];
-            origCount = eventType.length;
-            namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
+            type = ( selector ? special.delegateType : special.bindType ) || type;
+            handlers = events[ type ] || [];
+            tmp = tmp[2] && new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" );
 
             // Remove matching events
-            for ( j = 0; j < eventType.length; j++ ) {
-                handleObj = eventType[ j ];
+            origCount = j = handlers.length;
+            while ( j-- ) {
+                handleObj = handlers[ j ];
 
                 if ( ( mappedTypes || origType === handleObj.origType ) &&
                     ( !handler || handler.guid === handleObj.guid ) &&
-                    ( !namespaces || namespaces.test( handleObj.namespace ) ) &&
+                    ( !tmp || tmp.test( handleObj.namespace ) ) &&
                     ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
-                    eventType.splice( j--, 1 );
+                    handlers.splice( j, 1 );
 
                     if ( handleObj.selector ) {
-                        eventType.delegateCount--;
+                        handlers.delegateCount--;
                     }
                     if ( special.remove ) {
@@ -2872 +2851 @@
             // Remove generic event handler if we removed something and no more handlers exist
             // (avoids potential for endless recursion during removal of special event handlers)
-            if ( eventType.length === 0 && origCount !== eventType.length ) {
+            if ( origCount && !handlers.length ) {
                 if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
                     jQuery.removeEvent( elem, type, elemData.handle );
@@ -2893 +2872 @@
     trigger: function( event, data, elem, onlyHandlers ) {
 
-        var i, cur, old, ontype, special, handle, eventPath, bubbleType,
+        var i, cur, tmp, bubbleType, ontype, handle, special,
+            eventPath = [ elem || document ],
             type = event.type || event,
             namespaces = event.namespace ? event.namespace.split(".") : [];
 
-        elem = elem || document;
+        cur = tmp = elem = elem || document;
 
         // Don't do events on text and comment nodes
@@ -2915 +2895 @@
             namespaces.sort();
         }
-
-        // Caller can pass in an Event, Object, or just an event type string
-        event = typeof event === "object" ?
-            // jQuery.Event object
-            event[ jQuery.expando ] ? event :
-            // Object literal
-            new jQuery.Event( type, event ) :
-            // Just the event type (string)
-            new jQuery.Event( type );
-
-        event.type = type;
+        ontype = type.indexOf(":") < 0 && "on" + type;
+
+        // Caller can pass in a jQuery.Event object, Object, or just an event type string
+        event = event[ jQuery.expando ] ?
+            event :
+            new jQuery.Event( type, typeof event === "object" && event );
+
         event.isTrigger = true;
         event.namespace = namespaces.join(".");
-        event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
-        ontype = type.indexOf(":") < 0 ? "on" + type : "";
+        event.namespace_re = event.namespace ?
+            new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ) :
+            null;
 
         // Clean up the event in case it is being reused
@@ -2938 +2915 @@
 
         // Clone any incoming data and prepend the event, creating the handler arg list
-        data = data != null ? jQuery.makeArray( data ) : [];
-        data.unshift( event );
+        data = data == null ?
+            [ event ] :
+            jQuery.makeArray( data, [ event ] );
 
         // Allow special events to draw outside the lines
@@ -2949 +2927 @@
         // Determine event propagation path in advance, per W3C events spec (#9951)
         // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
-        eventPath = [[ elem, special.bindType || type ]];
         if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
 
             bubbleType = special.delegateType || type;
-            cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode;
-            for ( old = elem; cur; cur = cur.parentNode ) {
-                eventPath.push([ cur, bubbleType ]);
-                old = cur;
+            if ( !rfocusMorph.test( bubbleType + type ) ) {
+                cur = cur.parentNode;
+            }
+            for ( ; cur; cur = cur.parentNode ) {
+                eventPath.push( cur );
+                tmp = cur;
             }
 
             // Only add window if we got to document (e.g., not plain obj or detached DOM)
-            if ( old === (elem.ownerDocument || document) ) {
-                eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]);
+            if ( tmp === (elem.ownerDocument || document) ) {
+                eventPath.push( tmp.defaultView || tmp.parentWindow || window );
             }
         }
 
         // Fire handlers on the event path
-        for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) {
-
-            cur = eventPath[i][0];
-            event.type = eventPath[i][1];
-
+        i = 0;
+        while ( (cur = eventPath[i++]) && !event.isPropagationStopped() ) {
+
+            event.type = i > 1 ?
+                bubbleType :
+                special.bindType || type;
+
+            // jQuery handler
             handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
             if ( handle ) {
                 handle.apply( cur, data );
             }
-            // Note that this is a bare JS function and not a jQuery handler
+
+            // Native handler
             handle = ontype && cur[ ontype ];
             if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === false ) {
@@ -2995 +2978 @@
 
                     // Don't re-trigger an onFOO event when we call its FOO() method
-                    old = elem[ ontype ];
-
-                    if ( old ) {
+                    tmp = elem[ ontype ];
+
+                    if ( tmp ) {
                         elem[ ontype ] = null;
                     }
@@ -3011 +2994 @@
                     jQuery.event.triggered = undefined;
 
-                    if ( old ) {
-                        elem[ ontype ] = old;
+                    if ( tmp ) {
+                        elem[ ontype ] = tmp;
                     }
                 }
@@ -3026 +3009 @@
         event = jQuery.event.fix( event );
 
-        var i, j, cur, ret, selMatch, matched, matches, handleObj, sel,
-            handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []),
-            delegateCount = handlers.delegateCount,
+        var i, j, ret, matched, handleObj,
+            handlerQueue = [],
             args = core_slice.call( arguments ),
-            special = jQuery.event.special[ event.type ] || {},
-            handlerQueue = [];
+            handlers = ( jQuery._data( this, "events" ) || {} )[ event.type ] || [],
+            special = jQuery.event.special[ event.type ] || {};
 
         // Use the fix-ed jQuery.Event rather than the (read-only) native event
@@ -3042 +3024 @@
         }
 
-        // Determine handlers that should run if there are delegated events
+        // Determine handlers
+        handlerQueue = jQuery.event.handlers.call( this, event, handlers );
+
+        // Run delegates first; they may want to stop propagation beneath us
+        i = 0;
+        while ( (matched = handlerQueue[ i++ ]) && !event.isPropagationStopped() ) {
+            event.currentTarget = matched.elem;
+
+            j = 0;
+            while ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) {
+
+                // Triggered event must either 1) have no namespace, or
+                // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
+                if ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) {
+
+                    event.handleObj = handleObj;
+                    event.data = handleObj.data;
+
+                    ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
+                            .apply( matched.elem, args );
+
+                    if ( ret !== undefined ) {
+                        if ( (event.result = ret) === false ) {
+                            event.preventDefault();
+                            event.stopPropagation();
+                        }
+                    }
+                }
+            }
+        }
+
+        // Call the postDispatch hook for the mapped type
+        if ( special.postDispatch ) {
+            special.postDispatch.call( this, event );
+        }
+
+        return event.result;
+    },
+
+    handlers: function( event, handlers ) {
+        var i, matches, sel, handleObj,
+            handlerQueue = [],
+            delegateCount = handlers.delegateCount,
+            cur = event.target;
+
+        // Find delegate handlers
+        // Black-hole SVG <use> instance trees (#13180)
         // Avoid non-left-click bubbling in Firefox (#3861)
-        if ( delegateCount && !(event.button && event.type === "click") ) {
-
-            for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {
-
-                // Don't process clicks (ONLY) on disabled elements (#6911, #8165, #11382, #11764)
+        if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) {
+
+            for ( ; cur != this; cur = cur.parentNode || this ) {
+
+                // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
                 if ( cur.disabled !== true || event.type !== "click" ) {
-                    selMatch = {};
                     matches = [];
                     for ( i = 0; i < delegateCount; i++ ) {
                         handleObj = handlers[ i ];
-                        sel = handleObj.selector;
-
-                        if ( selMatch[ sel ] === undefined ) {
-                            selMatch[ sel ] = handleObj.needsContext ?
+
+                        // Don't conflict with Object.prototype properties (#13203)
+                        sel = handleObj.selector + " ";
+
+                        if ( matches[ sel ] === undefined ) {
+                            matches[ sel ] = handleObj.needsContext ?
                                 jQuery( sel, this ).index( cur ) >= 0 :
                                 jQuery.find( sel, this, null, [ cur ] ).length;
                         }
-                        if ( selMatch[ sel ] ) {
+                        if ( matches[ sel ] ) {
                             matches.push( handleObj );
                         }
                     }
                     if ( matches.length ) {
-                        handlerQueue.push({ elem: cur, matches: matches });
+                        handlerQueue.push({ elem: cur, handlers: matches });
                     }
                 }
@@ -3073 +3102 @@
 
         // Add the remaining (directly-bound) handlers
-        if ( handlers.length > delegateCount ) {
-            handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) });
-        }
-
-        // Run delegates first; they may want to stop propagation beneath us
-        for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) {
-            matched = handlerQueue[ i ];
-            event.currentTarget = matched.elem;
-
-            for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) {
-                handleObj = matched.matches[ j ];
-
-                // Triggered event must either 1) have no namespace, or
-                // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
-                if ( !event.namespace || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) {
-
-                    event.data = handleObj.data;
-                    event.handleObj = handleObj;
-
-                    ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
-                            .apply( matched.elem, args );
-
-                    if ( ret !== undefined ) {
-                        event.result = ret;
-                        if ( ret === false ) {
-                            event.preventDefault();
-                            event.stopPropagation();
-                        }
-                    }
-                }
-            }
-        }
-
-        // Call the postDispatch hook for the mapped type
-        if ( special.postDispatch ) {
-            special.postDispatch.call( this, event );
-        }
-
-        return event.result;
+        if ( delegateCount < handlers.length ) {
+            handlerQueue.push({ elem: this, handlers: handlers.slice( delegateCount ) });
+        }
+
+        return handlerQueue;
+    },
+
+    fix: function( event ) {
+        if ( event[ jQuery.expando ] ) {
+            return event;
+        }
+
+        // Create a writable copy of the event object and normalize some properties
+        var i, prop,
+            originalEvent = event,
+            fixHook = jQuery.event.fixHooks[ event.type ] || {},
+            copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
+
+        event = new jQuery.Event( originalEvent );
+
+        i = copy.length;
+        while ( i-- ) {
+            prop = copy[ i ];
+            event[ prop ] = originalEvent[ prop ];
+        }
+
+        // Support: IE<9
+        // Fix target property (#1925)
+        if ( !event.target ) {
+            event.target = originalEvent.srcElement || document;
+        }
+
+        // Support: Chrome 23+, Safari?
+        // Target should not be a text node (#504, #13143)
+        if ( event.target.nodeType === 3 ) {
+            event.target = event.target.parentNode;
+        }
+
+        // Support: IE<9
+        // For mouse/key events, metaKey==false if it's undefined (#3368, #11328)
+        event.metaKey = !!event.metaKey;
+
+        return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
     },
 
@@ -3162 +3195 @@
             return event;
         }
-    },
-
-    fix: function( event ) {
-        if ( event[ jQuery.expando ] ) {
-            return event;
-        }
-
-        // Create a writable copy of the event object and normalize some properties
-        var i, prop,
-            originalEvent = event,
-            fixHook = jQuery.event.fixHooks[ event.type ] || {},
-            copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
-
-        event = jQuery.Event( originalEvent );
-
-        for ( i = copy.length; i; ) {
-            prop = copy[ --i ];
-            event[ prop ] = originalEvent[ prop ];
-        }
-
-        // Fix target property, if necessary (#1925, IE 6/7/8 & Safari2)
-        if ( !event.target ) {
-            event.target = originalEvent.srcElement || document;
-        }
-
-        // Target should not be a text node (#504, Safari)
-        if ( event.target.nodeType === 3 ) {
-            event.target = event.target.parentNode;
-        }
-
-        // For mouse/key events, metaKey==false if it's undefined (#3368, #11328; IE6/7/8)
-        event.metaKey = !!event.metaKey;
-
-        return fixHook.filter? fixHook.filter( event, originalEvent ) : event;
     },
 
@@ -3220 +3219 @@
                         return false;
                     } catch ( e ) {
-                        // IE<9 dies on focus to hidden element (#1486,#12518)
-                        // If this happens, let .trigger() run the handlers
+                        // Support: IE<9
+                        // If we error on focus to hidden element (#1486, #12518),
+                        // let .trigger() run the handlers
                     }
                 }
@@ -3271 +3271 @@
 };
 
-// Some plugins are using, but it's undocumented/deprecated and will be removed.
-// The 1.7 special event interface should provide all the hooks needed now.
-jQuery.event.handle = jQuery.event.dispatch;
-
 jQuery.removeEvent = document.removeEventListener ?
     function( elem, type, handle ) {
@@ -3329 +3325 @@
 };
 
-function returnFalse() {
-    return false;
-}
-function returnTrue() {
-    return true;
-}
-
 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
 jQuery.Event.prototype = {
+    isDefaultPrevented: returnFalse,
+    isPropagationStopped: returnFalse,
+    isImmediatePropagationStopped: returnFalse,
+
     preventDefault: function() {
+        var e = this.originalEvent;
+
         this.isDefaultPrevented = returnTrue;
-
-        var e = this.originalEvent;
         if ( !e ) {
             return;
         }
 
-        // if preventDefault exists run it on the original event
+        // If preventDefault exists, run it on the original event
         if ( e.preventDefault ) {
             e.preventDefault();
 
-        // otherwise set the returnValue property of the original event to false (IE)
+        // Support: IE
+        // Otherwise set the returnValue property of the original event to false
         } else {
             e.returnValue = false;
@@ -3357 +3351 @@
     },
     stopPropagation: function() {
+        var e = this.originalEvent;
+
         this.isPropagationStopped = returnTrue;
-
-        var e = this.originalEvent;
         if ( !e ) {
             return;
         }
-        // if stopPropagation exists run it on the original event
+        // If stopPropagation exists, run it on the original event
         if ( e.stopPropagation ) {
             e.stopPropagation();
         }
-        // otherwise set the cancelBubble property of the original event to true (IE)
+
+        // Support: IE
+        // Set the cancelBubble property of the original event to true
         e.cancelBubble = true;
     },
@@ -3373 +3369 @@
         this.isImmediatePropagationStopped = returnTrue;
         this.stopPropagation();
-    },
-    isDefaultPrevented: returnFalse,
-    isPropagationStopped: returnFalse,
-    isImmediatePropagationStopped: returnFalse
+    }
 };
 
@@ -3421 +3414 @@
                 var elem = e.target,
                     form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
-                if ( form && !jQuery._data( form, "_submit_attached" ) ) {
+                if ( form && !jQuery._data( form, "submitBubbles" ) ) {
                     jQuery.event.add( form, "submit._submit", function( event ) {
                         event._submit_bubble = true;
                     });
-                    jQuery._data( form, "_submit_attached", true );
+                    jQuery._data( form, "submitBubbles", true );
                 }
             });
@@ -3484 +3477 @@
                 var elem = e.target;
 
-                if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "_change_attached" ) ) {
+                if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "changeBubbles" ) ) {
                     jQuery.event.add( elem, "change._change", function( event ) {
                         if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
@@ -3490 +3483 @@
                         }
                     });
-                    jQuery._data( elem, "_change_attached", true );
+                    jQuery._data( elem, "changeBubbles", true );
                 }
             });
@@ -3545 +3538 @@
         if ( typeof types === "object" ) {
             // ( types-Object, selector, data )
-            if ( typeof selector !== "string" ) { // && selector != null
+            if ( typeof selector !== "string" ) {
                 // ( types-Object, data )
                 data = data || selector;
@@ -3634 +3627 @@
     },
 
-    live: function( types, data, fn ) {
-        jQuery( this.context ).on( types, this.selector, data, fn );
-        return this;
-    },
-    die: function( types, fn ) {
-        jQuery( this.context ).off( types, this.selector || "**", fn );
-        return this;
-    },
-
     delegate: function( selector, types, data, fn ) {
         return this.on( types, selector, data, fn );
@@ -3657 +3641 @@
     },
     triggerHandler: function( type, data ) {
-        if ( this[0] ) {
-            return jQuery.event.trigger( type, data, this[0], true );
+        var elem = this[0];
+        if ( elem ) {
+            return jQuery.event.trigger( type, data, elem, true );
         }
     },
@@ -3714 +3699 @@
     sortOrder,
 
+    // Instance-specific data
     expando = "sizzle" + -(new Date()),
-
-    strundefined = typeof undefined,
-
-    // Used in sorting
-    MAX_NEGATIVE = 1 << 31,
     preferredDoc = window.document,
-
-    Token = String,
+    support = {},
     dirruns = 0,
     done = 0,
-    support = {},
+    classCache = createCache(),
+    tokenCache = createCache(),
+    compilerCache = createCache(),
+
+    // General-purpose constants
+    strundefined = typeof undefined,
+    MAX_NEGATIVE = 1 << 31,
 
     // Array methods
@@ -3744 +3730 @@
     },
 
-    // Augment a function for special use by Sizzle
-    markFunction = function( fn, value ) {
-        fn[ expando ] = value == null || value;
-        return fn;
-    },
-
-    createCache = function() {
-        var cache = {},
-            keys = [];
-
-        return markFunction(function( key, value ) {
-            // Only keep the most recent entries
-            if ( keys.push( key ) > Expr.cacheLength ) {
-                delete cache[ keys.shift() ];
-            }
-
-            // Retrieve with (key + " ") to avoid collision with native Object.prototype properties (see Issue #157)
-            return (cache[ key + " " ] = value);
-        }, cache );
-    },
-
-    classCache = createCache(),
-    tokenCache = createCache(),
-    compilerCache = createCache(),
-
-    // Regex
+
+    // Regular expressions
 
     // Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
@@ -3777 +3739 @@
 
     // Loosely modeled on CSS identifier characters
-    // An unquoted value should be a CSS identifier (http://www.w3.org/TR/css3-selectors/#attribute-selectors)
+    // An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
     // Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
     identifier = characterEncoding.replace( "w", "w#" ),
@@ -3800 +3762 @@
     rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ),
     rpseudo = new RegExp( pseudos ),
-
-    // Easily-parseable/retrievable ID or TAG or CLASS selectors
-    rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
-
-    rsibling = /[\x20\t\r\n\f]*[+~]/,
-
-    rheader = /h\d/i,
-    rinputs = /input|select|textarea|button/i,
-
-    rnative = /\{\s*\[native code\]\s*\}/,
-
-    rbackslash = /\\(?!\\)/g,
-
-    rescape = /'|\\/g,
-    rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,
+    ridentifier = new RegExp( "^" + identifier + "$" ),
 
     matchExpr = {
@@ -3832 +3780 @@
     },
 
-    /**
-     * For feature detection
-     * @param {Function} fn The function to test for native support
-     */
-    isNative = function( fn ) {
-        return rnative.test( fn + "" );
-    },
-
-    /**
-     * Support testing using an element
-     * @param {Function} fn Passed the created div and expects a boolean result
-     */
-    assert = function( fn ) {
-        var div = document.createElement("div");
-
-        try {
-            return fn( div );
-        } catch (e) {
-            return false;
-        } finally {
-            // release memory in IE
-            div = null;
-        }
+    rsibling = /[\x20\t\r\n\f]*[+~]/,
+
+    rnative = /\{\s*\[native code\]\s*\}/,
+
+    // Easily-parseable/retrievable ID or TAG or CLASS selectors
+    rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
+
+    rinputs = /^(?:input|select|textarea|button)$/i,
+    rheader = /^h\d$/i,
+
+    rescape = /'|\\/g,
+    rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,
+
+    // CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
+    runescape = /\\([\da-fA-F]{1,6}[\x20\t\r\n\f]?|.)/g,
+    funescape = function( _, escaped ) {
+        var high = "0x" + escaped - 0x10000;
+        // NaN means non-codepoint
+        return high !== high ?
+            escaped :
+            // BMP codepoint
+            high < 0 ?
+                String.fromCharCode( high + 0x10000 ) :
+                // Supplemental Plane codepoint (surrogate pair)
+                String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
     };
 
@@ -3871 +3821 @@
 }
 
+/**
+ * For feature detection
+ * @param {Function} fn The function to test for native support
+ */
+function isNative( fn ) {
+    return rnative.test( fn + "" );
+}
+
+/**
+ * Create key-value caches of limited size
+ * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
+ *  property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
+ *  deleting the oldest entry
+ */
+function createCache() {
+    var cache,
+        keys = [];
+
+    return (cache = function( key, value ) {
+        // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
+        if ( keys.push( key += " " ) > Expr.cacheLength ) {
+            // Only keep the most recent entries
+            delete cache[ keys.shift() ];
+        }
+        return (cache[ key ] = value);
+    });
+}
+
+/**
+ * Mark a function for special use by Sizzle
+ * @param {Function} fn The function to mark
+ */
+function markFunction( fn ) {
+    fn[ expando ] = true;
+    return fn;
+}
+
+/**
+ * Support testing using an element
+ * @param {Function} fn Passed the created div and expects a boolean result
+ */
+function assert( fn ) {
+    var div = document.createElement("div");
+
+    try {
+        return fn( div );
+    } catch (e) {
+        return false;
+    } finally {
+        // release memory in IE
+        div = null;
+    }
+}
+
 function Sizzle( selector, context, results, seed ) {
     var match, elem, m, nodeType,
@@ -3876 +3880 @@
         i, groups, old, nid, newContext, newSelector;
 
-    if ( context && (( context.ownerDocument || context ) !== document) ) {
+    if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
         setDocument( context );
     }
@@ -3955 +3959 @@
                 i = groups.length;
                 while ( i-- ) {
-                    groups[i] = nid + groups[i].join("");
+                    groups[i] = nid + toSelector( groups[i] );
                 }
                 newContext = rsibling.test( selector ) && context.parentNode || context;
@@ -3997 +4001 @@
  * @returns {Object} Returns the current document
  */
-setDocument = Sizzle.setDocument = function( doc ) {
-    doc = doc && doc.ownerDocument || doc || window.document;
+setDocument = Sizzle.setDocument = function( node ) {
+    var doc = node ? node.ownerDocument || node : preferredDoc;
 
     // If no document and documentElement is available, return
-    if ( !doc || doc.nodeType !== 9 || !doc.documentElement || document === doc ) {
+    if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
         return document;
     }
@@ -4088 +4092 @@
         };
         Expr.filter["ID"] = function( id ) {
-            var attrId = id.replace( rbackslash, "" );
+            var attrId = id.replace( runescape, funescape );
             return function( elem ) {
                 return elem.getAttribute("id") === attrId;
@@ -4106 +4110 @@
         };
         Expr.filter["ID"] =  function( id ) {
-            var attrId = id.replace( rbackslash, "" );
+            var attrId = id.replace( runescape, funescape );
             return function( elem ) {
                 var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
@@ -4190 +4194 @@
         assert(function( div ) {
 
-            // Opera 10-12/IE9 - ^= $= *= and empty values
+            // Opera 10-12/IE8 - ^= $= *= and empty values
             // Should not select anything
-            div.innerHTML = "<p test=''></p>";
-            if ( div.querySelectorAll("[test^='']").length ) {
+            div.innerHTML = "<input type='hidden' i=''/>";
+            if ( div.querySelectorAll("[i^='']").length ) {
                 rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:\"\"|'')" );
             }
@@ -4199 +4203 @@
             // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
             // IE8 throws error here and will not see later tests
-            div.innerHTML = "<input type='hidden'/>";
             if ( !div.querySelectorAll(":enabled").length ) {
                 rbuggyQSA.push( ":enabled", ":disabled" );
@@ -4223 +4226 @@
             // This should fail with an exception
             // Gecko does not error, returns false instead
-            matches.call( div, "[test!='']:x" );
+            matches.call( div, "[s!='']:x" );
             rbuggyMatches.push( "!=", pseudos );
         });
@@ -4345 +4348 @@
 
 Sizzle.matches = function( expr, elements ) {
-    return Sizzle( expr, window.document, null, elements );
+    return Sizzle( expr, null, null, elements );
 };
 
 Sizzle.matchesSelector = function( elem, expr ) {
     // Set document vars if needed
-    if ( elem && (( elem.ownerDocument || elem ) !== document) ) {
+    if ( ( elem.ownerDocument || elem ) !== document ) {
         setDocument( elem );
     }
@@ -4377 +4380 @@
 Sizzle.contains = function( context, elem ) {
     // Set document vars if needed
-    if ( context && (( context.ownerDocument || context ) !== document) ) {
+    if ( ( context.ownerDocument || context ) !== document ) {
         setDocument( context );
     }
@@ -4387 +4390 @@
 
     // Set document vars if needed
-    if ( elem && (( elem.ownerDocument || elem ) !== document) ) {
+    if ( ( elem.ownerDocument || elem ) !== document ) {
         setDocument( elem );
     }
@@ -4536 +4539 @@
     preFilter: {
         "ATTR": function( match ) {
-            match[1] = match[1].replace( rbackslash, "" );
+            match[1] = match[1].replace( runescape, funescape );
 
             // Move the given value to match[3] whether quoted or unquoted
-            match[3] = ( match[4] || match[5] || "" ).replace( rbackslash, "" );
+            match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape );
 
             if ( match[2] === "~=" ) {
@@ -4616 +4619 @@
             }
 
-            nodeName = nodeName.replace( rbackslash, "" ).toLowerCase();
+            nodeName = nodeName.replace( runescape, funescape ).toLowerCase();
             return function( elem ) {
                 return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
@@ -4623 +4626 @@
 
         "CLASS": function( className ) {
-            var pattern = classCache[ expando ][ className + " " ];
+            var pattern = classCache[ className + " " ];
 
             return pattern ||
@@ -4825 +4828 @@
         }),
 
+        // "Whether an element is represented by a :lang() selector
+        // is based solely on the element's language value
+        // being equal to the identifier C,
+        // or beginning with the identifier C immediately followed by "-".
+        // The matching of C against the element's language value is performed case-insensitively.
+        // The identifier C does not have to be a valid language name."
+        // http://www.w3.org/TR/selectors/#lang-pseudo
+        "lang": markFunction( function( lang ) {
+            // lang value must be a valid identifider
+            if ( !ridentifier.test(lang || "") ) {
+                Sizzle.error( "unsupported lang: " + lang );
+            }
+            lang = lang.replace( runescape, funescape ).toLowerCase();
+            return function( elem ) {
+                var elemLang;
+                do {
+                    if ( (elemLang = documentIsXML ?
+                        elem.getAttribute("xml:lang") || elem.getAttribute("lang") :
+                        elem.lang) ) {
+
+                        elemLang = elemLang.toLowerCase();
+                        return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
+                    }
+                } while ( (elem = elem.parentNode) && elem.nodeType === 1 );
+                return false;
+            };
+        }),
+
         // Miscellaneous
         "target": function( elem ) {
@@ -4965 +4996 @@
     var matched, match, tokens, type,
         soFar, groups, preFilters,
-        cached = tokenCache[ expando ][ selector + " " ];
+        cached = tokenCache[ selector + " " ];
 
     if ( cached ) {
@@ -4990 +5021 @@
         // Combinators
         if ( (match = rcombinators.exec( soFar )) ) {
-            tokens.push( matched = new Token( match.shift() ) );
+            matched = match.shift();
+            tokens.push( {
+                value: matched,
+                // Cast descendant combinators to space
+                type: match[0].replace( rtrim, " " )
+            } );
             soFar = soFar.slice( matched.length );
-
-            // Cast descendant combinators to space
-            matched.type = match[0].replace( rtrim, " " );
         }
 
@@ -5001 +5034 @@
             if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
                 (match = preFilters[ type ]( match ))) ) {
-
-                tokens.push( matched = new Token( match.shift() ) );
+                matched = match.shift();
+                tokens.push( {
+                    value: matched,
+                    type: type,
+                    matches: match
+                } );
                 soFar = soFar.slice( matched.length );
-                matched.type = type;
-                matched.matches = match;
             }
         }
@@ -5023 +5058 @@
             // Cache the tokens
             tokenCache( selector, groups ).slice( 0 );
+}
+
+function toSelector( tokens ) {
+    var i = 0,
+        len = tokens.length,
+        selector = "";
+    for ( ; i < len; i++ ) {
+        selector += tokens[i].value;
+    }
+    return selector;
 }
 
@@ -5241 +5286 @@
                 return setMatcher(
                     i > 1 && elementMatcher( matchers ),
-                    i > 1 && tokens.slice( 0, i - 1 ).join("").replace( rtrim, "$1" ),
+                    i > 1 && toSelector( tokens.slice( 0, i - 1 ) ).replace( rtrim, "$1" ),
                     matcher,
                     i < j && matcherFromTokens( tokens.slice( i, j ) ),
                     j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
-                    j < len && tokens.join("")
+                    j < len && toSelector( tokens )
                 );
             }
@@ -5358 +5403 @@
         setMatchers = [],
         elementMatchers = [],
-        cached = compilerCache[ expando ][ selector + " " ];
+        cached = compilerCache[ selector + " " ];
 
     if ( !cached ) {
@@ -5404 +5449 @@
                     Expr.relative[ tokens[1].type ] ) {
 
-                context = Expr.find["ID"]( token.matches[0].replace( rbackslash, "" ), context )[0];
+                context = Expr.find["ID"]( token.matches[0].replace( runescape, funescape ), context )[0];
                 if ( !context ) {
                     return results;
                 }
 
-                selector = selector.slice( tokens.shift().length );
+                selector = selector.slice( tokens.shift().value.length );
             }
 
@@ -5423 +5468 @@
                     // Search, expanding context for leading sibling combinators
                     if ( (seed = find(
-                        token.matches[0].replace( rbackslash, "" ),
+                        token.matches[0].replace( runescape, funescape ),
                         rsibling.test( tokens[0].type ) && context.parentNode || context
                     )) ) {
@@ -5429 +5474 @@
                         // If seed is empty or no tokens remain, we can return early
                         tokens.splice( i, 1 );
-                        selector = seed.length && tokens.join("");
+                        selector = seed.length && toSelector( tokens );
                         if ( !selector ) {
                             push.apply( results, slice.call( seed, 0 ) );
@@ -5781 +5826 @@
     rscriptTypeMasked = /^true\/(.*)/,
     rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,
+
+    // We have to close these tags to support XHTML (#13200)
     wrapMap = {
-        option: [ 1, "<select multiple='multiple'>" ],
-        legend: [ 1, "<fieldset>" ],
-        area: [ 1, "<map>" ],
-        param: [ 1, "<object>" ],
-        thead: [ 1, "<table>"  ],
-        tr: [ 2, "<table><tbody>" ],
-        col: [ 2, "<table><tbody></tbody><colgroup>", "</table>" ],
-        td: [ 3, "<table><tbody><tr>" ],
+        option: [ 1, "<select multiple='multiple'>", "</select>" ],
+        legend: [ 1, "<fieldset>", "</fieldset>" ],
+        area: [ 1, "<map>", "</map>" ],
+        param: [ 1, "<object>", "</object>" ],
+        thead: [ 1, "<table>", "</table>" ],
+        tr: [ 2, "<table><tbody>", "</tbody></table>" ],
+        col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
+        td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
 
         // IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
         // unless wrapped in a div with non-breaking characters in front of it.
-        _default: jQuery.support.htmlSerialize ? [ 0, "" ] : [ 1, "X<div>"  ]
+        _default: jQuery.support.htmlSerialize ? [ 0, "", "" ] : [ 1, "X<div>", "</div>"  ]
     },
     safeFragment = createSafeFragment( document ),
@@ -5944 +5991 @@
             while ( elem.firstChild ) {
                 elem.removeChild( elem.firstChild );
+            }
+
+            // If this is a select, ensure that it displays empty (#12336)
+            // Support: IE<9
+            if ( elem.options && jQuery.nodeName( elem, "select" ) ) {
+                elem.options.length = 0;
             }
         }
@@ -6039 +6092 @@
             i = 0,
             l = this.length,
+            set = this,
             iNoClone = l - 1,
             value = args[0],
@@ -6045 +6099 @@
         // We can't cloneNode fragments that contain checked, in WebKit
         if ( isFunction || !( l <= 1 || typeof value !== "string" || jQuery.support.checkClone || !rchecked.test( value ) ) ) {
-            return this.each(function() {
-                var self = jQuery( this );
+            return this.each(function( index ) {
+                var self = set.eq( index );
                 if ( isFunction ) {
-                    args[0] = value.call( this, i, table ? self.html() : undefined );
+                    args[0] = value.call( this, index, table ? self.html() : undefined );
                 }
                 self.domManip( args, table, callback );
@@ -6054 +6108 @@
         }
 
-        if ( this[0] ) {
-            doc = this[0].ownerDocument;
-            fragment = doc.createDocumentFragment();
-            jQuery.clean( args, doc, fragment, undefined, this );
+        if ( l ) {
+            fragment = jQuery.buildFragment( args, this[ 0 ].ownerDocument, false, this );
             first = fragment.firstChild;
 
@@ -6302 +6354 @@
 }
 
-// Used in clean, fixes the defaultChecked property
+// Used in buildFragment, fixes the defaultChecked property
 function fixDefaultChecked( elem ) {
     if ( manipulation_rcheckableType.test( elem.type ) ) {
@@ -6365 +6417 @@
     },
 
-    clean: function( elems, context, fragment, scripts, selection ) {
-        var elem, i, j, tmp, tag, wrap, tbody,
-            ret = [],
-            safe = context === document && safeFragment;
-
-        // Ensure that context is a document
-        if ( !context || typeof context.createDocumentFragment === "undefined" ) {
-            context = document;
-        }
-
-        for ( i = 0; (elem = elems[i]) != null; i++ ) {
+    buildFragment: function( elems, context, scripts, selection ) {
+        var contains, elem, tag, tmp, wrap, tbody, j,
+            l = elems.length,
+
+            // Ensure a safe fragment
+            safe = createSafeFragment( context ),
+
+            nodes = [],
+            i = 0;
+
+        for ( ; i < l; i++ ) {
+            elem = elems[ i ];
+
             if ( elem || elem === 0 ) {
+
                 // Add nodes directly
                 if ( jQuery.type( elem ) === "object" ) {
-                    jQuery.merge( ret, elem.nodeType ? [ elem ] : elem );
+                    jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
 
                 // Convert non-html into a text node
                 } else if ( !rhtml.test( elem ) ) {
-                    ret.push( context.createTextNode( elem ) );
+                    nodes.push( context.createTextNode( elem ) );
 
                 // Convert html into DOM nodes
                 } else {
-                    // Ensure a safe container
-                    safe = safe || createSafeFragment( context );
                     tmp = tmp || safe.appendChild( context.createElement("div") );
 
@@ -6394 +6447 @@
                     tag = ( rtagName.exec( elem ) || ["", ""] )[1].toLowerCase();
                     wrap = wrapMap[ tag ] || wrapMap._default;
-                    tmp.innerHTML = wrap[1] + elem.replace( rxhtmlTag, "<$1></$2>" ) + ( wrap[2] || "" );
+
+                    tmp.innerHTML = wrap[1] + elem.replace( rxhtmlTag, "<$1></$2>" ) + wrap[2];
 
                     // Descend through wrappers to the right content
@@ -6404 +6458 @@
                     // Manually add leading whitespace removed by IE
                     if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
-                        ret.push( context.createTextNode( rleadingWhitespace.exec( elem )[0] ) );
+                        nodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[0] ) );
                     }
 
@@ -6427 +6481 @@
                     }
 
-                    jQuery.merge( ret, tmp.childNodes );
+                    jQuery.merge( nodes, tmp.childNodes );
 
                     // Fix #12392 for WebKit and IE > 9
@@ -6443 +6497 @@
         }
 
-        // Fix #11356: Clear elements from safeFragment
+        // Fix #11356: Clear elements from fragment
         if ( tmp ) {
             safe.removeChild( tmp );
@@ -6451 +6505 @@
         // about to be appended to the DOM in IE 6/7 (#8060)
         if ( !jQuery.support.appendChecked ) {
-            jQuery.grep( getAll( ret, "input" ), fixDefaultChecked );
-        }
-
-        if ( fragment ) {
-            for ( i = 0; (elem = ret[i]) != null; i++ ) {
-                safe = jQuery.contains( elem.ownerDocument, elem );
-
-                // Append to fragment
-                // #4087 - If origin and destination elements are the same, and this is
-                // that element, do not append to fragment
-                if ( !selection || jQuery.inArray( elem, selection ) === -1 ) {
-                    fragment.appendChild( elem );
-                }
-                tmp = getAll( elem, "script" );
-
-                // Preserve script evaluation history
-                if ( safe ) {
-                    setGlobalEval( tmp );
-                }
-
-                // Capture executables
-                if ( scripts ) {
-                    for ( j = 0; (elem = tmp[j]) != null; j++ ) {
-                        if ( rscriptType.test( elem.type || "" ) ) {
-                            scripts.push( elem );
-                        }
+            jQuery.grep( getAll( nodes, "input" ), fixDefaultChecked );
+        }
+
+        i = 0;
+        while ( (elem = nodes[ i++ ]) ) {
+
+            // #4087 - If origin and destination elements are the same, and this is
+            // that element, do not do anything
+            if ( selection && jQuery.inArray( elem, selection ) !== -1 ) {
+                continue;
+            }
+
+            contains = jQuery.contains( elem.ownerDocument, elem );
+
+            // Append to fragment
+            tmp = getAll( safe.appendChild( elem ), "script" );
+
+            // Preserve script evaluation history
+            if ( contains ) {
+                setGlobalEval( tmp );
+            }
+
+            // Capture executables
+            if ( scripts ) {
+                j = 0;
+                while ( (elem = tmp[ j++ ]) ) {
+                    if ( rscriptType.test( elem.type || "" ) ) {
+                        scripts.push( elem );
                     }
                 }
@@ -6482 +6538 @@
         }
 
-        elem = tmp = safe = null;
-
-        return ret;
+        tmp = null;
+
+        return safe;
     },
 
@@ -6526 +6582 @@
                             delete elem[ internalKey ];
 
-                        } else if ( elem.removeAttribute ) {
+                        } else if ( typeof elem.removeAttribute !== "undefined" ) {
                             elem.removeAttribute( internalKey );
 
@@ -6755 +6811 @@
             // Fixes #8908, it can be done more correctly by specifing setters in cssHooks,
             // but it would mean to define eight (for every problematic property) identical functions
-            if ( value === "" && name.indexOf("background") === 0 ) {
-                value = " ";
+            if ( !jQuery.support.clearCloneStyle && value === "" && name.indexOf("background") === 0 ) {
+                style[ name ] = "inherit";
             }
 
@@ -7310 +7366 @@
     ajaxLocParts,
     ajaxLocation,
-
+    
     ajax_nonce = jQuery.now(),
 
@@ -8610 +8666 @@
 function Animation( elem, properties, options ) {
     var result,
+        stopped,
         index = 0,
         length = animationPrefilters.length,
@@ -8617 +8674 @@
         }),
         tick = function() {
+            if ( stopped ) {
+                return false;
+            }
             var currentTime = fxNow || createFxNow(),
                 remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
@@ -8658 +8718 @@
                     // otherwise we skip this part
                     length = gotoEnd ? animation.tweens.length : 0;
-
+                if ( stopped ) {
+                    return this;
+                }
+                stopped = true;
                 for ( ; index < length ; index++ ) {
                     animation.tweens[ index ].run( 1 );
@@ -8692 +8755 @@
     jQuery.fx.timer(
         jQuery.extend( tick, {
+            elem: elem,
             anim: animation,
-            queue: animation.opts.queue,
-            elem: elem
+            queue: animation.opts.queue
         })
     );
@@ -9015 +9078 @@
                 // Operate on a copy of prop so per-property easing won't be lost
                 var anim = Animation( this, jQuery.extend( {}, prop ), optall );
-
-                // Empty animations resolve immediately
-                if ( empty ) {
+                doAnimation.finish = function() {
                     anim.stop( true );
+                };
+                // Empty animations, or finishing resolves immediately
+                if ( empty || jQuery._data( this, "finish" ) ) {
+                    anim.stop( true );
                 }
             };
+            doAnimation.finish = doAnimation;
 
         return empty || optall.queue === false ?
@@ -9074 +9140 @@
                 jQuery.dequeue( this, type );
             }
+        });
+    },
+    finish: function( type ) {
+        if ( type !== false ) {
+            type = type || "fx";
+        }
+        return this.each(function() {
+            var index,
+                data = jQuery._data( this ),
+                queue = data[ type + "queue" ],
+                hooks = data[ type + "queueHooks" ],
+                timers = jQuery.timers,
+                length = queue ? queue.length : 0;
+
+            // enable finishing flag on private data
+            data.finish = true;
+
+            // empty the queue first
+            jQuery.queue( this, type, [] );
+
+            if ( hooks && hooks.cur && hooks.cur.finish ) {
+                hooks.cur.finish.call( this );
+            }
+
+            // look for any active animations, and finish them
+            for ( index = timers.length; index--; ) {
+                if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
+                    timers[ index ].anim.stop( true );
+                    timers.splice( index, 1 );
+                }
+            }
+
+            // look for any animations in the old queue and finish them
+            for ( index = 0; index < length; index++ ) {
+                if ( queue[ index ] && queue[ index ].finish ) {
+                    queue[ index ].finish.call( this );
+                }
+            }
+
+            // turn off finishing flag
+            delete data.finish;
         });
     }

trunk/wp-includes/script-loader.php

@@ -127 +127 @@
     // jQuery
     $scripts->add( 'jquery', false, array( 'jquery-core', 'jquery-migrate' ) );
-    $scripts->add( 'jquery-core', '/wp-includes/js/jquery/jquery.js', array(), '1.9.0b1' );
-    $scripts->add( 'jquery-migrate', '/wp-includes/js/jquery/jquery-migrate.js', array(), '1.0.0b1' );
+    $scripts->add( 'jquery-core', '/wp-includes/js/jquery/jquery.js', array(), '1.9.0' );
+    $scripts->add( 'jquery-migrate', '/wp-includes/js/jquery/jquery-migrate.js', array(), '1.0.0' );
 
     // full jQuery UI