Ticket #23204: jquery.diff

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 = {};
 
 // 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
 jQuery.migrateReset = function() {
         warnedAbout = {};
@@ -26 +22 @@
 };
 
 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 );
                 }
         }
 }
 
 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
                 try {
@@ -65 +59 @@
         obj[ prop ] = value;
 }
 
-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" );
 }
@@ -78 +72 @@
         valueAttrSet = jQuery.attrHooks.value && jQuery.attrHooks.value.set ||
                 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
 migrateWarnProp( jQuery, "attrFn", attrFn, "jQuery.attrFn is deprecated" );
 
 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 );
                 }
         }
@@ -96 +95 @@
                 migrateWarn("Can't change the 'type' of an input or button in IE 6/7/8");
         }
 
+        // 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 );
 };
 
 // attrHooks: value
 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;
         }
@@ -122 +167 @@
 
 
 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
 jQuery.fn.init = function( selector, context, rootjQuery ) {
@@ -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 ) {
         ua = ua.toLowerCase();
 
@@ -250 +273 @@
 };
 
 
-var oldSelf = jQuery.fn.andSelf || jQuery.fn.addBack,
+var rscriptType = /\/(java|ecma)script/i,
+        oldSelf = jQuery.fn.andSelf || jQuery.fn.addBack,
         oldFragment = jQuery.buildFragment;
 
 jQuery.fn.andSelf = function() {
@@ -258 +282 @@
         return oldSelf.apply( this, arguments );
 };
 
-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.clean() is deprecated");
 
-                migrateWarn("jQuery.buildFragment() is deprecated");
-                return { fragment: fragment, cacheable: false };
+                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 );
         }
-        // Don't warn if we are in a version where buildFragment is used internally
-        return oldFragment.apply( this, arguments );
+
+        // 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;
 };
 
 var eventAdd = jQuery.event.add,
@@ -303 +385 @@
         jQuery.event.props.unshift( "attrChange", "attrName", "relatedNode", "srcElement" );
 }
 
+// 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 ){
         if ( elem !== document && rajaxEvent.test( types ) ) {
@@ -314 +399 @@
         eventRemove.call( this, elem, hoverHack( types ) || "", handler, selector, mappedTypes );
 };
 
-jQuery.fn.error = function( data, fn ) {
+jQuery.fn.error = function() {
         var args = Array.prototype.slice.call( arguments, 0);
         migrateWarn("jQuery.fn.error() is deprecated");
         args.splice( 0, 0, "error" );
@@ -387 +472 @@
 jQuery.each( ajaxEvents.split("|"),
         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 );
                                         });
                                         jQuery._data( this, name, jQuery.guid++ );
                                 }
                                 return false;
                         },
-                        teardown: function( data, handleObj ) {
+                        teardown: function() {
                                 if ( this !== document ) {
                                         jQuery.event.remove( document, name + "." + jQuery._data( this, name ) );
                                 }
                                 return false;
                         }
-                }
+                };
         }
 );
 

wp-includes/js/jquery/jquery.js

@@ -1 +1 @@
 /*!
- * jQuery JavaScript Library v1.9.0b1
+ * jQuery JavaScript Library v1.9.0
  * http://jquery.com/
  *
  * Includes Sizzle.js
  * 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 ) {
 "use strict";
@@ -36 +36 @@
         // List of deleted data cache ids, so we can reuse them
         core_deletedIds = [],
 
-        core_version = "1.9.0b1",
+        core_version = "1.9.0",
 
         // Save a reference to some core methods
         core_concat = core_deletedIds.concat,
@@ -111 +111 @@
                         return this;
                 }
 
-                // HANDLE: $(DOMElement)
-                if ( selector.nodeType ) {
-                        this.context = this[0] = selector;
-                        this.length = 1;
-                        return this;
-                }
-
                 // Handle HTML strings
                 if ( typeof selector === "string" ) {
                         if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
@@ -191 +184 @@
                                 return this.constructor( context ).find( selector );
                         }
 
+                // HANDLE: $(DOMElement)
+                } else if ( selector.nodeType ) {
+                        this.context = this[0] = selector;
+                        this.length = 1;
+                        return this;
+
                 // HANDLE: $(function)
                 // Shortcut for document ready
                 } else if ( jQuery.isFunction( selector ) ) {
@@ -442 +441 @@
         },
 
         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;
         },
 
         isPlainObject: function( obj ) {
@@ -509 +511 @@
                         return [ context.createElement( parsed[1] ) ];
                 }
 
-                parsed = context.createDocumentFragment();
-                jQuery.clean( [ data ], context, parsed, scripts );
+                parsed = jQuery.buildFragment( [ data ], context, scripts );
                 if ( scripts ) {
                         jQuery( scripts ).remove();
                 }
@@ -1164 +1165 @@
                                         return jQuery.Deferred(function( newDefer ) {
                                                 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;
                                         }).promise();
@@ -1215 +1213 @@
 
                         // 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;
                         };
                         deferred[ tuple[0] + "With" ] = list.fireWith;
@@ -1287 +1285 @@
 });
 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");
 
         // Setup
@@ -1367 +1355 @@
                 boxModel: document.compatMode === "CSS1Compat",
 
                 // Will be defined later
-                submitBubbles: true,
-                changeBubbles: true,
-                focusinBubbles: false,
                 deleteExpando: true,
                 noCloneEvent: true,
                 inlineBlockNeedsLayout: false,
@@ -1388 +1373 @@
         select.disabled = true;
         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;
         } catch( e ) {
                 support.deleteExpando = false;
         }
 
-        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");
         input.setAttribute( "value", "" );
@@ -1417 +1391 @@
         support.radioValue = input.value === "t";
 
         // #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 );
+        fragment.appendChild( input );
 
-        // WebKit doesn't clone checked state correctly in fragments
-        support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
-
         // Check if a disconnected checkbox will retain its checked
         // value of true after appended to the DOM (IE6/7)
         support.appendChecked = input.checked;
 
-        fragment.removeChild( input );
-        fragment.appendChild( div );
+        // WebKit doesn't clone checked state correctly in fragments
+        support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
 
-        // 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
+        // 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];
 
                 if ( !body ) {
@@ -1468 +1439 @@
                 }
 
                 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 );
+                container.style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px";
 
-                // Construct the test element
-                div = document.createElement("div");
-                container.appendChild( div );
+                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
                 // table row; if so, offsetWidth/Height are not reliable for use when
                 // determining if an element has been hidden directly using
                 // 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");
                 tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none";
@@ -1490 +1458 @@
                 tds[ 0 ].style.display = "";
                 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 );
 
                 // Check box-sizing and margin behavior
@@ -1500 +1468 @@
                 support.boxSizing = ( div.offsetWidth === 4 );
                 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%";
                         support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
 
                         // 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 );
                 }
 
                 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";
                         support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
@@ -1542 +1507 @@
                         body.style.zoom = 1;
                 }
 
+                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 ) ) {
                 return;
@@ -1771 +1737 @@
         _data: function( elem, name, data ) {
                 return internalData( elem, name, data, true );
         },
-
+        
         _removeData: function( elem, name ) {
                 return internalRemoveData( elem, name, true );
         },
@@ -1926 +1892 @@
                         startLength--;
                 }
 
+                hooks.cur = fn;
                 if ( fn ) {
 
                         // Add a progress sentinel to prevent the fx queue from being
@@ -2367 +2334 @@
 
                 } 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
                         return ret == null ?
@@ -2637 +2608 @@
         jQuery.attrHooks.style = {
                 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 ) {
                         return ( elem.style.cssText = value + "" );
@@ -2697 +2669 @@
         rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
         rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
 
+function returnTrue() {
+        return true;
+}
+
+function returnFalse() {
+        return false;
+}
+
 /*
  * Helper functions for managing events -- not part of the public interface.
  * Props to Dean Edwards' addEvent library for many of the ideas.
  */
 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;
                 }
 
@@ -2727 +2710 @@
                 }
 
                 // Init the element's event structure and main handler, if this is the first
-                events = elemData.events;
-                if ( !events ) {
-                        elemData.events = events = {};
+                if ( !(events = elemData.events) ) {
+                        events = elemData.events = {};
                 }
-                eventHandle = elemData.handle;
-                if ( !eventHandle ) {
-                        elemData.handle = eventHandle = function( e ) {
+                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
                                 return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
@@ -2747 +2728 @@
                 // Handle multiple events separated by a space
                 // jQuery(...).bind("mouseover mouseout", fn);
                 types = ( types || "" ).match( core_rnotwhite ) || [""];
-                for ( ; t < types.length; t++ ) {
+                t = types.length;
+                while ( t-- ) {
+                        tmp = rtypenamespace.exec( types[t] ) || [];
+                        type = origType = tmp[1];
+                        namespaces = ( tmp[2] || "" ).split( "." ).sort();
 
-                        tns = rtypenamespace.exec( types[t] ) || [];
-                        type = tns[1];
-                        namespaces = ( tns[2] || "" ).split( "." ).sort();
-
                         // If event changes its type, use the special event handlers for the changed type
                         special = jQuery.event.special[ type ] || {};
 
@@ -2765 +2746 @@
                         // handleObj is passed to all event handlers
                         handleObj = jQuery.extend({
                                 type: type,
-                                origType: tns[1],
+                                origType: origType,
                                 data: data,
                                 handler: handler,
                                 guid: handler.guid,
@@ -2775 +2756 @@
                         }, handleObjIn );
 
                         // 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;
 
@@ -2815 +2795 @@
                 elem = null;
         },
 
-        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 );
 
                 if ( !elemData || !(events = elemData.events) ) {
@@ -2831 +2809 @@
 
                 // 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
                         if ( !type ) {
@@ -2845 +2824 @@
                         }
 
                         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 ) {
                                                 special.remove.call( elem, handleObj );
@@ -2871 +2850 @@
 
                         // 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 );
                                 }
@@ -2892 +2871 @@
 
         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
                 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
@@ -2914 +2894 @@
                         type = namespaces.shift();
                         namespaces.sort();
                 }
+                ontype = type.indexOf(":") < 0 && "on" + type;
 
-                // 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 );
+                // 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.type = type;
                 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
                 event.result = undefined;
@@ -2937 +2914 @@
                 }
 
                 // 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
                 special = jQuery.event.special[ type ] || {};
@@ -2948 +2926 @@
 
                 // 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++ ) {
+                i = 0;
+                while ( (cur = eventPath[i++]) && !event.isPropagationStopped() ) {
 
-                        cur = eventPath[i][0];
-                        event.type = eventPath[i][1];
+                        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 ) {
                                 event.preventDefault();
@@ -2994 +2977 @@
                                 if ( ontype && elem[ type ] && !jQuery.isWindow( elem ) ) {
 
                                         // Don't re-trigger an onFOO event when we call its FOO() method
-                                        old = elem[ ontype ];
+                                        tmp = elem[ ontype ];
 
-                                        if ( old ) {
+                                        if ( tmp ) {
                                                 elem[ ontype ] = null;
                                         }
 
@@ -3010 +2993 @@
                                         }
                                         jQuery.event.triggered = undefined;
 
-                                        if ( old ) {
-                                                elem[ ontype ] = old;
+                                        if ( tmp ) {
+                                                elem[ ontype ] = tmp;
                                         }
                                 }
                         }
@@ -3025 +3008 @@
                 // Make a writable jQuery.Event from the native event object
                 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
                 args[0] = event;
@@ -3041 +3023 @@
                         return;
                 }
 
-                // 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") ) {
+                if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) {
 
-                        for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {
+                        for ( ; cur != this; cur = cur.parentNode || this ) {
 
-                                // Don't process clicks (ONLY) on disabled elements (#6911, #8165, #11382, #11764)
+                                // 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 });
                                         }
                                 }
                         }
                 }
 
                 // Add the remaining (directly-bound) handlers
-                if ( handlers.length > delegateCount ) {
-                        handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) });
+                if ( delegateCount < handlers.length ) {
+                        handlerQueue.push({ elem: this, handlers: 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;
+                return handlerQueue;
+        },
 
-                        for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) {
-                                handleObj = matched.matches[ j ];
+        fix: function( event ) {
+                if ( event[ jQuery.expando ] ) {
+                        return event;
+                }
 
-                                // 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 ) ) {
+                // 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.data = handleObj.data;
-                                        event.handleObj = handleObj;
+                event = new jQuery.Event( originalEvent );
 
-                                        ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
-                                                        .apply( matched.elem, args );
+                i = copy.length;
+                while ( i-- ) {
+                        prop = copy[ i ];
+                        event[ prop ] = originalEvent[ prop ];
+                }
 
-                                        if ( ret !== undefined ) {
-                                                event.result = ret;
-                                                if ( ret === false ) {
-                                                        event.preventDefault();
-                                                        event.stopPropagation();
-                                                }
-                                        }
-                                }
-                        }
+                // Support: IE<9
+                // Fix target property (#1925)
+                if ( !event.target ) {
+                        event.target = originalEvent.srcElement || document;
                 }
 
-                // Call the postDispatch hook for the mapped type
-                if ( special.postDispatch ) {
-                        special.postDispatch.call( this, event );
+                // Support: Chrome 23+, Safari?
+                // Target should not be a text node (#504, #13143)
+                if ( event.target.nodeType === 3 ) {
+                        event.target = event.target.parentNode;
                 }
 
-                return event.result;
+                // 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;
         },
 
         // Includes some event props shared by KeyEvent and MouseEvent
@@ -3163 +3196 @@
                 }
         },
 
-        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;
-        },
-
         special: {
                 load: {
                         // Prevent triggered image.load events from bubbling to window.load
@@ -3219 +3218 @@
                                                 this.focus();
                                                 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
                                         }
                                 }
                         },
@@ -3270 +3270 @@
         }
 };
 
-// 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 ) {
                 if ( elem.removeEventListener ) {
@@ -3328 +3324 @@
         this[ jQuery.expando ] = true;
 };
 
-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;
                 }
         },
         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;
         },
         stopImmediatePropagation: function() {
                 this.isImmediatePropagationStopped = returnTrue;
                 this.stopPropagation();
-        },
-        isDefaultPrevented: returnFalse,
-        isPropagationStopped: returnFalse,
-        isImmediatePropagationStopped: returnFalse
+        }
 };
 
 // Create mouseenter/leave events using mouseover/out and event-time checks
@@ -3420 +3413 @@
                                 // Node name check avoids a VML-related crash in IE (#9807)
                                 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 );
                                 }
                         });
                         // return undefined since we don't need an event listener
@@ -3483 +3476 @@
                         jQuery.event.add( this, "beforeactivate._change", function( e ) {
                                 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 ) {
                                                         jQuery.event.simulate( "change", this.parentNode, event, true );
                                                 }
                                         });
-                                        jQuery._data( elem, "_change_attached", true );
+                                        jQuery._data( elem, "changeBubbles", true );
                                 }
                         });
                 },
@@ -3544 +3537 @@
                 // Types can be a map of types/handlers
                 if ( typeof types === "object" ) {
                         // ( types-Object, selector, data )
-                        if ( typeof selector !== "string" ) { // && selector != null
+                        if ( typeof selector !== "string" ) {
                                 // ( types-Object, data )
                                 data = data || selector;
                                 selector = undefined;
@@ -3633 +3626 @@
                 return this.off( types, null, fn );
         },
 
-        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 );
         },
@@ -3656 +3640 @@
                 });
         },
         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 );
                 }
         },
 
@@ -3713 +3698 @@
         contains,
         sortOrder,
 
+        // Instance-specific data
         expando = "sizzle" + -(new Date()),
+        preferredDoc = window.document,
+        support = {},
+        dirruns = 0,
+        done = 0,
+        classCache = createCache(),
+        tokenCache = createCache(),
+        compilerCache = createCache(),
 
+        // General-purpose constants
         strundefined = typeof undefined,
-
-        // Used in sorting
         MAX_NEGATIVE = 1 << 31,
-        preferredDoc = window.document,
 
-        Token = String,
-        dirruns = 0,
-        done = 0,
-        support = {},
-
         // Array methods
         arr = [],
         pop = arr.pop,
@@ -3743 +3729 @@
                 return -1;
         },
 
-        // Augment a function for special use by Sizzle
-        markFunction = function( fn, value ) {
-                fn[ expando ] = value == null || value;
-                return fn;
-        },
 
-        createCache = function() {
-                var cache = {},
-                        keys = [];
+        // Regular expressions
 
-                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
-
         // Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
         whitespace = "[\\x20\\t\\r\\n\\f]",
         // http://www.w3.org/TR/css3-syntax/#characters
         characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
 
         // 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#" ),
 
@@ -3799 +3761 @@
         rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
         rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ),
         rpseudo = new RegExp( pseudos ),
+        ridentifier = new RegExp( "^" + identifier + "$" ),
 
-        // 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,
-
         matchExpr = {
                 "ID": new RegExp( "^#(" + characterEncoding + ")" ),
                 "CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
@@ -3831 +3779 @@
                         whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
         },
 
-        /**
-         * For feature detection
-         * @param {Function} fn The function to test for native support
-         */
-        isNative = function( fn ) {
-                return rnative.test( fn + "" );
-        },
+        rsibling = /[\x20\t\r\n\f]*[+~]/,
 
-        /**
-         * 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");
+        rnative = /\{\s*\[native code\]\s*\}/,
 
-                try {
-                        return fn( div );
-                } catch (e) {
-                        return false;
-                } finally {
-                        // release memory in IE
-                        div = null;
-                }
+        // 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 );
         };
 
 // Use a stripped-down slice if we can't use a native one
@@ -3870 +3820 @@
         };
 }
 
+/**
+ * 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,
                 // QSA vars
                 i, groups, old, nid, newContext, newSelector;
 
-        if ( context && (( context.ownerDocument || context ) !== document) ) {
+        if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
                 setDocument( context );
         }
 
@@ -3954 +3958 @@
 
                                 i = groups.length;
                                 while ( i-- ) {
-                                        groups[i] = nid + groups[i].join("");
+                                        groups[i] = nid + toSelector( groups[i] );
                                 }
                                 newContext = rsibling.test( selector ) && context.parentNode || context;
                                 newSelector = groups.join(",");
@@ -3996 +4000 @@
  * @param {Element|Object} [doc] An element or document object to use to set the document
  * @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;
         }
 
@@ -4087 +4091 @@
                         }
                 };
                 Expr.filter["ID"] = function( id ) {
-                        var attrId = id.replace( rbackslash, "" );
+                        var attrId = id.replace( runescape, funescape );
                         return function( elem ) {
                                 return elem.getAttribute("id") === attrId;
                         };
@@ -4105 +4109 @@
                         }
                 };
                 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");
                                 return node && node.value === attrId;
@@ -4189 +4193 @@
 
                 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 + "*(?:\"\"|'')" );
                         }
 
                         // 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" );
                         }
@@ -4222 +4225 @@
 
                         // 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 );
                 });
         }
@@ -4344 +4347 @@
 };
 
 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 );
         }
 
@@ -4376 +4379 @@
 
 Sizzle.contains = function( context, elem ) {
         // Set document vars if needed
-        if ( context && (( context.ownerDocument || context ) !== document) ) {
+        if ( ( context.ownerDocument || context ) !== document ) {
                 setDocument( context );
         }
         return contains( context, elem );
@@ -4386 +4389 @@
         var val;
 
         // Set document vars if needed
-        if ( elem && (( elem.ownerDocument || elem ) !== document) ) {
+        if ( ( elem.ownerDocument || elem ) !== document ) {
                 setDocument( elem );
         }
 
@@ -4535 +4538 @@
 
         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] === "~=" ) {
                                 match[3] = " " + match[3] + " ";
@@ -4615 +4618 @@
                                 return function() { return true; };
                         }
 
-                        nodeName = nodeName.replace( rbackslash, "" ).toLowerCase();
+                        nodeName = nodeName.replace( runescape, funescape ).toLowerCase();
                         return function( elem ) {
                                 return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
                         };
                 },
 
                 "CLASS": function( className ) {
-                        var pattern = classCache[ expando ][ className + " " ];
+                        var pattern = classCache[ className + " " ];
 
                         return pattern ||
                                 (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
@@ -4824 +4827 @@
                         };
                 }),
 
+                // "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 ) {
                         var hash = window.location && window.location.hash;
@@ -4964 +4995 @@
 function tokenize( selector, parseOnly ) {
         var matched, match, tokens, type,
                 soFar, groups, preFilters,
-                cached = tokenCache[ expando ][ selector + " " ];
+                cached = tokenCache[ selector + " " ];
 
         if ( cached ) {
                 return parseOnly ? 0 : cached.slice( 0 );
@@ -4989 +5020 @@
 
                 // 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, " " );
                 }
 
                 // Filters
                 for ( type in Expr.filter ) {
                         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;
                         }
                 }
 
@@ -5024 +5059 @@
                         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;
+}
+
 function addCombinator( matcher, combinator, base ) {
         var dir = combinator.dir,
                 checkNonElements = base && combinator.dir === "parentNode",
@@ -5240 +5285 @@
                                 }
                                 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 )
                                 );
                         }
                         matchers.push( matcher );
@@ -5357 +5402 @@
         var i,
                 setMatchers = [],
                 elementMatchers = [],
-                cached = compilerCache[ expando ][ selector + " " ];
+                cached = compilerCache[ selector + " " ];
 
         if ( !cached ) {
                 // Generate a function of recursive functions that can be used to check each element
@@ -5403 +5448 @@
                                         context.nodeType === 9 && !documentIsXML &&
                                         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 );
                         }
 
                         // Fetch a seed set for right-to-left matching
@@ -5422 +5467 @@
                                 if ( (find = Expr.find[ type ]) ) {
                                         // 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
                                         )) ) {
 
                                                 // 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 ) );
                                                         return results;
@@ -5780 +5825 @@
         rscriptType = /^$|\/(?:java|ecma)script/i,
         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 ),
         fragmentDiv = safeFragment.appendChild( document.createElement("div") );
@@ -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;
+                        }
                 }
 
                 return this;
@@ -6038 +6091 @@
                 var fragment, first, scripts, hasScripts, node, doc,
                         i = 0,
                         l = this.length,
+                        set = this,
                         iNoClone = l - 1,
                         value = args[0],
                         isFunction = jQuery.isFunction( value );
 
                 // 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 );
                         });
                 }
 
-                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;
 
                         if ( fragment.childNodes.length === 1 ) {
@@ -6301 +6353 @@
                 found;
 }
 
-// Used in clean, fixes the defaultChecked property
+// Used in buildFragment, fixes the defaultChecked property
 function fixDefaultChecked( elem ) {
         if ( manipulation_rcheckableType.test( elem.type ) ) {
                 elem.defaultChecked = elem.checked;
@@ -6364 +6416 @@
                 return clone;
         },
 
-        clean: function( elems, context, fragment, scripts, selection ) {
-                var elem, i, j, tmp, tag, wrap, tbody,
-                        ret = [],
-                        safe = context === document && safeFragment;
+        buildFragment: function( elems, context, scripts, selection ) {
+                var contains, elem, tag, tmp, wrap, tbody, j,
+                        l = elems.length,
 
-                // Ensure that context is a document
-                if ( !context || typeof context.createDocumentFragment === "undefined" ) {
-                        context = document;
-                }
+                        // Ensure a safe fragment
+                        safe = createSafeFragment( context ),
 
-                for ( i = 0; (elem = elems[i]) != null; i++ ) {
+                        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") );
 
                                         // Deserialize a standard representation
                                         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
                                         j = wrap[0];
                                         while ( j-- ) {
@@ -6403 +6457 @@
 
                                         // 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] ) );
                                         }
 
                                         // Remove IE's autoinserted <tbody> from table fragments
@@ -6426 +6480 @@
                                                 }
                                         }
 
-                                        jQuery.merge( ret, tmp.childNodes );
+                                        jQuery.merge( nodes, tmp.childNodes );
 
                                         // Fix #12392 for WebKit and IE > 9
                                         tmp.textContent = "";
@@ -6442 +6496 @@
                         }
                 }
 
-                // Fix #11356: Clear elements from safeFragment
+                // Fix #11356: Clear elements from fragment
                 if ( tmp ) {
                         safe.removeChild( tmp );
                 }
@@ -6450 +6504 @@
                 // Reset defaultChecked for any radios and checkboxes
                 // about to be appended to the DOM in IE 6/7 (#8060)
                 if ( !jQuery.support.appendChecked ) {
-                        jQuery.grep( getAll( ret, "input" ), fixDefaultChecked );
+                        jQuery.grep( getAll( nodes, "input" ), fixDefaultChecked );
                 }
 
-                if ( fragment ) {
-                        for ( i = 0; (elem = ret[i]) != null; i++ ) {
-                                safe = jQuery.contains( elem.ownerDocument, elem );
+                i = 0;
+                while ( (elem = nodes[ i++ ]) ) {
 
-                                // 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" );
+                        // #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;
+                        }
 
-                                // Preserve script evaluation history
-                                if ( safe ) {
-                                        setGlobalEval( tmp );
-                                }
+                        contains = jQuery.contains( elem.ownerDocument, elem );
 
-                                // Capture executables
-                                if ( scripts ) {
-                                        for ( j = 0; (elem = tmp[j]) != null; j++ ) {
-                                                if ( rscriptType.test( elem.type || "" ) ) {
-                                                        scripts.push( 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 );
                                         }
                                 }
                         }
                 }
 
-                elem = tmp = safe = null;
+                tmp = null;
 
-                return ret;
+                return safe;
         },
 
         cleanData: function( elems, /* internal */ acceptData ) {
@@ -6525 +6581 @@
                                                 if ( deleteExpando ) {
                                                         delete elem[ internalKey ];
 
-                                                } else if ( elem.removeAttribute ) {
+                                                } else if ( typeof elem.removeAttribute !== "undefined" ) {
                                                         elem.removeAttribute( internalKey );
 
                                                 } else {
@@ -6754 +6810 @@
 
                         // 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";
                         }
 
                         // If a hook was provided, use that value, otherwise just set the specified value
@@ -7309 +7365 @@
         // Document location
         ajaxLocParts,
         ajaxLocation,
-
+        
         ajax_nonce = jQuery.now(),
 
         ajax_rquery = /\?/,
@@ -8609 +8665 @@
 
 function Animation( elem, properties, options ) {
         var result,
+                stopped,
                 index = 0,
                 length = animationPrefilters.length,
                 deferred = jQuery.Deferred().always( function() {
@@ -8616 +8673 @@
                         delete tick.elem;
                 }),
                 tick = function() {
+                        if ( stopped ) {
+                                return false;
+                        }
                         var currentTime = fxNow || createFxNow(),
                                 remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
                                 // archaic crash bug won't allow us to use 1 - ( 0.5 || 0 ) (#12497)
@@ -8657 +8717 @@
                                         // if we are going to the end, we want to run all the tweens
                                         // 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 );
                                 }
@@ -8691 +8754 @@
 
         jQuery.fx.timer(
                 jQuery.extend( tick, {
+                        elem: elem,
                         anim: animation,
-                        queue: animation.opts.queue,
-                        elem: elem
+                        queue: animation.opts.queue
                 })
         );
 
@@ -9014 +9077 @@
                         doAnimation = function() {
                                 // 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 ?
                         this.each( doAnimation ) :
@@ -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;
+                });
         }
 });