Changeset 27372


Ignore:
Timestamp:
Feb 13, 2014, 11:57:07 PM (7 years ago)
Author:
rvelices
Message:

upgrade jquery from 1.10.2 to 1.11.0

Location:
trunk/themes/default/js
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/themes/default/js/jquery.js

    r25383 r27372  
    11/*!
    2  * jQuery JavaScript Library v1.10.2
     2 * jQuery JavaScript Library v1.11.0
    33 * http://jquery.com/
    44 *
     
    66 * http://sizzlejs.com/
    77 *
    8  * Copyright 2005, 2013 jQuery Foundation, Inc. and other contributors
     8 * Copyright 2005, 2014 jQuery Foundation, Inc. and other contributors
    99 * Released under the MIT license
    1010 * http://jquery.org/license
    1111 *
    12  * Date: 2013-07-03T13:48Z
     12 * Date: 2014-01-23T21:02Z
    1313 */
    14 (function( window, undefined ) {
     14
     15(function( global, factory ) {
     16
     17        if ( typeof module === "object" && typeof module.exports === "object" ) {
     18                // For CommonJS and CommonJS-like environments where a proper window is present,
     19                // execute the factory and get jQuery
     20                // For environments that do not inherently posses a window with a document
     21                // (such as Node.js), expose a jQuery-making factory as module.exports
     22                // This accentuates the need for the creation of a real window
     23                // e.g. var jQuery = require("jquery")(window);
     24                // See ticket #14549 for more info
     25                module.exports = global.document ?
     26                        factory( global, true ) :
     27                        function( w ) {
     28                                if ( !w.document ) {
     29                                        throw new Error( "jQuery requires a window with a document" );
     30                                }
     31                                return factory( w );
     32                        };
     33        } else {
     34                factory( global );
     35        }
     36
     37// Pass this if window is not defined yet
     38}(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
    1539
    1640// Can't do this because several apps including ASP.NET trace
     
    1842// you try to trace through "use strict" call chains. (#13335)
    1943// Support: Firefox 18+
    20 //"use strict";
     44//
     45
     46var deletedIds = [];
     47
     48var slice = deletedIds.slice;
     49
     50var concat = deletedIds.concat;
     51
     52var push = deletedIds.push;
     53
     54var indexOf = deletedIds.indexOf;
     55
     56var class2type = {};
     57
     58var toString = class2type.toString;
     59
     60var hasOwn = class2type.hasOwnProperty;
     61
     62var trim = "".trim;
     63
     64var support = {};
     65
     66
     67
    2168var
    22         // The deferred used on DOM ready
    23         readyList,
    24 
    25         // A central reference to the root jQuery(document)
    26         rootjQuery,
    27 
    28         // Support: IE<10
    29         // For `typeof xmlNode.method` instead of `xmlNode.method !== undefined`
    30         core_strundefined = typeof undefined,
    31 
    32         // Use the correct document accordingly with window argument (sandbox)
    33         location = window.location,
    34         document = window.document,
    35         docElem = document.documentElement,
    36 
    37         // Map over jQuery in case of overwrite
    38         _jQuery = window.jQuery,
    39 
    40         // Map over the $ in case of overwrite
    41         _$ = window.$,
    42 
    43         // [[Class]] -> type pairs
    44         class2type = {},
    45 
    46         // List of deleted data cache ids, so we can reuse them
    47         core_deletedIds = [],
    48 
    49         core_version = "1.10.2",
    50 
    51         // Save a reference to some core methods
    52         core_concat = core_deletedIds.concat,
    53         core_push = core_deletedIds.push,
    54         core_slice = core_deletedIds.slice,
    55         core_indexOf = core_deletedIds.indexOf,
    56         core_toString = class2type.toString,
    57         core_hasOwn = class2type.hasOwnProperty,
    58         core_trim = core_version.trim,
     69        version = "1.11.0",
    5970
    6071        // Define a local copy of jQuery
    6172        jQuery = function( selector, context ) {
    6273                // The jQuery object is actually just the init constructor 'enhanced'
    63                 return new jQuery.fn.init( selector, context, rootjQuery );
    64         },
    65 
    66         // Used for matching numbers
    67         core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,
    68 
    69         // Used for splitting on whitespace
    70         core_rnotwhite = /\S+/g,
     74                // Need init if jQuery is called (just allow error to be thrown if not included)
     75                return new jQuery.fn.init( selector, context );
     76        },
    7177
    7278        // Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
    7379        rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
    74 
    75         // A simple way to check for HTML strings
    76         // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
    77         // Strict HTML recognition (#11290: must start with <)
    78         rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
    79 
    80         // Match a standalone tag
    81         rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
    82 
    83         // JSON RegExp
    84         rvalidchars = /^[\],:{}\s]*$/,
    85         rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
    86         rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
    87         rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g,
    8880
    8981        // Matches dashed string for camelizing
     
    9486        fcamelCase = function( all, letter ) {
    9587                return letter.toUpperCase();
    96         },
    97 
    98         // The ready event handler
    99         completed = function( event ) {
    100 
    101                 // readyState === "complete" is good enough for us to call the dom ready in oldIE
    102                 if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) {
    103                         detach();
    104                         jQuery.ready();
    105                 }
    106         },
    107         // Clean-up method for dom ready events
    108         detach = function() {
    109                 if ( document.addEventListener ) {
    110                         document.removeEventListener( "DOMContentLoaded", completed, false );
    111                         window.removeEventListener( "load", completed, false );
    112 
    113                 } else {
    114                         document.detachEvent( "onreadystatechange", completed );
    115                         window.detachEvent( "onload", completed );
    116                 }
    11788        };
    11889
    11990jQuery.fn = jQuery.prototype = {
    12091        // The current version of jQuery being used
    121         jquery: core_version,
     92        jquery: version,
    12293
    12394        constructor: jQuery,
    124         init: function( selector, context, rootjQuery ) {
    125                 var match, elem;
    126 
    127                 // HANDLE: $(""), $(null), $(undefined), $(false)
    128                 if ( !selector ) {
    129                         return this;
    130                 }
    131 
    132                 // Handle HTML strings
    133                 if ( typeof selector === "string" ) {
    134                         if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
    135                                 // Assume that strings that start and end with <> are HTML and skip the regex check
    136                                 match = [ null, selector, null ];
    137 
    138                         } else {
    139                                 match = rquickExpr.exec( selector );
    140                         }
    141 
    142                         // Match html or make sure no context is specified for #id
    143                         if ( match && (match[1] || !context) ) {
    144 
    145                                 // HANDLE: $(html) -> $(array)
    146                                 if ( match[1] ) {
    147                                         context = context instanceof jQuery ? context[0] : context;
    148 
    149                                         // scripts is true for back-compat
    150                                         jQuery.merge( this, jQuery.parseHTML(
    151                                                 match[1],
    152                                                 context && context.nodeType ? context.ownerDocument || context : document,
    153                                                 true
    154                                         ) );
    155 
    156                                         // HANDLE: $(html, props)
    157                                         if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
    158                                                 for ( match in context ) {
    159                                                         // Properties of context are called as methods if possible
    160                                                         if ( jQuery.isFunction( this[ match ] ) ) {
    161                                                                 this[ match ]( context[ match ] );
    162 
    163                                                         // ...and otherwise set as attributes
    164                                                         } else {
    165                                                                 this.attr( match, context[ match ] );
    166                                                         }
    167                                                 }
    168                                         }
    169 
    170                                         return this;
    171 
    172                                 // HANDLE: $(#id)
    173                                 } else {
    174                                         elem = document.getElementById( match[2] );
    175 
    176                                         // Check parentNode to catch when Blackberry 4.6 returns
    177                                         // nodes that are no longer in the document #6963
    178                                         if ( elem && elem.parentNode ) {
    179                                                 // Handle the case where IE and Opera return items
    180                                                 // by name instead of ID
    181                                                 if ( elem.id !== match[2] ) {
    182                                                         return rootjQuery.find( selector );
    183                                                 }
    184 
    185                                                 // Otherwise, we inject the element directly into the jQuery object
    186                                                 this.length = 1;
    187                                                 this[0] = elem;
    188                                         }
    189 
    190                                         this.context = document;
    191                                         this.selector = selector;
    192                                         return this;
    193                                 }
    194 
    195                         // HANDLE: $(expr, $(...))
    196                         } else if ( !context || context.jquery ) {
    197                                 return ( context || rootjQuery ).find( selector );
    198 
    199                         // HANDLE: $(expr, context)
    200                         // (which is just equivalent to: $(context).find(expr)
    201                         } else {
    202                                 return this.constructor( context ).find( selector );
    203                         }
    204 
    205                 // HANDLE: $(DOMElement)
    206                 } else if ( selector.nodeType ) {
    207                         this.context = this[0] = selector;
    208                         this.length = 1;
    209                         return this;
    210 
    211                 // HANDLE: $(function)
    212                 // Shortcut for document ready
    213                 } else if ( jQuery.isFunction( selector ) ) {
    214                         return rootjQuery.ready( selector );
    215                 }
    216 
    217                 if ( selector.selector !== undefined ) {
    218                         this.selector = selector.selector;
    219                         this.context = selector.context;
    220                 }
    221 
    222                 return jQuery.makeArray( selector, this );
    223         },
    22495
    22596        // Start with an empty selector
     
    230101
    231102        toArray: function() {
    232                 return core_slice.call( this );
     103                return slice.call( this );
    233104        },
    234105
     
    236107        // Get the whole matched element set as a clean array
    237108        get: function( num ) {
    238                 return num == null ?
     109                return num != null ?
    239110
    240111                        // Return a 'clean' array
    241                         this.toArray() :
     112                        ( num < 0 ? this[ num + this.length ] : this[ num ] ) :
    242113
    243114                        // Return just the object
    244                         ( num < 0 ? this[ this.length + num ] : this[ num ] );
     115                        slice.call( this );
    245116        },
    246117
     
    267138        },
    268139
    269         ready: function( fn ) {
    270                 // Add the callback
    271                 jQuery.ready.promise().done( fn );
    272 
    273                 return this;
     140        map: function( callback ) {
     141                return this.pushStack( jQuery.map(this, function( elem, i ) {
     142                        return callback.call( elem, i, elem );
     143                }));
    274144        },
    275145
    276146        slice: function() {
    277                 return this.pushStack( core_slice.apply( this, arguments ) );
     147                return this.pushStack( slice.apply( this, arguments ) );
    278148        },
    279149
     
    292162        },
    293163
    294         map: function( callback ) {
    295                 return this.pushStack( jQuery.map(this, function( elem, i ) {
    296                         return callback.call( elem, i, elem );
    297                 }));
    298         },
    299 
    300164        end: function() {
    301165                return this.prevObject || this.constructor(null);
     
    304168        // For internal use only.
    305169        // Behaves like an Array's method, not like a jQuery method.
    306         push: core_push,
    307         sort: [].sort,
    308         splice: [].splice
     170        push: push,
     171        sort: deletedIds.sort,
     172        splice: deletedIds.splice
    309173};
    310 
    311 // Give the init function the jQuery prototype for later instantiation
    312 jQuery.fn.init.prototype = jQuery.fn;
    313174
    314175jQuery.extend = jQuery.fn.extend = function() {
     
    322183        if ( typeof target === "boolean" ) {
    323184                deep = target;
    324                 target = arguments[1] || {};
     185
    325186                // skip the boolean and the target
    326                 i = 2;
     187                target = arguments[ i ] || {};
     188                i++;
    327189        }
    328190
     
    333195
    334196        // extend jQuery itself if only one argument is passed
    335         if ( length === i ) {
     197        if ( i === length ) {
    336198                target = this;
    337                 --i;
     199                i--;
    338200        }
    339201
     
    378240jQuery.extend({
    379241        // Unique for each copy of jQuery on the page
    380         // Non-digits removed to match rinlinejQuery
    381         expando: "jQuery" + ( core_version + Math.random() ).replace( /\D/g, "" ),
    382 
    383         noConflict: function( deep ) {
    384                 if ( window.$ === jQuery ) {
    385                         window.$ = _$;
    386                 }
    387 
    388                 if ( deep && window.jQuery === jQuery ) {
    389                         window.jQuery = _jQuery;
    390                 }
    391 
    392                 return jQuery;
    393         },
    394 
    395         // Is the DOM ready to be used? Set to true once it occurs.
    396         isReady: false,
    397 
    398         // A counter to track how many items to wait for before
    399         // the ready event fires. See #6781
    400         readyWait: 1,
    401 
    402         // Hold (or release) the ready event
    403         holdReady: function( hold ) {
    404                 if ( hold ) {
    405                         jQuery.readyWait++;
    406                 } else {
    407                         jQuery.ready( true );
    408                 }
    409         },
    410 
    411         // Handle when the DOM is ready
    412         ready: function( wait ) {
    413 
    414                 // Abort if there are pending holds or we're already ready
    415                 if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
    416                         return;
    417                 }
    418 
    419                 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
    420                 if ( !document.body ) {
    421                         return setTimeout( jQuery.ready );
    422                 }
    423 
    424                 // Remember that the DOM is ready
    425                 jQuery.isReady = true;
    426 
    427                 // If a normal DOM Ready event fired, decrement, and wait if need be
    428                 if ( wait !== true && --jQuery.readyWait > 0 ) {
    429                         return;
    430                 }
    431 
    432                 // If there are functions bound, to execute
    433                 readyList.resolveWith( document, [ jQuery ] );
    434 
    435                 // Trigger any bound ready events
    436                 if ( jQuery.fn.trigger ) {
    437                         jQuery( document ).trigger("ready").off("ready");
    438                 }
    439         },
     242        expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
     243
     244        // Assume jQuery is ready without the ready module
     245        isReady: true,
     246
     247        error: function( msg ) {
     248                throw new Error( msg );
     249        },
     250
     251        noop: function() {},
    440252
    441253        // See test/unit/core.js for details concerning isFunction.
     
    456268
    457269        isNumeric: function( obj ) {
    458                 return !isNaN( parseFloat(obj) ) && isFinite( obj );
    459         },
    460 
    461         type: function( obj ) {
    462                 if ( obj == null ) {
    463                         return String( obj );
    464                 }
    465                 return typeof obj === "object" || typeof obj === "function" ?
    466                         class2type[ core_toString.call(obj) ] || "object" :
    467                         typeof obj;
     270                // parseFloat NaNs numeric-cast false positives (null|true|false|"")
     271                // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
     272                // subtraction forces infinities to NaN
     273                return obj - parseFloat( obj ) >= 0;
     274        },
     275
     276        isEmptyObject: function( obj ) {
     277                var name;
     278                for ( name in obj ) {
     279                        return false;
     280                }
     281                return true;
    468282        },
    469283
     
    481295                        // Not own constructor property must be Object
    482296                        if ( obj.constructor &&
    483                                 !core_hasOwn.call(obj, "constructor") &&
    484                                 !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
     297                                !hasOwn.call(obj, "constructor") &&
     298                                !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
    485299                                return false;
    486300                        }
     
    492306                // Support: IE<9
    493307                // Handle iteration over inherited properties before own properties.
    494                 if ( jQuery.support.ownLast ) {
     308                if ( support.ownLast ) {
    495309                        for ( key in obj ) {
    496                                 return core_hasOwn.call( obj, key );
     310                                return hasOwn.call( obj, key );
    497311                        }
    498312                }
     
    502316                for ( key in obj ) {}
    503317
    504                 return key === undefined || core_hasOwn.call( obj, key );
    505         },
    506 
    507         isEmptyObject: function( obj ) {
    508                 var name;
    509                 for ( name in obj ) {
    510                         return false;
    511                 }
    512                 return true;
    513         },
    514 
    515         error: function( msg ) {
    516                 throw new Error( msg );
    517         },
    518 
    519         // data: string of html
    520         // context (optional): If specified, the fragment will be created in this context, defaults to document
    521         // keepScripts (optional): If true, will include scripts passed in the html string
    522         parseHTML: function( data, context, keepScripts ) {
    523                 if ( !data || typeof data !== "string" ) {
    524                         return null;
    525                 }
    526                 if ( typeof context === "boolean" ) {
    527                         keepScripts = context;
    528                         context = false;
    529                 }
    530                 context = context || document;
    531 
    532                 var parsed = rsingleTag.exec( data ),
    533                         scripts = !keepScripts && [];
    534 
    535                 // Single tag
    536                 if ( parsed ) {
    537                         return [ context.createElement( parsed[1] ) ];
    538                 }
    539 
    540                 parsed = jQuery.buildFragment( [ data ], context, scripts );
    541                 if ( scripts ) {
    542                         jQuery( scripts ).remove();
    543                 }
    544                 return jQuery.merge( [], parsed.childNodes );
    545         },
    546 
    547         parseJSON: function( data ) {
    548                 // Attempt to parse using the native JSON parser first
    549                 if ( window.JSON && window.JSON.parse ) {
    550                         return window.JSON.parse( data );
    551                 }
    552 
    553                 if ( data === null ) {
    554                         return data;
    555                 }
    556 
    557                 if ( typeof data === "string" ) {
    558 
    559                         // Make sure leading/trailing whitespace is removed (IE can't handle it)
    560                         data = jQuery.trim( data );
    561 
    562                         if ( data ) {
    563                                 // Make sure the incoming data is actual JSON
    564                                 // Logic borrowed from http://json.org/json2.js
    565                                 if ( rvalidchars.test( data.replace( rvalidescape, "@" )
    566                                         .replace( rvalidtokens, "]" )
    567                                         .replace( rvalidbraces, "")) ) {
    568 
    569                                         return ( new Function( "return " + data ) )();
    570                                 }
    571                         }
    572                 }
    573 
    574                 jQuery.error( "Invalid JSON: " + data );
    575         },
    576 
    577         // Cross-browser xml parsing
    578         parseXML: function( data ) {
    579                 var xml, tmp;
    580                 if ( !data || typeof data !== "string" ) {
    581                         return null;
    582                 }
    583                 try {
    584                         if ( window.DOMParser ) { // Standard
    585                                 tmp = new DOMParser();
    586                                 xml = tmp.parseFromString( data , "text/xml" );
    587                         } else { // IE
    588                                 xml = new ActiveXObject( "Microsoft.XMLDOM" );
    589                                 xml.async = "false";
    590                                 xml.loadXML( data );
    591                         }
    592                 } catch( e ) {
    593                         xml = undefined;
    594                 }
    595                 if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
    596                         jQuery.error( "Invalid XML: " + data );
    597                 }
    598                 return xml;
    599         },
    600 
    601         noop: function() {},
     318                return key === undefined || hasOwn.call( obj, key );
     319        },
     320
     321        type: function( obj ) {
     322                if ( obj == null ) {
     323                        return obj + "";
     324                }
     325                return typeof obj === "object" || typeof obj === "function" ?
     326                        class2type[ toString.call(obj) ] || "object" :
     327                        typeof obj;
     328        },
    602329
    603330        // Evaluates a script in a global context
     
    676403
    677404        // Use native String.trim function wherever possible
    678         trim: core_trim && !core_trim.call("\uFEFF\xA0") ?
     405        trim: trim && !trim.call("\uFEFF\xA0") ?
    679406                function( text ) {
    680407                        return text == null ?
    681408                                "" :
    682                                 core_trim.call( text );
     409                                trim.call( text );
    683410                } :
    684411
     
    701428                                );
    702429                        } else {
    703                                 core_push.call( ret, arr );
     430                                push.call( ret, arr );
    704431                        }
    705432                }
     
    712439
    713440                if ( arr ) {
    714                         if ( core_indexOf ) {
    715                                 return core_indexOf.call( arr, elem, i );
     441                        if ( indexOf ) {
     442                                return indexOf.call( arr, elem, i );
    716443                        }
    717444
     
    731458
    732459        merge: function( first, second ) {
    733                 var l = second.length,
    734                         i = first.length,
    735                         j = 0;
    736 
    737                 if ( typeof l === "number" ) {
    738                         for ( ; j < l; j++ ) {
    739                                 first[ i++ ] = second[ j ];
    740                         }
    741                 } else {
     460                var len = +second.length,
     461                        j = 0,
     462                        i = first.length;
     463
     464                while ( j < len ) {
     465                        first[ i++ ] = second[ j++ ];
     466                }
     467
     468                // Support: IE<9
     469                // Workaround casting of .length to NaN on otherwise arraylike objects (e.g., NodeLists)
     470                if ( len !== len ) {
    742471                        while ( second[j] !== undefined ) {
    743472                                first[ i++ ] = second[ j++ ];
     
    750479        },
    751480
    752         grep: function( elems, callback, inv ) {
    753                 var retVal,
    754                         ret = [],
     481        grep: function( elems, callback, invert ) {
     482                var callbackInverse,
     483                        matches = [],
    755484                        i = 0,
    756                         length = elems.length;
    757                 inv = !!inv;
     485                        length = elems.length,
     486                        callbackExpect = !invert;
    758487
    759488                // Go through the array, only saving the items
    760489                // that pass the validator function
    761490                for ( ; i < length; i++ ) {
    762                         retVal = !!callback( elems[ i ], i );
    763                         if ( inv !== retVal ) {
    764                                 ret.push( elems[ i ] );
    765                         }
    766                 }
    767 
    768                 return ret;
     491                        callbackInverse = !callback( elems[ i ], i );
     492                        if ( callbackInverse !== callbackExpect ) {
     493                                matches.push( elems[ i ] );
     494                        }
     495                }
     496
     497                return matches;
    769498        },
    770499
     
    777506                        ret = [];
    778507
    779                 // Go through the array, translating each of the items to their
     508                // Go through the array, translating each of the items to their new values
    780509                if ( isArray ) {
    781510                        for ( ; i < length; i++ ) {
     
    783512
    784513                                if ( value != null ) {
    785                                         ret[ ret.length ] = value;
     514                                        ret.push( value );
    786515                                }
    787516                        }
     
    793522
    794523                                if ( value != null ) {
    795                                         ret[ ret.length ] = value;
     524                                        ret.push( value );
    796525                                }
    797526                        }
     
    799528
    800529                // Flatten any nested arrays
    801                 return core_concat.apply( [], ret );
     530                return concat.apply( [], ret );
    802531        },
    803532
     
    823552
    824553                // Simulated bind
    825                 args = core_slice.call( arguments, 2 );
     554                args = slice.call( arguments, 2 );
    826555                proxy = function() {
    827                         return fn.apply( context || this, args.concat( core_slice.call( arguments ) ) );
     556                        return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
    828557                };
    829558
     
    834563        },
    835564
    836         // Multifunctional method to get and set values of a collection
    837         // The value/s can optionally be executed if it's a function
    838         access: function( elems, fn, key, value, chainable, emptyGet, raw ) {
    839                 var i = 0,
    840                         length = elems.length,
    841                         bulk = key == null;
    842 
    843                 // Sets many values
    844                 if ( jQuery.type( key ) === "object" ) {
    845                         chainable = true;
    846                         for ( i in key ) {
    847                                 jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );
    848                         }
    849 
    850                 // Sets one value
    851                 } else if ( value !== undefined ) {
    852                         chainable = true;
    853 
    854                         if ( !jQuery.isFunction( value ) ) {
    855                                 raw = true;
    856                         }
    857 
    858                         if ( bulk ) {
    859                                 // Bulk operations run against the entire set
    860                                 if ( raw ) {
    861                                         fn.call( elems, value );
    862                                         fn = null;
    863 
    864                                 // ...except when executing function values
    865                                 } else {
    866                                         bulk = fn;
    867                                         fn = function( elem, key, value ) {
    868                                                 return bulk.call( jQuery( elem ), value );
    869                                         };
    870                                 }
    871                         }
    872 
    873                         if ( fn ) {
    874                                 for ( ; i < length; i++ ) {
    875                                         fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );
    876                                 }
    877                         }
    878                 }
    879 
    880                 return chainable ?
    881                         elems :
    882 
    883                         // Gets
    884                         bulk ?
    885                                 fn.call( elems ) :
    886                                 length ? fn( elems[0], key ) : emptyGet;
    887         },
    888 
    889565        now: function() {
    890                 return ( new Date() ).getTime();
    891         },
    892 
    893         // A method for quickly swapping in/out CSS properties to get correct calculations.
    894         // Note: this method belongs to the css module but it's needed here for the support module.
    895         // If support gets modularized, this method should be moved back to the css module.
    896         swap: function( elem, options, callback, args ) {
    897                 var ret, name,
    898                         old = {};
    899 
    900                 // Remember the old values, and insert the new ones
    901                 for ( name in options ) {
    902                         old[ name ] = elem.style[ name ];
    903                         elem.style[ name ] = options[ name ];
    904                 }
    905 
    906                 ret = callback.apply( elem, args || [] );
    907 
    908                 // Revert the old values
    909                 for ( name in options ) {
    910                         elem.style[ name ] = old[ name ];
    911                 }
    912 
    913                 return ret;
    914         }
     566                return +( new Date() );
     567        },
     568
     569        // jQuery.support is not used in Core but other projects attach their
     570        // properties to it so it needs to exist.
     571        support: support
    915572});
    916 
    917 jQuery.ready.promise = function( obj ) {
    918         if ( !readyList ) {
    919 
    920                 readyList = jQuery.Deferred();
    921 
    922                 // Catch cases where $(document).ready() is called after the browser event has already occurred.
    923                 // we once tried to use readyState "interactive" here, but it caused issues like the one
    924                 // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
    925                 if ( document.readyState === "complete" ) {
    926                         // Handle it asynchronously to allow scripts the opportunity to delay ready
    927                         setTimeout( jQuery.ready );
    928 
    929                 // Standards-based browsers support DOMContentLoaded
    930                 } else if ( document.addEventListener ) {
    931                         // Use the handy event callback
    932                         document.addEventListener( "DOMContentLoaded", completed, false );
    933 
    934                         // A fallback to window.onload, that will always work
    935                         window.addEventListener( "load", completed, false );
    936 
    937                 // If IE event model is used
    938                 } else {
    939                         // Ensure firing before onload, maybe late but safe also for iframes
    940                         document.attachEvent( "onreadystatechange", completed );
    941 
    942                         // A fallback to window.onload, that will always work
    943                         window.attachEvent( "onload", completed );
    944 
    945                         // If IE and not a frame
    946                         // continually check to see if the document is ready
    947                         var top = false;
    948 
    949                         try {
    950                                 top = window.frameElement == null && document.documentElement;
    951                         } catch(e) {}
    952 
    953                         if ( top && top.doScroll ) {
    954                                 (function doScrollCheck() {
    955                                         if ( !jQuery.isReady ) {
    956 
    957                                                 try {
    958                                                         // Use the trick by Diego Perini
    959                                                         // http://javascript.nwbox.com/IEContentLoaded/
    960                                                         top.doScroll("left");
    961                                                 } catch(e) {
    962                                                         return setTimeout( doScrollCheck, 50 );
    963                                                 }
    964 
    965                                                 // detach all dom ready events
    966                                                 detach();
    967 
    968                                                 // and execute any waiting functions
    969                                                 jQuery.ready();
    970                                         }
    971                                 })();
    972                         }
    973                 }
    974         }
    975         return readyList.promise( obj );
    976 };
    977573
    978574// Populate the class2type map
     
    985581                type = jQuery.type( obj );
    986582
    987         if ( jQuery.isWindow( obj ) ) {
     583        if ( type === "function" || jQuery.isWindow( obj ) ) {
    988584                return false;
    989585        }
     
    993589        }
    994590
    995         return type === "array" || type !== "function" &&
    996                 ( length === 0 ||
    997                 typeof length === "number" && length > 0 && ( length - 1 ) in obj );
     591        return type === "array" || length === 0 ||
     592                typeof length === "number" && length > 0 && ( length - 1 ) in obj;
    998593}
    999 
    1000 // All jQuery objects should point back to these
    1001 rootjQuery = jQuery(document);
     594var Sizzle =
    1002595/*!
    1003  * Sizzle CSS Selector Engine v1.10.2
     596 * Sizzle CSS Selector Engine v1.10.16
    1004597 * http://sizzlejs.com/
    1005598 *
     
    1008601 * http://jquery.org/license
    1009602 *
    1010  * Date: 2013-07-03
     603 * Date: 2014-01-13
    1011604 */
    1012 (function( window, undefined ) {
     605(function( window ) {
    1013606
    1014607var i,
    1015608        support,
    1016         cachedruns,
    1017609        Expr,
    1018610        getText,
     
    1021613        outermostContext,
    1022614        sortInput,
     615        hasDuplicate,
    1023616
    1024617        // Local document vars
     
    1040633        tokenCache = createCache(),
    1041634        compilerCache = createCache(),
    1042         hasDuplicate = false,
    1043635        sortOrder = function( a, b ) {
    1044636                if ( a === b ) {
    1045637                        hasDuplicate = true;
    1046                         return 0;
    1047638                }
    1048639                return 0;
     
    1104695        rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
    1105696
    1106         rsibling = new RegExp( whitespace + "*[+~]" ),
    1107         rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*)" + whitespace + "*\\]", "g" ),
     697        rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
    1108698
    1109699        rpseudo = new RegExp( pseudos ),
     
    1126716        },
    1127717
     718        rinputs = /^(?:input|select|textarea|button)$/i,
     719        rheader = /^h\d$/i,
     720
    1128721        rnative = /^[^{]+\{\s*\[native \w/,
    1129722
     
    1131724        rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
    1132725
    1133         rinputs = /^(?:input|select|textarea|button)$/i,
    1134         rheader = /^h\d$/i,
    1135 
     726        rsibling = /[+~]/,
    1136727        rescape = /'|\\/g,
    1137728
     
    1145736                return high !== high || escapedWhitespace ?
    1146737                        escaped :
    1147                         // BMP codepoint
    1148738                        high < 0 ?
     739                                // BMP codepoint
    1149740                                String.fromCharCode( high + 0x10000 ) :
    1150741                                // Supplemental Plane codepoint (surrogate pair)
     
    1210801                                        elem = context.getElementById( m );
    1211802                                        // Check parentNode to catch when Blackberry 4.6 returns
    1212                                         // nodes that are no longer in the document #6963
     803                                        // nodes that are no longer in the document (jQuery #6963)
    1213804                                        if ( elem && elem.parentNode ) {
    1214805                                                // Handle the case where IE, Opera, and Webkit return items
     
    1266857                                        groups[i] = nid + toSelector( groups[i] );
    1267858                                }
    1268                                 newContext = rsibling.test( selector ) && context.parentNode || context;
     859                                newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context;
    1269860                                newSelector = groups.join(",");
    1270861                        }
     
    1301892        function cache( key, value ) {
    1302893                // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
    1303                 if ( keys.push( key += " " ) > Expr.cacheLength ) {
     894                if ( keys.push( key + " " ) > Expr.cacheLength ) {
    1304895                        // Only keep the most recent entries
    1305896                        delete cache[ keys.shift() ];
    1306897                }
    1307                 return (cache[ key ] = value);
     898                return (cache[ key + " " ] = value);
    1308899        }
    1309900        return cache;
     
    14281019
    14291020/**
    1430  * Detect xml
     1021 * Checks a node for validity as a Sizzle context
     1022 * @param {Element|Object=} context
     1023 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
     1024 */
     1025function testContext( context ) {
     1026        return context && typeof context.getElementsByTagName !== strundefined && context;
     1027}
     1028
     1029// Expose support vars for convenience
     1030support = Sizzle.support = {};
     1031
     1032/**
     1033 * Detects XML nodes
    14311034 * @param {Element|Object} elem An element or a document
     1035 * @returns {Boolean} True iff elem is a non-HTML XML node
    14321036 */
    14331037isXML = Sizzle.isXML = function( elem ) {
     
    14381042};
    14391043
    1440 // Expose support vars for convenience
    1441 support = Sizzle.support = {};
    1442 
    14431044/**
    14441045 * Sets document-related variables once based on the current document
     
    14471048 */
    14481049setDocument = Sizzle.setDocument = function( node ) {
    1449         var doc = node ? node.ownerDocument || node : preferredDoc,
     1050        var hasCompare,
     1051                doc = node ? node.ownerDocument || node : preferredDoc,
    14501052                parent = doc.defaultView;
    14511053
     
    14661068        // IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
    14671069        // IE6-8 do not support the defaultView property so parent will be undefined
    1468         if ( parent && parent.attachEvent && parent !== parent.top ) {
    1469                 parent.attachEvent( "onbeforeunload", function() {
    1470                         setDocument();
    1471                 });
     1070        if ( parent && parent !== parent.top ) {
     1071                // IE11 does not have attachEvent, so all must suffer
     1072                if ( parent.addEventListener ) {
     1073                        parent.addEventListener( "unload", function() {
     1074                                setDocument();
     1075                        }, false );
     1076                } else if ( parent.attachEvent ) {
     1077                        parent.attachEvent( "onunload", function() {
     1078                                setDocument();
     1079                        });
     1080                }
    14721081        }
    14731082
     
    14921101
    14931102        // Check if getElementsByClassName can be trusted
    1494         support.getElementsByClassName = assert(function( div ) {
     1103        support.getElementsByClassName = rnative.test( doc.getElementsByClassName ) && assert(function( div ) {
    14951104                div.innerHTML = "<div class='a'></div><div class='a i'></div>";
    14961105
     
    15991208                        // since its presence should be enough
    16001209                        // http://bugs.jquery.com/ticket/12359
    1601                         div.innerHTML = "<select><option selected=''></option></select>";
     1210                        div.innerHTML = "<select t=''><option selected=''></option></select>";
     1211
     1212                        // Support: IE8, Opera 10-12
     1213                        // Nothing should be selected when empty strings follow ^= or $= or *=
     1214                        if ( div.querySelectorAll("[t^='']").length ) {
     1215                                rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
     1216                        }
    16021217
    16031218                        // Support: IE8
     
    16161231
    16171232                assert(function( div ) {
    1618 
    1619                         // Support: Opera 10-12/IE8
    1620                         // ^= $= *= and empty values
    1621                         // Should not select anything
    16221233                        // Support: Windows 8 Native Apps
    1623                         // The type attribute is restricted during .innerHTML assignment
     1234                        // The type and name attributes are restricted during .innerHTML assignment
    16241235                        var input = doc.createElement("input");
    16251236                        input.setAttribute( "type", "hidden" );
    1626                         div.appendChild( input ).setAttribute( "t", "" );
    1627 
    1628                         if ( div.querySelectorAll("[t^='']").length ) {
    1629                                 rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
     1237                        div.appendChild( input ).setAttribute( "name", "D" );
     1238
     1239                        // Support: IE8
     1240                        // Enforce case-sensitivity of name attribute
     1241                        if ( div.querySelectorAll("[name=d]").length ) {
     1242                                rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
    16301243                        }
    16311244
     
    16641277        /* Contains
    16651278        ---------------------------------------------------------------------- */
     1279        hasCompare = rnative.test( docElem.compareDocumentPosition );
    16661280
    16671281        // Element contains another
    16681282        // Purposefully does not implement inclusive descendent
    16691283        // As in, an element does not contain itself
    1670         contains = rnative.test( docElem.contains ) || docElem.compareDocumentPosition ?
     1284        contains = hasCompare || rnative.test( docElem.contains ) ?
    16711285                function( a, b ) {
    16721286                        var adown = a.nodeType === 9 ? a.documentElement : a,
     
    16931307
    16941308        // Document order sorting
    1695         sortOrder = docElem.compareDocumentPosition ?
     1309        sortOrder = hasCompare ?
    16961310        function( a, b ) {
    16971311
     
    17021316                }
    17031317
    1704                 var compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition( b );
    1705 
     1318                // Sort on method existence if only one input has compareDocumentPosition
     1319                var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
    17061320                if ( compare ) {
    1707                         // Disconnected nodes
    1708                         if ( compare & 1 ||
    1709                                 (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
    1710 
    1711                                 // Choose the first element that is related to our preferred document
    1712                                 if ( a === doc || contains(preferredDoc, a) ) {
    1713                                         return -1;
    1714                                 }
    1715                                 if ( b === doc || contains(preferredDoc, b) ) {
    1716                                         return 1;
    1717                                 }
    1718 
    1719                                 // Maintain original order
    1720                                 return sortInput ?
    1721                                         ( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
    1722                                         0;
    1723                         }
    1724 
    1725                         return compare & 4 ? -1 : 1;
    1726                 }
    1727 
    1728                 // Not directly comparable, sort on existence of method
    1729                 return a.compareDocumentPosition ? -1 : 1;
     1321                        return compare;
     1322                }
     1323
     1324                // Calculate position if both inputs belong to the same document
     1325                compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
     1326                        a.compareDocumentPosition( b ) :
     1327
     1328                        // Otherwise we know they are disconnected
     1329                        1;
     1330
     1331                // Disconnected nodes
     1332                if ( compare & 1 ||
     1333                        (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
     1334
     1335                        // Choose the first element that is related to our preferred document
     1336                        if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
     1337                                return -1;
     1338                        }
     1339                        if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
     1340                                return 1;
     1341                        }
     1342
     1343                        // Maintain original order
     1344                        return sortInput ?
     1345                                ( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
     1346                                0;
     1347                }
     1348
     1349                return compare & 4 ? -1 : 1;
    17301350        } :
    17311351        function( a, b ) {
     1352                // Exit early if the nodes are identical
     1353                if ( a === b ) {
     1354                        hasDuplicate = true;
     1355                        return 0;
     1356                }
     1357
    17321358                var cur,
    17331359                        i = 0,
     
    17371363                        bp = [ b ];
    17381364
    1739                 // Exit early if the nodes are identical
    1740                 if ( a === b ) {
    1741                         hasDuplicate = true;
    1742                         return 0;
    1743 
    17441365                // Parentless nodes are either documents or disconnected
    1745                 } else if ( !aup || !bup ) {
     1366                if ( !aup || !bup ) {
    17461367                        return a === doc ? -1 :
    17471368                                b === doc ? 1 :
     
    18381459                        undefined;
    18391460
    1840         return val === undefined ?
     1461        return val !== undefined ?
     1462                val :
    18411463                support.attributes || !documentIsHTML ?
    18421464                        elem.getAttribute( name ) :
    18431465                        (val = elem.getAttributeNode(name)) && val.specified ?
    18441466                                val.value :
    1845                                 null :
    1846                 val;
     1467                                null;
    18471468};
    18481469
     
    18771498        }
    18781499
     1500        // Clear input after sorting to release objects
     1501        // See https://github.com/jquery/sizzle/pull/225
     1502        sortInput = null;
     1503
    18791504        return results;
    18801505};
     
    18921517        if ( !nodeType ) {
    18931518                // If no nodeType, this is expected to be an array
    1894                 for ( ; (node = elem[i]); i++ ) {
     1519                while ( (node = elem[i++]) ) {
    18951520                        // Do not traverse comment nodes
    18961521                        ret += getText( node );
     
    18981523        } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
    18991524                // Use textContent for elements
    1900                 // innerText usage removed for consistency of new lines (see #11153)
     1525                // innerText usage removed for consistency of new lines (jQuery #11153)
    19011526                if ( typeof elem.textContent === "string" ) {
    19021527                        return elem.textContent;
     
    22951920                "empty": function( elem ) {
    22961921                        // http://www.w3.org/TR/selectors/#empty-pseudo
    2297                         // :empty is only affected by element nodes and content nodes(including text(3), cdata(4)),
    2298                         //   not comment, processing instructions, or others
    2299                         // Thanks to Diego Perini for the nodeName shortcut
    2300                         //   Greater than "@" means alpha characters (specifically not starting with "#" or "?")
     1922                        // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
     1923                        //   but not by others (comment: 8; processing instruction: 7; etc.)
     1924                        // nodeType < 6 works because attributes (2) do not appear as children
    23011925                        for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
    2302                                 if ( elem.nodeName > "@" || elem.nodeType === 3 || elem.nodeType === 4 ) {
     1926                                if ( elem.nodeType < 6 ) {
    23031927                                        return false;
    23041928                                }
     
    23271951                "text": function( elem ) {
    23281952                        var attr;
    2329                         // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
    2330                         // use getAttribute instead to test this case
    23311953                        return elem.nodeName.toLowerCase() === "input" &&
    23321954                                elem.type === "text" &&
    2333                                 ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === elem.type );
     1955
     1956                                // Support: IE<8
     1957                                // New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
     1958                                ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
    23341959                },
    23351960
     
    24172042                                soFar = soFar.slice( match[0].length ) || soFar;
    24182043                        }
    2419                         groups.push( tokens = [] );
     2044                        groups.push( (tokens = []) );
    24202045                }
    24212046
     
    24902115                // Check against all ancestor/preceding elements
    24912116                function( elem, context, xml ) {
    2492                         var data, cache, outerCache,
    2493                                 dirkey = dirruns + " " + doneName;
     2117                        var oldCache, outerCache,
     2118                                newCache = [ dirruns, doneName ];
    24942119
    24952120                        // We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
     
    25062131                                        if ( elem.nodeType === 1 || checkNonElements ) {
    25072132                                                outerCache = elem[ expando ] || (elem[ expando ] = {});
    2508                                                 if ( (cache = outerCache[ dir ]) && cache[0] === dirkey ) {
    2509                                                         if ( (data = cache[1]) === true || data === cachedruns ) {
    2510                                                                 return data === true;
    2511                                                         }
     2133                                                if ( (oldCache = outerCache[ dir ]) &&
     2134                                                        oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
     2135
     2136                                                        // Assign to newCache so results back-propagate to previous elements
     2137                                                        return (newCache[ 2 ] = oldCache[ 2 ]);
    25122138                                                } else {
    2513                                                         cache = outerCache[ dir ] = [ dirkey ];
    2514                                                         cache[1] = matcher( elem, context, xml ) || cachedruns;
    2515                                                         if ( cache[1] === true ) {
     2139                                                        // Reuse newcache so results back-propagate to previous elements
     2140                                                        outerCache[ dir ] = newCache;
     2141
     2142                                                        // A match means we're done; a fail means we have to keep checking
     2143                                                        if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
    25162144                                                                return true;
    25172145                                                        }
     
    27072335
    27082336function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
    2709         // A counter to specify which element is currently being matched
    2710         var matcherCachedRuns = 0,
    2711                 bySet = setMatchers.length > 0,
     2337        var bySet = setMatchers.length > 0,
    27122338                byElement = elementMatchers.length > 0,
    2713                 superMatcher = function( seed, context, xml, results, expandContext ) {
     2339                superMatcher = function( seed, context, xml, results, outermost ) {
    27142340                        var elem, j, matcher,
    2715                                 setMatched = [],
    27162341                                matchedCount = 0,
    27172342                                i = "0",
    27182343                                unmatched = seed && [],
    2719                                 outermost = expandContext != null,
     2344                                setMatched = [],
    27202345                                contextBackup = outermostContext,
    2721                                 // We must always have either seed elements or context
    2722                                 elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ),
     2346                                // We must always have either seed elements or outermost context
     2347                                elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
    27232348                                // Use integer dirruns iff this is the outermost matcher
    2724                                 dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1);
     2349                                dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
     2350                                len = elems.length;
    27252351
    27262352                        if ( outermost ) {
    27272353                                outermostContext = context !== document && context;
    2728                                 cachedruns = matcherCachedRuns;
    27292354                        }
    27302355
    27312356                        // Add elements passing elementMatchers directly to results
    27322357                        // Keep `i` a string if there are no elements so `matchedCount` will be "00" below
    2733                         for ( ; (elem = elems[i]) != null; i++ ) {
     2358                        // Support: IE<9, Safari
     2359                        // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
     2360                        for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
    27342361                                if ( byElement && elem ) {
    27352362                                        j = 0;
     
    27422369                                        if ( outermost ) {
    27432370                                                dirruns = dirrunsUnique;
    2744                                                 cachedruns = ++matcherCachedRuns;
    27452371                                        }
    27462372                                }
     
    28772503                                        if ( (seed = find(
    28782504                                                token.matches[0].replace( runescape, funescape ),
    2879                                                 rsibling.test( tokens[0].type ) && context.parentNode || context
     2505                                                rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
    28802506                                        )) ) {
    28812507
     
    29022528                !documentIsHTML,
    29032529                results,
    2904                 rsibling.test( selector )
     2530                rsibling.test( selector ) && testContext( context.parentNode ) || context
    29052531        );
    29062532        return results;
     
    29142540// Support: Chrome<14
    29152541// Always assume duplicates if they aren't passed to the comparison function
    2916 support.detectDuplicates = hasDuplicate;
     2542support.detectDuplicates = !!hasDuplicate;
    29172543
    29182544// Initialize against the default document
     
    29622588                var val;
    29632589                if ( !isXML ) {
    2964                         return (val = elem.getAttributeNode( name )) && val.specified ?
    2965                                 val.value :
    2966                                 elem[ name ] === true ? name.toLowerCase() : null;
     2590                        return elem[ name ] === true ? name.toLowerCase() :
     2591                                        (val = elem.getAttributeNode( name )) && val.specified ?
     2592                                        val.value :
     2593                                null;
    29672594                }
    29682595        });
    29692596}
     2597
     2598return Sizzle;
     2599
     2600})( window );
     2601
     2602
    29702603
    29712604jQuery.find = Sizzle;
     
    29782611
    29792612
    2980 })( window );
     2613
     2614var rneedsContext = jQuery.expr.match.needsContext;
     2615
     2616var rsingleTag = (/^<(\w+)\s*\/?>(?:<\/\1>|)$/);
     2617
     2618
     2619
     2620var risSimple = /^.[^:#\[\.,]*$/;
     2621
     2622// Implement the identical functionality for filter and not
     2623function winnow( elements, qualifier, not ) {
     2624        if ( jQuery.isFunction( qualifier ) ) {
     2625                return jQuery.grep( elements, function( elem, i ) {
     2626                        /* jshint -W018 */
     2627                        return !!qualifier.call( elem, i, elem ) !== not;
     2628                });
     2629
     2630        }
     2631
     2632        if ( qualifier.nodeType ) {
     2633                return jQuery.grep( elements, function( elem ) {
     2634                        return ( elem === qualifier ) !== not;
     2635                });
     2636
     2637        }
     2638
     2639        if ( typeof qualifier === "string" ) {
     2640                if ( risSimple.test( qualifier ) ) {
     2641                        return jQuery.filter( qualifier, elements, not );
     2642                }
     2643
     2644                qualifier = jQuery.filter( qualifier, elements );
     2645        }
     2646
     2647        return jQuery.grep( elements, function( elem ) {
     2648                return ( jQuery.inArray( elem, qualifier ) >= 0 ) !== not;
     2649        });
     2650}
     2651
     2652jQuery.filter = function( expr, elems, not ) {
     2653        var elem = elems[ 0 ];
     2654
     2655        if ( not ) {
     2656                expr = ":not(" + expr + ")";
     2657        }
     2658
     2659        return elems.length === 1 && elem.nodeType === 1 ?
     2660                jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :
     2661                jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
     2662                        return elem.nodeType === 1;
     2663                }));
     2664};
     2665
     2666jQuery.fn.extend({
     2667        find: function( selector ) {
     2668                var i,
     2669                        ret = [],
     2670                        self = this,
     2671                        len = self.length;
     2672
     2673                if ( typeof selector !== "string" ) {
     2674                        return this.pushStack( jQuery( selector ).filter(function() {
     2675                                for ( i = 0; i < len; i++ ) {
     2676                                        if ( jQuery.contains( self[ i ], this ) ) {
     2677                                                return true;
     2678                                        }
     2679                                }
     2680                        }) );
     2681                }
     2682
     2683                for ( i = 0; i < len; i++ ) {
     2684                        jQuery.find( selector, self[ i ], ret );
     2685                }
     2686
     2687                // Needed because $( selector, context ) becomes $( context ).find( selector )
     2688                ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );
     2689                ret.selector = this.selector ? this.selector + " " + selector : selector;
     2690                return ret;
     2691        },
     2692        filter: function( selector ) {
     2693                return this.pushStack( winnow(this, selector || [], false) );
     2694        },
     2695        not: function( selector ) {
     2696                return this.pushStack( winnow(this, selector || [], true) );
     2697        },
     2698        is: function( selector ) {
     2699                return !!winnow(
     2700                        this,
     2701
     2702                        // If this is a positional/relative selector, check membership in the returned set
     2703                        // so $("p:first").is("p:last") won't return true for a doc with two "p".
     2704                        typeof selector === "string" && rneedsContext.test( selector ) ?
     2705                                jQuery( selector ) :
     2706                                selector || [],
     2707                        false
     2708                ).length;
     2709        }
     2710});
     2711
     2712
     2713// Initialize a jQuery object
     2714
     2715
     2716// A central reference to the root jQuery(document)
     2717var rootjQuery,
     2718
     2719        // Use the correct document accordingly with window argument (sandbox)
     2720        document = window.document,
     2721
     2722        // A simple way to check for HTML strings
     2723        // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
     2724        // Strict HTML recognition (#11290: must start with <)
     2725        rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
     2726
     2727        init = jQuery.fn.init = function( selector, context ) {
     2728                var match, elem;
     2729
     2730                // HANDLE: $(""), $(null), $(undefined), $(false)
     2731                if ( !selector ) {
     2732                        return this;
     2733                }
     2734
     2735                // Handle HTML strings
     2736                if ( typeof selector === "string" ) {
     2737                        if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
     2738                                // Assume that strings that start and end with <> are HTML and skip the regex check
     2739                                match = [ null, selector, null ];
     2740
     2741                        } else {
     2742                                match = rquickExpr.exec( selector );
     2743                        }
     2744
     2745                        // Match html or make sure no context is specified for #id
     2746                        if ( match && (match[1] || !context) ) {
     2747
     2748                                // HANDLE: $(html) -> $(array)
     2749                                if ( match[1] ) {
     2750                                        context = context instanceof jQuery ? context[0] : context;
     2751
     2752                                        // scripts is true for back-compat
     2753                                        // Intentionally let the error be thrown if parseHTML is not present
     2754                                        jQuery.merge( this, jQuery.parseHTML(
     2755                                                match[1],
     2756                                                context && context.nodeType ? context.ownerDocument || context : document,
     2757                                                true
     2758                                        ) );
     2759
     2760                                        // HANDLE: $(html, props)
     2761                                        if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
     2762                                                for ( match in context ) {
     2763                                                        // Properties of context are called as methods if possible
     2764                                                        if ( jQuery.isFunction( this[ match ] ) ) {
     2765                                                                this[ match ]( context[ match ] );
     2766
     2767                                                        // ...and otherwise set as attributes
     2768                                                        } else {
     2769                                                                this.attr( match, context[ match ] );
     2770                                                        }
     2771                                                }
     2772                                        }
     2773
     2774                                        return this;
     2775
     2776                                // HANDLE: $(#id)
     2777                                } else {
     2778                                        elem = document.getElementById( match[2] );
     2779
     2780                                        // Check parentNode to catch when Blackberry 4.6 returns
     2781                                        // nodes that are no longer in the document #6963
     2782                                        if ( elem && elem.parentNode ) {
     2783                                                // Handle the case where IE and Opera return items
     2784                                                // by name instead of ID
     2785                                                if ( elem.id !== match[2] ) {
     2786                                                        return rootjQuery.find( selector );
     2787                                                }
     2788
     2789                                                // Otherwise, we inject the element directly into the jQuery object
     2790                                                this.length = 1;
     2791                                                this[0] = elem;
     2792                                        }
     2793
     2794                                        this.context = document;
     2795                                        this.selector = selector;
     2796                                        return this;
     2797                                }
     2798
     2799                        // HANDLE: $(expr, $(...))
     2800                        } else if ( !context || context.jquery ) {
     2801                                return ( context || rootjQuery ).find( selector );
     2802
     2803                        // HANDLE: $(expr, context)
     2804                        // (which is just equivalent to: $(context).find(expr)
     2805                        } else {
     2806                                return this.constructor( context ).find( selector );
     2807                        }
     2808
     2809                // HANDLE: $(DOMElement)
     2810                } else if ( selector.nodeType ) {
     2811                        this.context = this[0] = selector;
     2812                        this.length = 1;
     2813                        return this;
     2814
     2815                // HANDLE: $(function)
     2816                // Shortcut for document ready
     2817                } else if ( jQuery.isFunction( selector ) ) {
     2818                        return typeof rootjQuery.ready !== "undefined" ?
     2819                                rootjQuery.ready( selector ) :
     2820                                // Execute immediately if ready is not present
     2821                                selector( jQuery );
     2822                }
     2823
     2824                if ( selector.selector !== undefined ) {
     2825                        this.selector = selector.selector;
     2826                        this.context = selector.context;
     2827                }
     2828
     2829                return jQuery.makeArray( selector, this );
     2830        };
     2831
     2832// Give the init function the jQuery prototype for later instantiation
     2833init.prototype = jQuery.fn;
     2834
     2835// Initialize central reference
     2836rootjQuery = jQuery( document );
     2837
     2838
     2839var rparentsprev = /^(?:parents|prev(?:Until|All))/,
     2840        // methods guaranteed to produce a unique set when starting from a unique set
     2841        guaranteedUnique = {
     2842                children: true,
     2843                contents: true,
     2844                next: true,
     2845                prev: true
     2846        };
     2847
     2848jQuery.extend({
     2849        dir: function( elem, dir, until ) {
     2850                var matched = [],
     2851                        cur = elem[ dir ];
     2852
     2853                while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
     2854                        if ( cur.nodeType === 1 ) {
     2855                                matched.push( cur );
     2856                        }
     2857                        cur = cur[dir];
     2858                }
     2859                return matched;
     2860        },
     2861
     2862        sibling: function( n, elem ) {
     2863                var r = [];
     2864
     2865                for ( ; n; n = n.nextSibling ) {
     2866                        if ( n.nodeType === 1 && n !== elem ) {
     2867                                r.push( n );
     2868                        }
     2869                }
     2870
     2871                return r;
     2872        }
     2873});
     2874
     2875jQuery.fn.extend({
     2876        has: function( target ) {
     2877                var i,
     2878                        targets = jQuery( target, this ),
     2879                        len = targets.length;
     2880
     2881                return this.filter(function() {
     2882                        for ( i = 0; i < len; i++ ) {
     2883                                if ( jQuery.contains( this, targets[i] ) ) {
     2884                                        return true;
     2885                                }
     2886                        }
     2887                });
     2888        },
     2889
     2890        closest: function( selectors, context ) {
     2891                var cur,
     2892                        i = 0,
     2893                        l = this.length,
     2894                        matched = [],
     2895                        pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
     2896                                jQuery( selectors, context || this.context ) :
     2897                                0;
     2898
     2899                for ( ; i < l; i++ ) {
     2900                        for ( cur = this[i]; cur && cur !== context; cur = cur.parentNode ) {
     2901                                // Always skip document fragments
     2902                                if ( cur.nodeType < 11 && (pos ?
     2903                                        pos.index(cur) > -1 :
     2904
     2905                                        // Don't pass non-elements to Sizzle
     2906                                        cur.nodeType === 1 &&
     2907                                                jQuery.find.matchesSelector(cur, selectors)) ) {
     2908
     2909                                        matched.push( cur );
     2910                                        break;
     2911                                }
     2912                        }
     2913                }
     2914
     2915                return this.pushStack( matched.length > 1 ? jQuery.unique( matched ) : matched );
     2916        },
     2917
     2918        // Determine the position of an element within
     2919        // the matched set of elements
     2920        index: function( elem ) {
     2921
     2922                // No argument, return index in parent
     2923                if ( !elem ) {
     2924                        return ( this[0] && this[0].parentNode ) ? this.first().prevAll().length : -1;
     2925                }
     2926
     2927                // index in selector
     2928                if ( typeof elem === "string" ) {
     2929                        return jQuery.inArray( this[0], jQuery( elem ) );
     2930                }
     2931
     2932                // Locate the position of the desired element
     2933                return jQuery.inArray(
     2934                        // If it receives a jQuery object, the first element is used
     2935                        elem.jquery ? elem[0] : elem, this );
     2936        },
     2937
     2938        add: function( selector, context ) {
     2939                return this.pushStack(
     2940                        jQuery.unique(
     2941                                jQuery.merge( this.get(), jQuery( selector, context ) )
     2942                        )
     2943                );
     2944        },
     2945
     2946        addBack: function( selector ) {
     2947                return this.add( selector == null ?
     2948                        this.prevObject : this.prevObject.filter(selector)
     2949                );
     2950        }
     2951});
     2952
     2953function sibling( cur, dir ) {
     2954        do {
     2955                cur = cur[ dir ];
     2956        } while ( cur && cur.nodeType !== 1 );
     2957
     2958        return cur;
     2959}
     2960
     2961jQuery.each({
     2962        parent: function( elem ) {
     2963                var parent = elem.parentNode;
     2964                return parent && parent.nodeType !== 11 ? parent : null;
     2965        },
     2966        parents: function( elem ) {
     2967                return jQuery.dir( elem, "parentNode" );
     2968        },
     2969        parentsUntil: function( elem, i, until ) {
     2970                return jQuery.dir( elem, "parentNode", until );
     2971        },
     2972        next: function( elem ) {
     2973                return sibling( elem, "nextSibling" );
     2974        },
     2975        prev: function( elem ) {
     2976                return sibling( elem, "previousSibling" );
     2977        },
     2978        nextAll: function( elem ) {
     2979                return jQuery.dir( elem, "nextSibling" );
     2980        },
     2981        prevAll: function( elem ) {
     2982                return jQuery.dir( elem, "previousSibling" );
     2983        },
     2984        nextUntil: function( elem, i, until ) {
     2985                return jQuery.dir( elem, "nextSibling", until );
     2986        },
     2987        prevUntil: function( elem, i, until ) {
     2988                return jQuery.dir( elem, "previousSibling", until );
     2989        },
     2990        siblings: function( elem ) {
     2991                return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
     2992        },
     2993        children: function( elem ) {
     2994                return jQuery.sibling( elem.firstChild );
     2995        },
     2996        contents: function( elem ) {
     2997                return jQuery.nodeName( elem, "iframe" ) ?
     2998                        elem.contentDocument || elem.contentWindow.document :
     2999                        jQuery.merge( [], elem.childNodes );
     3000        }
     3001}, function( name, fn ) {
     3002        jQuery.fn[ name ] = function( until, selector ) {
     3003                var ret = jQuery.map( this, fn, until );
     3004
     3005                if ( name.slice( -5 ) !== "Until" ) {
     3006                        selector = until;
     3007                }
     3008
     3009                if ( selector && typeof selector === "string" ) {
     3010                        ret = jQuery.filter( selector, ret );
     3011                }
     3012
     3013                if ( this.length > 1 ) {
     3014                        // Remove duplicates
     3015                        if ( !guaranteedUnique[ name ] ) {
     3016                                ret = jQuery.unique( ret );
     3017                        }
     3018
     3019                        // Reverse order for parents* and prev-derivatives
     3020                        if ( rparentsprev.test( name ) ) {
     3021                                ret = ret.reverse();
     3022                        }
     3023                }
     3024
     3025                return this.pushStack( ret );
     3026        };
     3027});
     3028var rnotwhite = (/\S+/g);
     3029
     3030
     3031
    29813032// String to Object options format cache
    29823033var optionsCache = {};
     
    29853036function createOptions( options ) {
    29863037        var object = optionsCache[ options ] = {};
    2987         jQuery.each( options.match( core_rnotwhite ) || [], function( _, flag ) {
     3038        jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {
    29883039                object[ flag ] = true;
    29893040        });
     
    31023153                                        jQuery.each( arguments, function( _, arg ) {
    31033154                                                var index;
    3104                                                 while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
     3155                                                while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
    31053156                                                        list.splice( index, 1 );
    31063157                                                        // Handle firing indexes
     
    31763227        return self;
    31773228};
     3229
     3230
    31783231jQuery.extend({
    31793232
     
    31983251                                        return jQuery.Deferred(function( newDefer ) {
    31993252                                                jQuery.each( tuples, function( i, tuple ) {
    3200                                                         var action = tuple[ 0 ],
    3201                                                                 fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
     3253                                                        var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
    32023254                                                        // deferred[ done | fail | progress ] for forwarding actions to newDefer
    32033255                                                        deferred[ tuple[1] ](function() {
     
    32093261                                                                                .progress( newDefer.notify );
    32103262                                                                } else {
    3211                                                                         newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
     3263                                                                        newDefer[ tuple[ 0 ] + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
    32123264                                                                }
    32133265                                                        });
     
    32683320        when: function( subordinate /* , ..., subordinateN */ ) {
    32693321                var i = 0,
    3270                         resolveValues = core_slice.call( arguments ),
     3322                        resolveValues = slice.call( arguments ),
    32713323                        length = resolveValues.length,
    32723324
     
    32813333                                return function( value ) {
    32823334                                        contexts[ i ] = this;
    3283                                         values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
    3284                                         if( values === progressValues ) {
     3335                                        values[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
     3336                                        if ( values === progressValues ) {
    32853337                                                deferred.notifyWith( contexts, values );
    3286                                         } else if ( !( --remaining ) ) {
     3338
     3339                                        } else if ( !(--remaining) ) {
    32873340                                                deferred.resolveWith( contexts, values );
    32883341                                        }
     
    33173370        }
    33183371});
    3319 jQuery.support = (function( support ) {
    3320 
    3321         var all, a, input, select, fragment, opt, eventName, isSupported, i,
    3322                 div = document.createElement("div");
     3372
     3373
     3374// The deferred used on DOM ready
     3375var readyList;
     3376
     3377jQuery.fn.ready = function( fn ) {
     3378        // Add the callback
     3379        jQuery.ready.promise().done( fn );
     3380
     3381        return this;
     3382};
     3383
     3384jQuery.extend({
     3385        // Is the DOM ready to be used? Set to true once it occurs.
     3386        isReady: false,
     3387
     3388        // A counter to track how many items to wait for before
     3389        // the ready event fires. See #6781
     3390        readyWait: 1,
     3391
     3392        // Hold (or release) the ready event
     3393        holdReady: function( hold ) {
     3394                if ( hold ) {
     3395                        jQuery.readyWait++;
     3396                } else {
     3397                        jQuery.ready( true );
     3398                }
     3399        },
     3400
     3401        // Handle when the DOM is ready
     3402        ready: function( wait ) {
     3403
     3404                // Abort if there are pending holds or we're already ready
     3405                if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
     3406                        return;
     3407                }
     3408
     3409                // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
     3410                if ( !document.body ) {
     3411                        return setTimeout( jQuery.ready );
     3412                }
     3413
     3414                // Remember that the DOM is ready
     3415                jQuery.isReady = true;
     3416
     3417                // If a normal DOM Ready event fired, decrement, and wait if need be
     3418                if ( wait !== true && --jQuery.readyWait > 0 ) {
     3419                        return;
     3420                }
     3421
     3422                // If there are functions bound, to execute
     3423                readyList.resolveWith( document, [ jQuery ] );
     3424
     3425                // Trigger any bound ready events
     3426                if ( jQuery.fn.trigger ) {
     3427                        jQuery( document ).trigger("ready").off("ready");
     3428                }
     3429        }
     3430});
     3431
     3432/**
     3433 * Clean-up method for dom ready events
     3434 */
     3435function detach() {
     3436        if ( document.addEventListener ) {
     3437                document.removeEventListener( "DOMContentLoaded", completed, false );
     3438                window.removeEventListener( "load", completed, false );
     3439
     3440        } else {
     3441                document.detachEvent( "onreadystatechange", completed );
     3442                window.detachEvent( "onload", completed );
     3443        }
     3444}
     3445
     3446/**
     3447 * The ready event handler and self cleanup method
     3448 */
     3449function completed() {
     3450        // readyState === "complete" is good enough for us to call the dom ready in oldIE
     3451        if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) {
     3452                detach();
     3453                jQuery.ready();
     3454        }
     3455}
     3456
     3457jQuery.ready.promise = function( obj ) {
     3458        if ( !readyList ) {
     3459
     3460                readyList = jQuery.Deferred();
     3461
     3462                // Catch cases where $(document).ready() is called after the browser event has already occurred.
     3463                // we once tried to use readyState "interactive" here, but it caused issues like the one
     3464                // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
     3465                if ( document.readyState === "complete" ) {
     3466                        // Handle it asynchronously to allow scripts the opportunity to delay ready
     3467                        setTimeout( jQuery.ready );
     3468
     3469                // Standards-based browsers support DOMContentLoaded
     3470                } else if ( document.addEventListener ) {
     3471                        // Use the handy event callback
     3472                        document.addEventListener( "DOMContentLoaded", completed, false );
     3473
     3474                        // A fallback to window.onload, that will always work
     3475                        window.addEventListener( "load", completed, false );
     3476
     3477                // If IE event model is used
     3478                } else {
     3479                        // Ensure firing before onload, maybe late but safe also for iframes
     3480                        document.attachEvent( "onreadystatechange", completed );
     3481
     3482                        // A fallback to window.onload, that will always work
     3483                        window.attachEvent( "onload", completed );
     3484
     3485                        // If IE and not a frame
     3486                        // continually check to see if the document is ready
     3487                        var top = false;
     3488
     3489                        try {
     3490                                top = window.frameElement == null && document.documentElement;
     3491                        } catch(e) {}
     3492
     3493                        if ( top && top.doScroll ) {
     3494                                (function doScrollCheck() {
     3495                                        if ( !jQuery.isReady ) {
     3496
     3497                                                try {
     3498                                                        // Use the trick by Diego Perini
     3499                                                        // http://javascript.nwbox.com/IEContentLoaded/
     3500                                                        top.doScroll("left");
     3501                                                } catch(e) {
     3502                                                        return setTimeout( doScrollCheck, 50 );
     3503                                                }
     3504
     3505                                                // detach all dom ready events
     3506                                                detach();
     3507
     3508                                                // and execute any waiting functions
     3509                                                jQuery.ready();
     3510                                        }
     3511                                })();
     3512                        }
     3513                }
     3514        }
     3515        return readyList.promise( obj );
     3516};
     3517
     3518
     3519var strundefined = typeof undefined;
     3520
     3521
     3522
     3523// Support: IE<9
     3524// Iteration over object's inherited properties before its own
     3525var i;
     3526for ( i in jQuery( support ) ) {
     3527        break;
     3528}
     3529support.ownLast = i !== "0";
     3530
     3531// Note: most support tests are defined in their respective modules.
     3532// false until the test is run
     3533support.inlineBlockNeedsLayout = false;
     3534
     3535jQuery(function() {
     3536        // We need to execute this one support test ASAP because we need to know
     3537        // if body.style.zoom needs to be set.
     3538
     3539        var container, div,
     3540                body = document.getElementsByTagName("body")[0];
     3541
     3542        if ( !body ) {
     3543                // Return for frameset docs that don't have a body
     3544                return;
     3545        }
    33233546
    33243547        // Setup
    3325         div.setAttribute( "className", "t" );
    3326         div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
    3327 
    3328         // Finish early in limited (non-browser) environments
    3329         all = div.getElementsByTagName("*") || [];
    3330         a = div.getElementsByTagName("a")[ 0 ];
    3331         if ( !a || !a.style || !all.length ) {
    3332                 return support;
    3333         }
    3334 
    3335         // First batch of tests
    3336         select = document.createElement("select");
    3337         opt = select.appendChild( document.createElement("option") );
    3338         input = div.getElementsByTagName("input")[ 0 ];
    3339 
    3340         a.style.cssText = "top:1px;float:left;opacity:.5";
    3341 
    3342         // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
    3343         support.getSetAttribute = div.className !== "t";
    3344 
    3345         // IE strips leading whitespace when .innerHTML is used
    3346         support.leadingWhitespace = div.firstChild.nodeType === 3;
    3347 
    3348         // Make sure that tbody elements aren't automatically inserted
    3349         // IE will insert them into empty tables
    3350         support.tbody = !div.getElementsByTagName("tbody").length;
    3351 
    3352         // Make sure that link elements get serialized correctly by innerHTML
    3353         // This requires a wrapper element in IE
    3354         support.htmlSerialize = !!div.getElementsByTagName("link").length;
    3355 
    3356         // Get the style information from getAttribute
    3357         // (IE uses .cssText instead)
    3358         support.style = /top/.test( a.getAttribute("style") );
    3359 
    3360         // Make sure that URLs aren't manipulated
    3361         // (IE normalizes it by default)
    3362         support.hrefNormalized = a.getAttribute("href") === "/a";
    3363 
    3364         // Make sure that element opacity exists
    3365         // (IE uses filter instead)
    3366         // Use a regex to work around a WebKit issue. See #5145
    3367         support.opacity = /^0.5/.test( a.style.opacity );
    3368 
    3369         // Verify style float existence
    3370         // (IE uses styleFloat instead of cssFloat)
    3371         support.cssFloat = !!a.style.cssFloat;
    3372 
    3373         // Check the default checkbox/radio value ("" on WebKit; "on" elsewhere)
    3374         support.checkOn = !!input.value;
    3375 
    3376         // Make sure that a selected-by-default option has a working selected property.
    3377         // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
    3378         support.optSelected = opt.selected;
    3379 
    3380         // Tests for enctype support on a form (#6743)
    3381         support.enctype = !!document.createElement("form").enctype;
    3382 
    3383         // Makes sure cloning an html5 element does not cause problems
    3384         // Where outerHTML is undefined, this still works
    3385         support.html5Clone = document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>";
    3386 
    3387         // Will be defined later
    3388         support.inlineBlockNeedsLayout = false;
    3389         support.shrinkWrapBlocks = false;
    3390         support.pixelPosition = false;
    3391         support.deleteExpando = true;
    3392         support.noCloneEvent = true;
    3393         support.reliableMarginRight = true;
    3394         support.boxSizingReliable = true;
    3395 
    3396         // Make sure checked status is properly cloned
    3397         input.checked = true;
    3398         support.noCloneChecked = input.cloneNode( true ).checked;
    3399 
    3400         // Make sure that the options inside disabled selects aren't marked as disabled
    3401         // (WebKit marks them as disabled)
    3402         select.disabled = true;
    3403         support.optDisabled = !opt.disabled;
    3404 
    3405         // Support: IE<9
    3406         try {
    3407                 delete div.test;
    3408         } catch( e ) {
    3409                 support.deleteExpando = false;
    3410         }
    3411 
    3412         // Check if we can trust getAttribute("value")
    3413         input = document.createElement("input");
    3414         input.setAttribute( "value", "" );
    3415         support.input = input.getAttribute( "value" ) === "";
    3416 
    3417         // Check if an input maintains its value after becoming a radio
    3418         input.value = "t";
    3419         input.setAttribute( "type", "radio" );
    3420         support.radioValue = input.value === "t";
    3421 
    3422         // #11217 - WebKit loses check when the name is after the checked attribute
    3423         input.setAttribute( "checked", "t" );
    3424         input.setAttribute( "name", "t" );
    3425 
    3426         fragment = document.createDocumentFragment();
    3427         fragment.appendChild( input );
    3428 
    3429         // Check if a disconnected checkbox will retain its checked
    3430         // value of true after appended to the DOM (IE6/7)
    3431         support.appendChecked = input.checked;
    3432 
    3433         // WebKit doesn't clone checked state correctly in fragments
    3434         support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
    3435 
    3436         // Support: IE<9
    3437         // Opera does not clone events (and typeof div.attachEvent === undefined).
    3438         // IE9-10 clones events bound via attachEvent, but they don't trigger with .click()
    3439         if ( div.attachEvent ) {
    3440                 div.attachEvent( "onclick", function() {
    3441                         support.noCloneEvent = false;
    3442                 });
    3443 
    3444                 div.cloneNode( true ).click();
    3445         }
    3446 
    3447         // Support: IE<9 (lack submit/change bubble), Firefox 17+ (lack focusin event)
    3448         // Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP)
    3449         for ( i in { submit: true, change: true, focusin: true }) {
    3450                 div.setAttribute( eventName = "on" + i, "t" );
    3451 
    3452                 support[ i + "Bubbles" ] = eventName in window || div.attributes[ eventName ].expando === false;
    3453         }
    3454 
    3455         div.style.backgroundClip = "content-box";
    3456         div.cloneNode( true ).style.backgroundClip = "";
    3457         support.clearCloneStyle = div.style.backgroundClip === "content-box";
    3458 
    3459         // Support: IE<9
    3460         // Iteration over object's inherited properties before its own.
    3461         for ( i in jQuery( support ) ) {
    3462                 break;
    3463         }
    3464         support.ownLast = i !== "0";
    3465 
    3466         // Run tests that need a body at doc ready
    3467         jQuery(function() {
    3468                 var container, marginDiv, tds,
    3469                         divReset = "padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;",
    3470                         body = document.getElementsByTagName("body")[0];
    3471 
    3472                 if ( !body ) {
    3473                         // Return for frameset docs that don't have a body
    3474                         return;
    3475                 }
    3476 
    3477                 container = document.createElement("div");
    3478                 container.style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px";
    3479 
    3480                 body.appendChild( container ).appendChild( div );
    3481 
    3482                 // Support: IE8
    3483                 // Check if table cells still have offsetWidth/Height when they are set
    3484                 // to display:none and there are still other visible table cells in a
    3485                 // table row; if so, offsetWidth/Height are not reliable for use when
    3486                 // determining if an element has been hidden directly using
    3487                 // display:none (it is still safe to use offsets if a parent element is
    3488                 // hidden; don safety goggles and see bug #4512 for more information).
    3489                 div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
    3490                 tds = div.getElementsByTagName("td");
    3491                 tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none";
    3492                 isSupported = ( tds[ 0 ].offsetHeight === 0 );
    3493 
    3494                 tds[ 0 ].style.display = "";
    3495                 tds[ 1 ].style.display = "none";
    3496 
    3497                 // Support: IE8
    3498                 // Check if empty table cells still have offsetWidth/Height
    3499                 support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
    3500 
    3501                 // Check box-sizing and margin behavior.
    3502                 div.innerHTML = "";
    3503                 div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";
    3504 
    3505                 // Workaround failing boxSizing test due to offsetWidth returning wrong value
    3506                 // with some non-1 values of body zoom, ticket #13543
    3507                 jQuery.swap( body, body.style.zoom != null ? { zoom: 1 } : {}, function() {
    3508                         support.boxSizing = div.offsetWidth === 4;
    3509                 });
    3510 
    3511                 // Use window.getComputedStyle because jsdom on node.js will break without it.
    3512                 if ( window.getComputedStyle ) {
    3513                         support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
    3514                         support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
    3515 
    3516                         // Check if div with explicit width and no margin-right incorrectly
    3517                         // gets computed margin-right based on width of container. (#3333)
    3518                         // Fails in WebKit before Feb 2011 nightlies
    3519                         // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
    3520                         marginDiv = div.appendChild( document.createElement("div") );
    3521                         marginDiv.style.cssText = div.style.cssText = divReset;
    3522                         marginDiv.style.marginRight = marginDiv.style.width = "0";
    3523                         div.style.width = "1px";
    3524 
    3525                         support.reliableMarginRight =
    3526                                 !parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight );
    3527                 }
    3528 
    3529                 if ( typeof div.style.zoom !== core_strundefined ) {
     3548        container = document.createElement( "div" );
     3549        container.style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px";
     3550
     3551        div = document.createElement( "div" );
     3552        body.appendChild( container ).appendChild( div );
     3553
     3554        if ( typeof div.style.zoom !== strundefined ) {
     3555                // Support: IE<8
     3556                // Check if natively block-level elements act like inline-block
     3557                // elements when setting their display to 'inline' and giving
     3558                // them layout
     3559                div.style.cssText = "border:0;margin:0;width:1px;padding:1px;display:inline;zoom:1";
     3560
     3561                if ( (support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 )) ) {
     3562                        // Prevent IE 6 from affecting layout for positioned elements #11048
     3563                        // Prevent IE from shrinking the body in IE 7 mode #12869
    35303564                        // Support: IE<8
    3531                         // Check if natively block-level elements act like inline-block
    3532                         // elements when setting their display to 'inline' and giving
    3533                         // them layout
    3534                         div.innerHTML = "";
    3535                         div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
    3536                         support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
    3537 
    3538                         // Support: IE6
    3539                         // Check if elements with layout shrink-wrap their children
    3540                         div.style.display = "block";
    3541                         div.innerHTML = "<div></div>";
    3542                         div.firstChild.style.width = "5px";
    3543                         support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
    3544 
    3545                         if ( support.inlineBlockNeedsLayout ) {
    3546                                 // Prevent IE 6 from affecting layout for positioned elements #11048
    3547                                 // Prevent IE from shrinking the body in IE 7 mode #12869
    3548                                 // Support: IE<8
    3549                                 body.style.zoom = 1;
    3550                         }
    3551                 }
    3552 
    3553                 body.removeChild( container );
    3554 
    3555                 // Null elements to avoid leaks in IE
    3556                 container = div = tds = marginDiv = null;
    3557         });
     3565                        body.style.zoom = 1;
     3566                }
     3567        }
     3568
     3569        body.removeChild( container );
    35583570
    35593571        // Null elements to avoid leaks in IE
    3560         all = select = fragment = opt = a = input = null;
    3561 
    3562         return support;
    3563 })({});
    3564 
    3565 var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
     3572        container = div = null;
     3573});
     3574
     3575
     3576
     3577
     3578(function() {
     3579        var div = document.createElement( "div" );
     3580
     3581        // Execute the test only if not already executed in another module.
     3582        if (support.deleteExpando == null) {
     3583                // Support: IE<9
     3584                support.deleteExpando = true;
     3585                try {
     3586                        delete div.test;
     3587                } catch( e ) {
     3588                        support.deleteExpando = false;
     3589                }
     3590        }
     3591
     3592        // Null elements to avoid leaks in IE.
     3593        div = null;
     3594})();
     3595
     3596
     3597/**
     3598 * Determines whether an object can have data
     3599 */
     3600jQuery.acceptData = function( elem ) {
     3601        var noData = jQuery.noData[ (elem.nodeName + " ").toLowerCase() ],
     3602                nodeType = +elem.nodeType || 1;
     3603
     3604        // Do not set data on non-element DOM nodes because it will not be cleared (#8335).
     3605        return nodeType !== 1 && nodeType !== 9 ?
     3606                false :
     3607
     3608                // Nodes accept data unless otherwise specified; rejection can be conditional
     3609                !noData || noData !== true && elem.getAttribute("classid") === noData;
     3610};
     3611
     3612
     3613var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
    35663614        rmultiDash = /([A-Z])/g;
    35673615
    3568 function internalData( elem, name, data, pvt /* Internal Use Only */ ){
     3616function dataAttr( elem, key, data ) {
     3617        // If nothing was found internally, try to fetch any
     3618        // data from the HTML5 data-* attribute
     3619        if ( data === undefined && elem.nodeType === 1 ) {
     3620
     3621                var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
     3622
     3623                data = elem.getAttribute( name );
     3624
     3625                if ( typeof data === "string" ) {
     3626                        try {
     3627                                data = data === "true" ? true :
     3628                                        data === "false" ? false :
     3629                                        data === "null" ? null :
     3630                                        // Only convert to a number if it doesn't change the string
     3631                                        +data + "" === data ? +data :
     3632                                        rbrace.test( data ) ? jQuery.parseJSON( data ) :
     3633                                        data;
     3634                        } catch( e ) {}
     3635
     3636                        // Make sure we set the data so it isn't changed later
     3637                        jQuery.data( elem, key, data );
     3638
     3639                } else {
     3640                        data = undefined;
     3641                }
     3642        }
     3643
     3644        return data;
     3645}
     3646
     3647// checks a cache object for emptiness
     3648function isEmptyDataObject( obj ) {
     3649        var name;
     3650        for ( name in obj ) {
     3651
     3652                // if the public data object is empty, the private is still empty
     3653                if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
     3654                        continue;
     3655                }
     3656                if ( name !== "toJSON" ) {
     3657                        return false;
     3658                }
     3659        }
     3660
     3661        return true;
     3662}
     3663
     3664function internalData( elem, name, data, pvt /* Internal Use Only */ ) {
    35693665        if ( !jQuery.acceptData( elem ) ) {
    35703666                return;
     
    35963692                // ends up in the global cache
    35973693                if ( isNode ) {
    3598                         id = elem[ internalKey ] = core_deletedIds.pop() || jQuery.guid++;
     3694                        id = elem[ internalKey ] = deletedIds.pop() || jQuery.guid++;
    35993695                } else {
    36003696                        id = internalKey;
     
    37353831        // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
    37363832        /* jshint eqeqeq: false */
    3737         } else if ( jQuery.support.deleteExpando || cache != cache.window ) {
     3833        } else if ( support.deleteExpando || cache != cache.window ) {
    37383834                /* jshint eqeqeq: true */
    37393835                delete cache[ id ];
     
    37483844        cache: {},
    37493845
    3750         // The following elements throw uncatchable exceptions if you
    3751         // attempt to add expando properties to them.
     3846        // The following elements (space-suffixed to avoid Object.prototype collisions)
     3847        // throw uncatchable exceptions if you attempt to set expando properties
    37523848        noData: {
    3753                 "applet": true,
    3754                 "embed": true,
    3755                 // Ban all objects except for Flash (which handle expandos)
    3756                 "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"
     3849                "applet ": true,
     3850                "embed ": true,
     3851                // ...but Flash objects (which have this classid) *can* handle expandos
     3852                "object ": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"
    37573853        },
    37583854
     
    37773873        _removeData: function( elem, name ) {
    37783874                return internalRemoveData( elem, name, true );
    3779         },
    3780 
    3781         // A method for determining if a DOM node can handle the data expando
    3782         acceptData: function( elem ) {
    3783                 // Do not set data on non-element because it will not be cleared (#8335).
    3784                 if ( elem.nodeType && elem.nodeType !== 1 && elem.nodeType !== 9 ) {
    3785                         return false;
    3786                 }
    3787 
    3788                 var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ];
    3789 
    3790                 // nodes accept data unless otherwise specified; rejection can be conditional
    3791                 return !noData || noData !== true && elem.getAttribute("classid") === noData;
    37923875        }
    37933876});
     
    37953878jQuery.fn.extend({
    37963879        data: function( key, value ) {
    3797                 var attrs, name,
    3798                         data = null,
    3799                         i = 0,
    3800                         elem = this[0];
     3880                var i, name, data,
     3881                        elem = this[0],
     3882                        attrs = elem && elem.attributes;
    38013883
    38023884                // Special expections of .data basically thwart jQuery.access,
     
    38093891
    38103892                                if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
    3811                                         attrs = elem.attributes;
    3812                                         for ( ; i < attrs.length; i++ ) {
     3893                                        i = attrs.length;
     3894                                        while ( i-- ) {
    38133895                                                name = attrs[i].name;
    38143896
     
    38423924                        // Gets one value
    38433925                        // Try to fetch any internally stored data first
    3844                         elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : null;
     3926                        elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : undefined;
    38453927        },
    38463928
     
    38523934});
    38533935
    3854 function dataAttr( elem, key, data ) {
    3855         // If nothing was found internally, try to fetch any
    3856         // data from the HTML5 data-* attribute
    3857         if ( data === undefined && elem.nodeType === 1 ) {
    3858 
    3859                 var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
    3860 
    3861                 data = elem.getAttribute( name );
    3862 
    3863                 if ( typeof data === "string" ) {
    3864                         try {
    3865                                 data = data === "true" ? true :
    3866                                         data === "false" ? false :
    3867                                         data === "null" ? null :
    3868                                         // Only convert to a number if it doesn't change the string
    3869                                         +data + "" === data ? +data :
    3870                                         rbrace.test( data ) ? jQuery.parseJSON( data ) :
    3871                                                 data;
    3872                         } catch( e ) {}
    3873 
    3874                         // Make sure we set the data so it isn't changed later
    3875                         jQuery.data( elem, key, data );
    3876 
    3877                 } else {
    3878                         data = undefined;
    3879                 }
    3880         }
    3881 
    3882         return data;
    3883 }
    3884 
    3885 // checks a cache object for emptiness
    3886 function isEmptyDataObject( obj ) {
    3887         var name;
    3888         for ( name in obj ) {
    3889 
    3890                 // if the public data object is empty, the private is still empty
    3891                 if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
    3892                         continue;
    3893                 }
    3894                 if ( name !== "toJSON" ) {
    3895                         return false;
    3896                 }
    3897         }
    3898 
    3899         return true;
    3900 }
     3936
    39013937jQuery.extend({
    39023938        queue: function( elem, type, data ) {
     
    39964032                return this.each(function() {
    39974033                        jQuery.dequeue( this, type );
    3998                 });
    3999         },
    4000         // Based off of the plugin by Clint Helfers, with permission.
    4001         // http://blindsignals.com/index.php/2009/07/jquery-delay/
    4002         delay: function( time, type ) {
    4003                 time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
    4004                 type = type || "fx";
    4005 
    4006                 return this.queue( type, function( next, hooks ) {
    4007                         var timeout = setTimeout( next, time );
    4008                         hooks.stop = function() {
    4009                                 clearTimeout( timeout );
    4010                         };
    40114034                });
    40124035        },
     
    40344057                type = type || "fx";
    40354058
    4036                 while( i-- ) {
     4059                while ( i-- ) {
    40374060                        tmp = jQuery._data( elements[ i ], type + "queueHooks" );
    40384061                        if ( tmp && tmp.empty ) {
     
    40454068        }
    40464069});
    4047 var nodeHook, boolHook,
    4048         rclass = /[\t\r\n\f]/g,
    4049         rreturn = /\r/g,
    4050         rfocusable = /^(?:input|select|textarea|button|object)$/i,
    4051         rclickable = /^(?:a|area)$/i,
    4052         ruseDefault = /^(?:checked|selected)$/i,
    4053         getSetAttribute = jQuery.support.getSetAttribute,
    4054         getSetInput = jQuery.support.input;
    4055 
    4056 jQuery.fn.extend({
    4057         attr: function( name, value ) {
    4058                 return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
    4059         },
    4060 
    4061         removeAttr: function( name ) {
    4062                 return this.each(function() {
    4063                         jQuery.removeAttr( this, name );
     4070var pnum = (/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/).source;
     4071
     4072var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
     4073
     4074var isHidden = function( elem, el ) {
     4075                // isHidden might be called from jQuery#filter function;
     4076                // in that case, element will be second argument
     4077                elem = el || elem;
     4078                return jQuery.css( elem, "display" ) === "none" || !jQuery.contains( elem.ownerDocument, elem );
     4079        };
     4080
     4081
     4082
     4083// Multifunctional method to get and set values of a collection
     4084// The value/s can optionally be executed if it's a function
     4085var access = jQuery.access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
     4086        var i = 0,
     4087                length = elems.length,
     4088                bulk = key == null;
     4089
     4090        // Sets many values
     4091        if ( jQuery.type( key ) === "object" ) {
     4092                chainable = true;
     4093                for ( i in key ) {
     4094                        jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );
     4095                }
     4096
     4097        // Sets one value
     4098        } else if ( value !== undefined ) {
     4099                chainable = true;
     4100
     4101                if ( !jQuery.isFunction( value ) ) {
     4102                        raw = true;
     4103                }
     4104
     4105                if ( bulk ) {
     4106                        // Bulk operations run against the entire set
     4107                        if ( raw ) {
     4108                                fn.call( elems, value );
     4109                                fn = null;
     4110
     4111                        // ...except when executing function values
     4112                        } else {
     4113                                bulk = fn;
     4114                                fn = function( elem, key, value ) {
     4115                                        return bulk.call( jQuery( elem ), value );
     4116                                };
     4117                        }
     4118                }
     4119
     4120                if ( fn ) {
     4121                        for ( ; i < length; i++ ) {
     4122                                fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );
     4123                        }
     4124                }
     4125        }
     4126
     4127        return chainable ?
     4128                elems :
     4129
     4130                // Gets
     4131                bulk ?
     4132                        fn.call( elems ) :
     4133                        length ? fn( elems[0], key ) : emptyGet;
     4134};
     4135var rcheckableType = (/^(?:checkbox|radio)$/i);
     4136
     4137
     4138
     4139(function() {
     4140        var fragment = document.createDocumentFragment(),
     4141                div = document.createElement("div"),
     4142                input = document.createElement("input");
     4143
     4144        // Setup
     4145        div.setAttribute( "className", "t" );
     4146        div.innerHTML = "  <link/><table></table><a href='/a'>a</a>";
     4147
     4148        // IE strips leading whitespace when .innerHTML is used
     4149        support.leadingWhitespace = div.firstChild.nodeType === 3;
     4150
     4151        // Make sure that tbody elements aren't automatically inserted
     4152        // IE will insert them into empty tables
     4153        support.tbody = !div.getElementsByTagName( "tbody" ).length;
     4154
     4155        // Make sure that link elements get serialized correctly by innerHTML
     4156        // This requires a wrapper element in IE
     4157        support.htmlSerialize = !!div.getElementsByTagName( "link" ).length;
     4158
     4159        // Makes sure cloning an html5 element does not cause problems
     4160        // Where outerHTML is undefined, this still works
     4161        support.html5Clone =
     4162                document.createElement( "nav" ).cloneNode( true ).outerHTML !== "<:nav></:nav>";
     4163
     4164        // Check if a disconnected checkbox will retain its checked
     4165        // value of true after appended to the DOM (IE6/7)
     4166        input.type = "checkbox";
     4167        input.checked = true;
     4168        fragment.appendChild( input );
     4169        support.appendChecked = input.checked;
     4170
     4171        // Make sure textarea (and checkbox) defaultValue is properly cloned
     4172        // Support: IE6-IE11+
     4173        div.innerHTML = "<textarea>x</textarea>";
     4174        support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
     4175
     4176        // #11217 - WebKit loses check when the name is after the checked attribute
     4177        fragment.appendChild( div );
     4178        div.innerHTML = "<input type='radio' checked='checked' name='t'/>";
     4179
     4180        // Support: Safari 5.1, iOS 5.1, Android 4.x, Android 2.3
     4181        // old WebKit doesn't clone checked state correctly in fragments
     4182        support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
     4183
     4184        // Support: IE<9
     4185        // Opera does not clone events (and typeof div.attachEvent === undefined).
     4186        // IE9-10 clones events bound via attachEvent, but they don't trigger with .click()
     4187        support.noCloneEvent = true;
     4188        if ( div.attachEvent ) {
     4189                div.attachEvent( "onclick", function() {
     4190                        support.noCloneEvent = false;
    40644191                });
    4065         },
    4066 
    4067         prop: function( name, value ) {
    4068                 return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
    4069         },
    4070 
    4071         removeProp: function( name ) {
    4072                 name = jQuery.propFix[ name ] || name;
    4073                 return this.each(function() {
    4074                         // try/catch handles cases where IE balks (such as removing a property on window)
    4075                         try {
    4076                                 this[ name ] = undefined;
    4077                                 delete this[ name ];
    4078                         } catch( e ) {}
    4079                 });
    4080         },
    4081 
    4082         addClass: function( value ) {
    4083                 var classes, elem, cur, clazz, j,
    4084                         i = 0,
    4085                         len = this.length,
    4086                         proceed = typeof value === "string" && value;
    4087 
    4088                 if ( jQuery.isFunction( value ) ) {
    4089                         return this.each(function( j ) {
    4090                                 jQuery( this ).addClass( value.call( this, j, this.className ) );
    4091                         });
    4092                 }
    4093 
    4094                 if ( proceed ) {
    4095                         // The disjunction here is for better compressibility (see removeClass)
    4096                         classes = ( value || "" ).match( core_rnotwhite ) || [];
    4097 
    4098                         for ( ; i < len; i++ ) {
    4099                                 elem = this[ i ];
    4100                                 cur = elem.nodeType === 1 && ( elem.className ?
    4101                                         ( " " + elem.className + " " ).replace( rclass, " " ) :
    4102                                         " "
    4103                                 );
    4104 
    4105                                 if ( cur ) {
    4106                                         j = 0;
    4107                                         while ( (clazz = classes[j++]) ) {
    4108                                                 if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
    4109                                                         cur += clazz + " ";
    4110                                                 }
    4111                                         }
    4112                                         elem.className = jQuery.trim( cur );
    4113 
    4114                                 }
    4115                         }
    4116                 }
    4117 
    4118                 return this;
    4119         },
    4120 
    4121         removeClass: function( value ) {
    4122                 var classes, elem, cur, clazz, j,
    4123                         i = 0,
    4124                         len = this.length,
    4125                         proceed = arguments.length === 0 || typeof value === "string" && value;
    4126 
    4127                 if ( jQuery.isFunction( value ) ) {
    4128                         return this.each(function( j ) {
    4129                                 jQuery( this ).removeClass( value.call( this, j, this.className ) );
    4130                         });
    4131                 }
    4132                 if ( proceed ) {
    4133                         classes = ( value || "" ).match( core_rnotwhite ) || [];
    4134 
    4135                         for ( ; i < len; i++ ) {
    4136                                 elem = this[ i ];
    4137                                 // This expression is here for better compressibility (see addClass)
    4138                                 cur = elem.nodeType === 1 && ( elem.className ?
    4139                                         ( " " + elem.className + " " ).replace( rclass, " " ) :
    4140                                         ""
    4141                                 );
    4142 
    4143                                 if ( cur ) {
    4144                                         j = 0;
    4145                                         while ( (clazz = classes[j++]) ) {
    4146                                                 // Remove *all* instances
    4147                                                 while ( cur.indexOf( " " + clazz + " " ) >= 0 ) {
    4148                                                         cur = cur.replace( " " + clazz + " ", " " );
    4149                                                 }
    4150                                         }
    4151                                         elem.className = value ? jQuery.trim( cur ) : "";
    4152                                 }
    4153                         }
    4154                 }
    4155 
    4156                 return this;
    4157         },
    4158 
    4159         toggleClass: function( value, stateVal ) {
    4160                 var type = typeof value;
    4161 
    4162                 if ( typeof stateVal === "boolean" && type === "string" ) {
    4163                         return stateVal ? this.addClass( value ) : this.removeClass( value );
    4164                 }
    4165 
    4166                 if ( jQuery.isFunction( value ) ) {
    4167                         return this.each(function( i ) {
    4168                                 jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
    4169                         });
    4170                 }
    4171 
    4172                 return this.each(function() {
    4173                         if ( type === "string" ) {
    4174                                 // toggle individual class names
    4175                                 var className,
    4176                                         i = 0,
    4177                                         self = jQuery( this ),
    4178                                         classNames = value.match( core_rnotwhite ) || [];
    4179 
    4180                                 while ( (className = classNames[ i++ ]) ) {
    4181                                         // check each className given, space separated list
    4182                                         if ( self.hasClass( className ) ) {
    4183                                                 self.removeClass( className );
    4184                                         } else {
    4185                                                 self.addClass( className );
    4186                                         }
    4187                                 }
    4188 
    4189                         // Toggle whole class name
    4190                         } else if ( type === core_strundefined || type === "boolean" ) {
    4191                                 if ( this.className ) {
    4192                                         // store className if set
    4193                                         jQuery._data( this, "__className__", this.className );
    4194                                 }
    4195 
    4196                                 // If the element has a class name or if we're passed "false",
    4197                                 // then remove the whole classname (if there was one, the above saved it).
    4198                                 // Otherwise bring back whatever was previously saved (if anything),
    4199                                 // falling back to the empty string if nothing was stored.
    4200                                 this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
    4201                         }
    4202                 });
    4203         },
    4204 
    4205         hasClass: function( selector ) {
    4206                 var className = " " + selector + " ",
    4207                         i = 0,
    4208                         l = this.length;
    4209                 for ( ; i < l; i++ ) {
    4210                         if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {
    4211                                 return true;
    4212                         }
    4213                 }
    4214 
    4215                 return false;
    4216         },
    4217 
    4218         val: function( value ) {
    4219                 var ret, hooks, isFunction,
    4220                         elem = this[0];
    4221 
    4222                 if ( !arguments.length ) {
    4223                         if ( elem ) {
    4224                                 hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
    4225 
    4226                                 if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
    4227                                         return ret;
    4228                                 }
    4229 
    4230                                 ret = elem.value;
    4231 
    4232                                 return typeof ret === "string" ?
    4233                                         // handle most common string cases
    4234                                         ret.replace(rreturn, "") :
    4235                                         // handle cases where value is null/undef or number
    4236                                         ret == null ? "" : ret;
    4237                         }
    4238 
    4239                         return;
    4240                 }
    4241 
    4242                 isFunction = jQuery.isFunction( value );
    4243 
    4244                 return this.each(function( i ) {
    4245                         var val;
    4246 
    4247                         if ( this.nodeType !== 1 ) {
    4248                                 return;
    4249                         }
    4250 
    4251                         if ( isFunction ) {
    4252                                 val = value.call( this, i, jQuery( this ).val() );
    4253                         } else {
    4254                                 val = value;
    4255                         }
    4256 
    4257                         // Treat null/undefined as ""; convert numbers to string
    4258                         if ( val == null ) {
    4259                                 val = "";
    4260                         } else if ( typeof val === "number" ) {
    4261                                 val += "";
    4262                         } else if ( jQuery.isArray( val ) ) {
    4263                                 val = jQuery.map(val, function ( value ) {
    4264                                         return value == null ? "" : value + "";
    4265                                 });
    4266                         }
    4267 
    4268                         hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
    4269 
    4270                         // If set returns undefined, fall back to normal setting
    4271                         if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
    4272                                 this.value = val;
    4273                         }
    4274                 });
    4275         }
    4276 });
    4277 
    4278 jQuery.extend({
    4279         valHooks: {
    4280                 option: {
    4281                         get: function( elem ) {
    4282                                 // Use proper attribute retrieval(#6932, #12072)
    4283                                 var val = jQuery.find.attr( elem, "value" );
    4284                                 return val != null ?
    4285                                         val :
    4286                                         elem.text;
    4287                         }
    4288                 },
    4289                 select: {
    4290                         get: function( elem ) {
    4291                                 var value, option,
    4292                                         options = elem.options,
    4293                                         index = elem.selectedIndex,
    4294                                         one = elem.type === "select-one" || index < 0,
    4295                                         values = one ? null : [],
    4296                                         max = one ? index + 1 : options.length,
    4297                                         i = index < 0 ?
    4298                                                 max :
    4299                                                 one ? index : 0;
    4300 
    4301                                 // Loop through all the selected options
    4302                                 for ( ; i < max; i++ ) {
    4303                                         option = options[ i ];
    4304 
    4305                                         // oldIE doesn't update selected after form reset (#2551)
    4306                                         if ( ( option.selected || i === index ) &&
    4307                                                         // Don't return options that are disabled or in a disabled optgroup
    4308                                                         ( jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null ) &&
    4309                                                         ( !option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {
    4310 
    4311                                                 // Get the specific value for the option
    4312                                                 value = jQuery( option ).val();
    4313 
    4314                                                 // We don't need an array for one selects
    4315                                                 if ( one ) {
    4316                                                         return value;
    4317                                                 }
    4318 
    4319                                                 // Multi-Selects return an array
    4320                                                 values.push( value );
    4321                                         }
    4322                                 }
    4323 
    4324                                 return values;
    4325                         },
    4326 
    4327                         set: function( elem, value ) {
    4328                                 var optionSet, option,
    4329                                         options = elem.options,
    4330                                         values = jQuery.makeArray( value ),
    4331                                         i = options.length;
    4332 
    4333                                 while ( i-- ) {
    4334                                         option = options[ i ];
    4335                                         if ( (option.selected = jQuery.inArray( jQuery(option).val(), values ) >= 0) ) {
    4336                                                 optionSet = true;
    4337                                         }
    4338                                 }
    4339 
    4340                                 // force browsers to behave consistently when non-matching value is set
    4341                                 if ( !optionSet ) {
    4342                                         elem.selectedIndex = -1;
    4343                                 }
    4344                                 return values;
    4345                         }
    4346                 }
    4347         },
    4348 
    4349         attr: function( elem, name, value ) {
    4350                 var hooks, ret,
    4351                         nType = elem.nodeType;
    4352 
    4353                 // don't get/set attributes on text, comment and attribute nodes
    4354                 if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
    4355                         return;
    4356                 }
    4357 
    4358                 // Fallback to prop when attributes are not supported
    4359                 if ( typeof elem.getAttribute === core_strundefined ) {
    4360                         return jQuery.prop( elem, name, value );
    4361                 }
    4362 
    4363                 // All attributes are lowercase
    4364                 // Grab necessary hook if one is defined
    4365                 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
    4366                         name = name.toLowerCase();
    4367                         hooks = jQuery.attrHooks[ name ] ||
    4368                                 ( jQuery.expr.match.bool.test( name ) ? boolHook : nodeHook );
    4369                 }
    4370 
    4371                 if ( value !== undefined ) {
    4372 
    4373                         if ( value === null ) {
    4374                                 jQuery.removeAttr( elem, name );
    4375 
    4376                         } else if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
    4377                                 return ret;
    4378 
    4379                         } else {
    4380                                 elem.setAttribute( name, value + "" );
    4381                                 return value;
    4382                         }
    4383 
    4384                 } else if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
    4385                         return ret;
    4386 
    4387                 } else {
    4388                         ret = jQuery.find.attr( elem, name );
    4389 
    4390                         // Non-existent attributes return null, we normalize to undefined
    4391                         return ret == null ?
    4392                                 undefined :
    4393                                 ret;
    4394                 }
    4395         },
    4396 
    4397         removeAttr: function( elem, value ) {
    4398                 var name, propName,
    4399                         i = 0,
    4400                         attrNames = value && value.match( core_rnotwhite );
    4401 
    4402                 if ( attrNames && elem.nodeType === 1 ) {
    4403                         while ( (name = attrNames[i++]) ) {
    4404                                 propName = jQuery.propFix[ name ] || name;
    4405 
    4406                                 // Boolean attributes get special treatment (#10870)
    4407                                 if ( jQuery.expr.match.bool.test( name ) ) {
    4408                                         // Set corresponding property to false
    4409                                         if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
    4410                                                 elem[ propName ] = false;
    4411                                         // Support: IE<9
    4412                                         // Also clear defaultChecked/defaultSelected (if appropriate)
    4413                                         } else {
    4414                                                 elem[ jQuery.camelCase( "default-" + name ) ] =
    4415                                                         elem[ propName ] = false;
    4416                                         }
    4417 
    4418                                 // See #9699 for explanation of this approach (setting first, then removal)
    4419                                 } else {
    4420                                         jQuery.attr( elem, name, "" );
    4421                                 }
    4422 
    4423                                 elem.removeAttribute( getSetAttribute ? name : propName );
    4424                         }
    4425                 }
    4426         },
    4427 
    4428         attrHooks: {
    4429                 type: {
    4430                         set: function( elem, value ) {
    4431                                 if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
    4432                                         // Setting the type on a radio button after the value resets the value in IE6-9
    4433                                         // Reset value to default in case type is set after value during creation
    4434                                         var val = elem.value;
    4435                                         elem.setAttribute( "type", value );
    4436                                         if ( val ) {
    4437                                                 elem.value = val;
    4438                                         }
    4439                                         return value;
    4440                                 }
    4441                         }
    4442                 }
    4443         },
    4444 
    4445         propFix: {
    4446                 "for": "htmlFor",
    4447                 "class": "className"
    4448         },
    4449 
    4450         prop: function( elem, name, value ) {
    4451                 var ret, hooks, notxml,
    4452                         nType = elem.nodeType;
    4453 
    4454                 // don't get/set properties on text, comment and attribute nodes
    4455                 if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
    4456                         return;
    4457                 }
    4458 
    4459                 notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
    4460 
    4461                 if ( notxml ) {
    4462                         // Fix name and attach hooks
    4463                         name = jQuery.propFix[ name ] || name;
    4464                         hooks = jQuery.propHooks[ name ];
    4465                 }
    4466 
    4467                 if ( value !== undefined ) {
    4468                         return hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ?
    4469                                 ret :
    4470                                 ( elem[ name ] = value );
    4471 
    4472                 } else {
    4473                         return hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ?
    4474                                 ret :
    4475                                 elem[ name ];
    4476                 }
    4477         },
    4478 
    4479         propHooks: {
    4480                 tabIndex: {
    4481                         get: function( elem ) {
    4482                                 // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
    4483                                 // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
    4484                                 // Use proper attribute retrieval(#12072)
    4485                                 var tabindex = jQuery.find.attr( elem, "tabindex" );
    4486 
    4487                                 return tabindex ?
    4488                                         parseInt( tabindex, 10 ) :
    4489                                         rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
    4490                                                 0 :
    4491                                                 -1;
    4492                         }
    4493                 }
    4494         }
    4495 });
    4496 
    4497 // Hooks for boolean attributes
    4498 boolHook = {
    4499         set: function( elem, value, name ) {
    4500                 if ( value === false ) {
    4501                         // Remove boolean attributes when set to false
    4502                         jQuery.removeAttr( elem, name );
    4503                 } else if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
    4504                         // IE<8 needs the *property* name
    4505                         elem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name );
    4506 
    4507                 // Use defaultChecked and defaultSelected for oldIE
    4508                 } else {
    4509                         elem[ jQuery.camelCase( "default-" + name ) ] = elem[ name ] = true;
    4510                 }
    4511 
    4512                 return name;
    4513         }
    4514 };
    4515 jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
    4516         var getter = jQuery.expr.attrHandle[ name ] || jQuery.find.attr;
    4517 
    4518         jQuery.expr.attrHandle[ name ] = getSetInput && getSetAttribute || !ruseDefault.test( name ) ?
    4519                 function( elem, name, isXML ) {
    4520                         var fn = jQuery.expr.attrHandle[ name ],
    4521                                 ret = isXML ?
    4522                                         undefined :
    4523                                         /* jshint eqeqeq: false */
    4524                                         (jQuery.expr.attrHandle[ name ] = undefined) !=
    4525                                                 getter( elem, name, isXML ) ?
    4526 
    4527                                                 name.toLowerCase() :
    4528                                                 null;
    4529                         jQuery.expr.attrHandle[ name ] = fn;
    4530                         return ret;
    4531                 } :
    4532                 function( elem, name, isXML ) {
    4533                         return isXML ?
    4534                                 undefined :
    4535                                 elem[ jQuery.camelCase( "default-" + name ) ] ?
    4536                                         name.toLowerCase() :
    4537                                         null;
    4538                 };
    4539 });
    4540 
    4541 // fix oldIE attroperties
    4542 if ( !getSetInput || !getSetAttribute ) {
    4543         jQuery.attrHooks.value = {
    4544                 set: function( elem, value, name ) {
    4545                         if ( jQuery.nodeName( elem, "input" ) ) {
    4546                                 // Does not return so that setAttribute is also used
    4547                                 elem.defaultValue = value;
    4548                         } else {
    4549                                 // Use nodeHook if defined (#1954); otherwise setAttribute is fine
    4550                                 return nodeHook && nodeHook.set( elem, value, name );
    4551                         }
    4552                 }
    4553         };
    4554 }
    4555 
    4556 // IE6/7 do not support getting/setting some attributes with get/setAttribute
    4557 if ( !getSetAttribute ) {
    4558 
    4559         // Use this for any attribute in IE6/7
    4560         // This fixes almost every IE6/7 issue
    4561         nodeHook = {
    4562                 set: function( elem, value, name ) {
    4563                         // Set the existing or create a new attribute node
    4564                         var ret = elem.getAttributeNode( name );
    4565                         if ( !ret ) {
    4566                                 elem.setAttributeNode(
    4567                                         (ret = elem.ownerDocument.createAttribute( name ))
    4568                                 );
    4569                         }
    4570 
    4571                         ret.value = value += "";
    4572 
    4573                         // Break association with cloned elements by also using setAttribute (#9646)
    4574                         return name === "value" || value === elem.getAttribute( name ) ?
    4575                                 value :
    4576                                 undefined;
    4577                 }
    4578         };
    4579         jQuery.expr.attrHandle.id = jQuery.expr.attrHandle.name = jQuery.expr.attrHandle.coords =
    4580                 // Some attributes are constructed with empty-string values when not defined
    4581                 function( elem, name, isXML ) {
    4582                         var ret;
    4583                         return isXML ?
    4584                                 undefined :
    4585                                 (ret = elem.getAttributeNode( name )) && ret.value !== "" ?
    4586                                         ret.value :
    4587                                         null;
    4588                 };
    4589         jQuery.valHooks.button = {
    4590                 get: function( elem, name ) {
    4591                         var ret = elem.getAttributeNode( name );
    4592                         return ret && ret.specified ?
    4593                                 ret.value :
    4594                                 undefined;
    4595                 },
    4596                 set: nodeHook.set
    4597         };
    4598 
    4599         // Set contenteditable to false on removals(#10429)
    4600         // Setting to empty string throws an error as an invalid value
    4601         jQuery.attrHooks.contenteditable = {
    4602                 set: function( elem, value, name ) {
    4603                         nodeHook.set( elem, value === "" ? false : value, name );
    4604                 }
    4605         };
    4606 
    4607         // Set width and height to auto instead of 0 on empty string( Bug #8150 )
    4608         // This is for removals
    4609         jQuery.each([ "width", "height" ], function( i, name ) {
    4610                 jQuery.attrHooks[ name ] = {
    4611                         set: function( elem, value ) {
    4612                                 if ( value === "" ) {
    4613                                         elem.setAttribute( name, "auto" );
    4614                                         return value;
    4615                                 }
    4616                         }
    4617                 };
    4618         });
    4619 }
    4620 
    4621 
    4622 // Some attributes require a special call on IE
    4623 // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
    4624 if ( !jQuery.support.hrefNormalized ) {
    4625         // href/src property should get the full normalized URL (#10299/#12915)
    4626         jQuery.each([ "href", "src" ], function( i, name ) {
    4627                 jQuery.propHooks[ name ] = {
    4628                         get: function( elem ) {
    4629                                 return elem.getAttribute( name, 4 );
    4630                         }
    4631                 };
    4632         });
    4633 }
    4634 
    4635 if ( !jQuery.support.style ) {
    4636         jQuery.attrHooks.style = {
    4637                 get: function( elem ) {
    4638                         // Return undefined in the case of empty string
    4639                         // Note: IE uppercases css property names, but if we were to .toLowerCase()
    4640                         // .cssText, that would destroy case senstitivity in URL's, like in "background"
    4641                         return elem.style.cssText || undefined;
    4642                 },
    4643                 set: function( elem, value ) {
    4644                         return ( elem.style.cssText = value + "" );
    4645                 }
    4646         };
    4647 }
    4648 
    4649 // Safari mis-reports the default selected property of an option
    4650 // Accessing the parent's selectedIndex property fixes it
    4651 if ( !jQuery.support.optSelected ) {
    4652         jQuery.propHooks.selected = {
    4653                 get: function( elem ) {
    4654                         var parent = elem.parentNode;
    4655 
    4656                         if ( parent ) {
    4657                                 parent.selectedIndex;
    4658 
    4659                                 // Make sure that it also works with optgroups, see #5701
    4660                                 if ( parent.parentNode ) {
    4661                                         parent.parentNode.selectedIndex;
    4662                                 }
    4663                         }
    4664                         return null;
    4665                 }
    4666         };
    4667 }
    4668 
    4669 jQuery.each([
    4670         "tabIndex",
    4671         "readOnly",
    4672         "maxLength",
    4673         "cellSpacing",
    4674         "cellPadding",
    4675         "rowSpan",
    4676         "colSpan",
    4677         "useMap",
    4678         "frameBorder",
    4679         "contentEditable"
    4680 ], function() {
    4681         jQuery.propFix[ this.toLowerCase() ] = this;
    4682 });
    4683 
    4684 // IE6/7 call enctype encoding
    4685 if ( !jQuery.support.enctype ) {
    4686         jQuery.propFix.enctype = "encoding";
    4687 }
    4688 
    4689 // Radios and checkboxes getter/setter
    4690 jQuery.each([ "radio", "checkbox" ], function() {
    4691         jQuery.valHooks[ this ] = {
    4692                 set: function( elem, value ) {
    4693                         if ( jQuery.isArray( value ) ) {
    4694                                 return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
    4695                         }
    4696                 }
    4697         };
    4698         if ( !jQuery.support.checkOn ) {
    4699                 jQuery.valHooks[ this ].get = function( elem ) {
    4700                         // Support: Webkit
    4701                         // "" is returned instead of "on" if a value isn't specified
    4702                         return elem.getAttribute("value") === null ? "on" : elem.value;
    4703                 };
    4704         }
    4705 });
     4192
     4193                div.cloneNode( true ).click();
     4194        }
     4195
     4196        // Execute the test only if not already executed in another module.
     4197        if (support.deleteExpando == null) {
     4198                // Support: IE<9
     4199                support.deleteExpando = true;
     4200                try {
     4201                        delete div.test;
     4202                } catch( e ) {
     4203                        support.deleteExpando = false;
     4204                }
     4205        }
     4206
     4207        // Null elements to avoid leaks in IE.
     4208        fragment = div = input = null;
     4209})();
     4210
     4211
     4212(function() {
     4213        var i, eventName,
     4214                div = document.createElement( "div" );
     4215
     4216        // Support: IE<9 (lack submit/change bubble), Firefox 23+ (lack focusin event)
     4217        for ( i in { submit: true, change: true, focusin: true }) {
     4218                eventName = "on" + i;
     4219
     4220                if ( !(support[ i + "Bubbles" ] = eventName in window) ) {
     4221                        // Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP)
     4222                        div.setAttribute( eventName, "t" );
     4223                        support[ i + "Bubbles" ] = div.attributes[ eventName ].expando === false;
     4224                }
     4225        }
     4226
     4227        // Null elements to avoid leaks in IE.
     4228        div = null;
     4229})();
     4230
     4231
    47064232var rformElems = /^(?:input|select|textarea)$/i,
    47074233        rkeyEvent = /^key/,
     
    47634289                                // Discard the second event of a jQuery.event.trigger() and
    47644290                                // when an event is called after a page has unloaded
    4765                                 return typeof jQuery !== core_strundefined && (!e || jQuery.event.triggered !== e.type) ?
     4291                                return typeof jQuery !== strundefined && (!e || jQuery.event.triggered !== e.type) ?
    47664292                                        jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
    47674293                                        undefined;
     
    47724298
    47734299                // Handle multiple events separated by a space
    4774                 types = ( types || "" ).match( core_rnotwhite ) || [""];
     4300                types = ( types || "" ).match( rnotwhite ) || [ "" ];
    47754301                t = types.length;
    47764302                while ( t-- ) {
     
    48584384
    48594385                // Once for each type.namespace in types; type may be omitted
    4860                 types = ( types || "" ).match( core_rnotwhite ) || [""];
     4386                types = ( types || "" ).match( rnotwhite ) || [ "" ];
    48614387                t = types.length;
    48624388                while ( t-- ) {
     
    49234449                        bubbleType, special, tmp, i,
    49244450                        eventPath = [ elem || document ],
    4925                         type = core_hasOwn.call( event, "type" ) ? event.type : event,
    4926                         namespaces = core_hasOwn.call( event, "namespace" ) ? event.namespace.split(".") : [];
     4451                        type = hasOwn.call( event, "type" ) ? event.type : event,
     4452                        namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split(".") : [];
    49274453
    49284454                cur = tmp = elem = elem || document;
     
    50104536                        // Native handler
    50114537                        handle = ontype && cur[ ontype ];
    5012                         if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === false ) {
    5013                                 event.preventDefault();
     4538                        if ( handle && handle.apply && jQuery.acceptData( cur ) ) {
     4539                                event.result = handle.apply( cur, data );
     4540                                if ( event.result === false ) {
     4541                                        event.preventDefault();
     4542                                }
    50144543                        }
    50154544                }
     
    50614590                var i, ret, handleObj, matched, j,
    50624591                        handlerQueue = [],
    5063                         args = core_slice.call( arguments ),
     4592                        args = slice.call( arguments ),
    50644593                        handlers = ( jQuery._data( this, "events" ) || {} )[ event.type ] || [],
    50654594                        special = jQuery.event.special[ event.type ] || {};
     
    53514880                        // #8545, #7054, preventing memory leaks for custom events in IE6-8
    53524881                        // detachEvent needed property on element, by name of that event, to properly expose it to GC
    5353                         if ( typeof elem[ name ] === core_strundefined ) {
     4882                        if ( typeof elem[ name ] === strundefined ) {
    53544883                                elem[ name ] = null;
    53554884                        }
     
    53724901                // Events bubbling up the document may have been marked as prevented
    53734902                // by a handler lower down the tree; reflect the correct value.
    5374                 this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
    5375                         src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
     4903                this.isDefaultPrevented = src.defaultPrevented ||
     4904                                src.defaultPrevented === undefined && (
     4905                                // Support: IE < 9
     4906                                src.returnValue === false ||
     4907                                // Support: Android < 4.0
     4908                                src.getPreventDefault && src.getPreventDefault() ) ?
     4909                        returnTrue :
     4910                        returnFalse;
    53764911
    53774912        // Event type
     
    54675002
    54685003// IE submit delegation
    5469 if ( !jQuery.support.submitBubbles ) {
     5004if ( !support.submitBubbles ) {
    54705005
    54715006        jQuery.event.special.submit = {
     
    55145049
    55155050// IE change delegation and checkbox/radio fix
    5516 if ( !jQuery.support.changeBubbles ) {
     5051if ( !support.changeBubbles ) {
    55175052
    55185053        jQuery.event.special.change = {
     
    55735108
    55745109// Create "bubbling" focus and blur events
    5575 if ( !jQuery.support.focusinBubbles ) {
     5110if ( !support.focusinBubbles ) {
    55765111        jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
    55775112
    5578                 // Attach a single capturing handler while someone wants focusin/focusout
    5579                 var attaches = 0,
    5580                         handler = function( event ) {
     5113                // Attach a single capturing handler on the document while someone wants focusin/focusout
     5114                var handler = function( event ) {
    55815115                                jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
    55825116                        };
     
    55845118                jQuery.event.special[ fix ] = {
    55855119                        setup: function() {
    5586                                 if ( attaches++ === 0 ) {
    5587                                         document.addEventListener( orig, handler, true );
    5588                                 }
     5120                                var doc = this.ownerDocument || this,
     5121                                        attaches = jQuery._data( doc, fix );
     5122
     5123                                if ( !attaches ) {
     5124                                        doc.addEventListener( orig, handler, true );
     5125                                }
     5126                                jQuery._data( doc, fix, ( attaches || 0 ) + 1 );
    55895127                        },
    55905128                        teardown: function() {
    5591                                 if ( --attaches === 0 ) {
    5592                                         document.removeEventListener( orig, handler, true );
     5129                                var doc = this.ownerDocument || this,
     5130                                        attaches = jQuery._data( doc, fix ) - 1;
     5131
     5132                                if ( !attaches ) {
     5133                                        doc.removeEventListener( orig, handler, true );
     5134                                        jQuery._removeData( doc, fix );
     5135                                } else {
     5136                                        jQuery._data( doc, fix, attaches );
    55935137                                }
    55945138                        }
     
    56995243        }
    57005244});
    5701 var isSimple = /^.[^:#\[\.,]*$/,
    5702         rparentsprev = /^(?:parents|prev(?:Until|All))/,
    5703         rneedsContext = jQuery.expr.match.needsContext,
    5704         // methods guaranteed to produce a unique set when starting from a unique set
    5705         guaranteedUnique = {
    5706                 children: true,
    5707                 contents: true,
    5708                 next: true,
    5709                 prev: true
    5710         };
    5711 
    5712 jQuery.fn.extend({
    5713         find: function( selector ) {
    5714                 var i,
    5715                         ret = [],
    5716                         self = this,
    5717                         len = self.length;
    5718 
    5719                 if ( typeof selector !== "string" ) {
    5720                         return this.pushStack( jQuery( selector ).filter(function() {
    5721                                 for ( i = 0; i < len; i++ ) {
    5722                                         if ( jQuery.contains( self[ i ], this ) ) {
    5723                                                 return true;
    5724                                         }
    5725                                 }
    5726                         }) );
    5727                 }
    5728 
    5729                 for ( i = 0; i < len; i++ ) {
    5730                         jQuery.find( selector, self[ i ], ret );
    5731                 }
    5732 
    5733                 // Needed because $( selector, context ) becomes $( context ).find( selector )
    5734                 ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );
    5735                 ret.selector = this.selector ? this.selector + " " + selector : selector;
    5736                 return ret;
    5737         },
    5738 
    5739         has: function( target ) {
    5740                 var i,
    5741                         targets = jQuery( target, this ),
    5742                         len = targets.length;
    5743 
    5744                 return this.filter(function() {
    5745                         for ( i = 0; i < len; i++ ) {
    5746                                 if ( jQuery.contains( this, targets[i] ) ) {
    5747                                         return true;
    5748                                 }
    5749                         }
    5750                 });
    5751         },
    5752 
    5753         not: function( selector ) {
    5754                 return this.pushStack( winnow(this, selector || [], true) );
    5755         },
    5756 
    5757         filter: function( selector ) {
    5758                 return this.pushStack( winnow(this, selector || [], false) );
    5759         },
    5760 
    5761         is: function( selector ) {
    5762                 return !!winnow(
    5763                         this,
    5764 
    5765                         // If this is a positional/relative selector, check membership in the returned set
    5766                         // so $("p:first").is("p:last") won't return true for a doc with two "p".
    5767                         typeof selector === "string" && rneedsContext.test( selector ) ?
    5768                                 jQuery( selector ) :
    5769                                 selector || [],
    5770                         false
    5771                 ).length;
    5772         },
    5773 
    5774         closest: function( selectors, context ) {
    5775                 var cur,
    5776                         i = 0,
    5777                         l = this.length,
    5778                         ret = [],
    5779                         pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
    5780                                 jQuery( selectors, context || this.context ) :
    5781                                 0;
    5782 
    5783                 for ( ; i < l; i++ ) {
    5784                         for ( cur = this[i]; cur && cur !== context; cur = cur.parentNode ) {
    5785                                 // Always skip document fragments
    5786                                 if ( cur.nodeType < 11 && (pos ?
    5787                                         pos.index(cur) > -1 :
    5788 
    5789                                         // Don't pass non-elements to Sizzle
    5790                                         cur.nodeType === 1 &&
    5791                                                 jQuery.find.matchesSelector(cur, selectors)) ) {
    5792 
    5793                                         cur = ret.push( cur );
    5794                                         break;
    5795                                 }
    5796                         }
    5797                 }
    5798 
    5799                 return this.pushStack( ret.length > 1 ? jQuery.unique( ret ) : ret );
    5800         },
    5801 
    5802         // Determine the position of an element within
    5803         // the matched set of elements
    5804         index: function( elem ) {
    5805 
    5806                 // No argument, return index in parent
    5807                 if ( !elem ) {
    5808                         return ( this[0] && this[0].parentNode ) ? this.first().prevAll().length : -1;
    5809                 }
    5810 
    5811                 // index in selector
    5812                 if ( typeof elem === "string" ) {
    5813                         return jQuery.inArray( this[0], jQuery( elem ) );
    5814                 }
    5815 
    5816                 // Locate the position of the desired element
    5817                 return jQuery.inArray(
    5818                         // If it receives a jQuery object, the first element is used
    5819                         elem.jquery ? elem[0] : elem, this );
    5820         },
    5821 
    5822         add: function( selector, context ) {
    5823                 var set = typeof selector === "string" ?
    5824                                 jQuery( selector, context ) :
    5825                                 jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
    5826                         all = jQuery.merge( this.get(), set );
    5827 
    5828                 return this.pushStack( jQuery.unique(all) );
    5829         },
    5830 
    5831         addBack: function( selector ) {
    5832                 return this.add( selector == null ?
    5833                         this.prevObject : this.prevObject.filter(selector)
    5834                 );
    5835         }
    5836 });
    5837 
    5838 function sibling( cur, dir ) {
    5839         do {
    5840                 cur = cur[ dir ];
    5841         } while ( cur && cur.nodeType !== 1 );
    5842 
    5843         return cur;
    5844 }
    5845 
    5846 jQuery.each({
    5847         parent: function( elem ) {
    5848                 var parent = elem.parentNode;
    5849                 return parent && parent.nodeType !== 11 ? parent : null;
    5850         },
    5851         parents: function( elem ) {
    5852                 return jQuery.dir( elem, "parentNode" );
    5853         },
    5854         parentsUntil: function( elem, i, until ) {
    5855                 return jQuery.dir( elem, "parentNode", until );
    5856         },
    5857         next: function( elem ) {
    5858                 return sibling( elem, "nextSibling" );
    5859         },
    5860         prev: function( elem ) {
    5861                 return sibling( elem, "previousSibling" );
    5862         },
    5863         nextAll: function( elem ) {
    5864                 return jQuery.dir( elem, "nextSibling" );
    5865         },
    5866         prevAll: function( elem ) {
    5867                 return jQuery.dir( elem, "previousSibling" );
    5868         },
    5869         nextUntil: function( elem, i, until ) {
    5870                 return jQuery.dir( elem, "nextSibling", until );
    5871         },
    5872         prevUntil: function( elem, i, until ) {
    5873                 return jQuery.dir( elem, "previousSibling", until );
    5874         },
    5875         siblings: function( elem ) {
    5876                 return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
    5877         },
    5878         children: function( elem ) {
    5879                 return jQuery.sibling( elem.firstChild );
    5880         },
    5881         contents: function( elem ) {
    5882                 return jQuery.nodeName( elem, "iframe" ) ?
    5883                         elem.contentDocument || elem.contentWindow.document :
    5884                         jQuery.merge( [], elem.childNodes );
    5885         }
    5886 }, function( name, fn ) {
    5887         jQuery.fn[ name ] = function( until, selector ) {
    5888                 var ret = jQuery.map( this, fn, until );
    5889 
    5890                 if ( name.slice( -5 ) !== "Until" ) {
    5891                         selector = until;
    5892                 }
    5893 
    5894                 if ( selector && typeof selector === "string" ) {
    5895                         ret = jQuery.filter( selector, ret );
    5896                 }
    5897 
    5898                 if ( this.length > 1 ) {
    5899                         // Remove duplicates
    5900                         if ( !guaranteedUnique[ name ] ) {
    5901                                 ret = jQuery.unique( ret );
    5902                         }
    5903 
    5904                         // Reverse order for parents* and prev-derivatives
    5905                         if ( rparentsprev.test( name ) ) {
    5906                                 ret = ret.reverse();
    5907                         }
    5908                 }
    5909 
    5910                 return this.pushStack( ret );
    5911         };
    5912 });
    5913 
    5914 jQuery.extend({
    5915         filter: function( expr, elems, not ) {
    5916                 var elem = elems[ 0 ];
    5917 
    5918                 if ( not ) {
    5919                         expr = ":not(" + expr + ")";
    5920                 }
    5921 
    5922                 return elems.length === 1 && elem.nodeType === 1 ?
    5923                         jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :
    5924                         jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
    5925                                 return elem.nodeType === 1;
    5926                         }));
    5927         },
    5928 
    5929         dir: function( elem, dir, until ) {
    5930                 var matched = [],
    5931                         cur = elem[ dir ];
    5932 
    5933                 while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
    5934                         if ( cur.nodeType === 1 ) {
    5935                                 matched.push( cur );
    5936                         }
    5937                         cur = cur[dir];
    5938                 }
    5939                 return matched;
    5940         },
    5941 
    5942         sibling: function( n, elem ) {
    5943                 var r = [];
    5944 
    5945                 for ( ; n; n = n.nextSibling ) {
    5946                         if ( n.nodeType === 1 && n !== elem ) {
    5947                                 r.push( n );
    5948                         }
    5949                 }
    5950 
    5951                 return r;
    5952         }
    5953 });
    5954 
    5955 // Implement the identical functionality for filter and not
    5956 function winnow( elements, qualifier, not ) {
    5957         if ( jQuery.isFunction( qualifier ) ) {
    5958                 return jQuery.grep( elements, function( elem, i ) {
    5959                         /* jshint -W018 */
    5960                         return !!qualifier.call( elem, i, elem ) !== not;
    5961                 });
    5962 
    5963         }
    5964 
    5965         if ( qualifier.nodeType ) {
    5966                 return jQuery.grep( elements, function( elem ) {
    5967                         return ( elem === qualifier ) !== not;
    5968                 });
    5969 
    5970         }
    5971 
    5972         if ( typeof qualifier === "string" ) {
    5973                 if ( isSimple.test( qualifier ) ) {
    5974                         return jQuery.filter( qualifier, elements, not );
    5975                 }
    5976 
    5977                 qualifier = jQuery.filter( qualifier, elements );
    5978         }
    5979 
    5980         return jQuery.grep( elements, function( elem ) {
    5981                 return ( jQuery.inArray( elem, qualifier ) >= 0 ) !== not;
    5982         });
    5983 }
     5245
     5246
    59845247function createSafeFragment( document ) {
    59855248        var list = nodeNames.split( "|" ),
     
    60065269        rhtml = /<|&#?\w+;/,
    60075270        rnoInnerhtml = /<(?:script|style|link)/i,
    6008         manipulation_rcheckableType = /^(?:checkbox|radio)$/i,
    60095271        // checked="checked" or checked
    60105272        rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
     
    60265288                // IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
    60275289                // unless wrapped in a div with non-breaking characters in front of it.
    6028                 _default: jQuery.support.htmlSerialize ? [ 0, "", "" ] : [ 1, "X<div>", "</div>"  ]
     5290                _default: support.htmlSerialize ? [ 0, "", "" ] : [ 1, "X<div>", "</div>"  ]
    60295291        },
    60305292        safeFragment = createSafeFragment( document ),
     
    60355297wrapMap.th = wrapMap.td;
    60365298
    6037 jQuery.fn.extend({
    6038         text: function( value ) {
    6039                 return jQuery.access( this, function( value ) {
    6040                         return value === undefined ?
    6041                                 jQuery.text( this ) :
    6042                                 this.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) );
    6043                 }, null, value, arguments.length );
    6044         },
    6045 
    6046         append: function() {
    6047                 return this.domManip( arguments, function( elem ) {
    6048                         if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
    6049                                 var target = manipulationTarget( this, elem );
    6050                                 target.appendChild( elem );
    6051                         }
    6052                 });
    6053         },
    6054 
    6055         prepend: function() {
    6056                 return this.domManip( arguments, function( elem ) {
    6057                         if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
    6058                                 var target = manipulationTarget( this, elem );
    6059                                 target.insertBefore( elem, target.firstChild );
    6060                         }
    6061                 });
    6062         },
    6063 
    6064         before: function() {
    6065                 return this.domManip( arguments, function( elem ) {
    6066                         if ( this.parentNode ) {
    6067                                 this.parentNode.insertBefore( elem, this );
    6068                         }
    6069                 });
    6070         },
    6071 
    6072         after: function() {
    6073                 return this.domManip( arguments, function( elem ) {
    6074                         if ( this.parentNode ) {
    6075                                 this.parentNode.insertBefore( elem, this.nextSibling );
    6076                         }
    6077                 });
    6078         },
    6079 
    6080         // keepData is for internal use only--do not document
    6081         remove: function( selector, keepData ) {
    6082                 var elem,
    6083                         elems = selector ? jQuery.filter( selector, this ) : this,
    6084                         i = 0;
    6085 
    6086                 for ( ; (elem = elems[i]) != null; i++ ) {
    6087 
    6088                         if ( !keepData && elem.nodeType === 1 ) {
    6089                                 jQuery.cleanData( getAll( elem ) );
    6090                         }
    6091 
    6092                         if ( elem.parentNode ) {
    6093                                 if ( keepData && jQuery.contains( elem.ownerDocument, elem ) ) {
    6094                                         setGlobalEval( getAll( elem, "script" ) );
    6095                                 }
    6096                                 elem.parentNode.removeChild( elem );
    6097                         }
    6098                 }
    6099 
    6100                 return this;
    6101         },
    6102 
    6103         empty: function() {
    6104                 var elem,
    6105                         i = 0;
    6106 
    6107                 for ( ; (elem = this[i]) != null; i++ ) {
    6108                         // Remove element nodes and prevent memory leaks
    6109                         if ( elem.nodeType === 1 ) {
    6110                                 jQuery.cleanData( getAll( elem, false ) );
    6111                         }
    6112 
    6113                         // Remove any remaining nodes
    6114                         while ( elem.firstChild ) {
    6115                                 elem.removeChild( elem.firstChild );
    6116                         }
    6117 
    6118                         // If this is a select, ensure that it displays empty (#12336)
    6119                         // Support: IE<9
    6120                         if ( elem.options && jQuery.nodeName( elem, "select" ) ) {
    6121                                 elem.options.length = 0;
    6122                         }
    6123                 }
    6124 
    6125                 return this;
    6126         },
    6127 
    6128         clone: function( dataAndEvents, deepDataAndEvents ) {
    6129                 dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
    6130                 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
    6131 
    6132                 return this.map( function () {
    6133                         return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
    6134                 });
    6135         },
    6136 
    6137         html: function( value ) {
    6138                 return jQuery.access( this, function( value ) {
    6139                         var elem = this[0] || {},
    6140                                 i = 0,
    6141                                 l = this.length;
    6142 
    6143                         if ( value === undefined ) {
    6144                                 return elem.nodeType === 1 ?
    6145                                         elem.innerHTML.replace( rinlinejQuery, "" ) :
    6146                                         undefined;
    6147                         }
    6148 
    6149                         // See if we can take a shortcut and just use innerHTML
    6150                         if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
    6151                                 ( jQuery.support.htmlSerialize || !rnoshimcache.test( value )  ) &&
    6152                                 ( jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&
    6153                                 !wrapMap[ ( rtagName.exec( value ) || ["", ""] )[1].toLowerCase() ] ) {
    6154 
    6155                                 value = value.replace( rxhtmlTag, "<$1></$2>" );
    6156 
    6157                                 try {
    6158                                         for (; i < l; i++ ) {
    6159                                                 // Remove element nodes and prevent memory leaks
    6160                                                 elem = this[i] || {};
    6161                                                 if ( elem.nodeType === 1 ) {
    6162                                                         jQuery.cleanData( getAll( elem, false ) );
    6163                                                         elem.innerHTML = value;
    6164                                                 }
    6165                                         }
    6166 
    6167                                         elem = 0;
    6168 
    6169                                 // If using innerHTML throws an exception, use the fallback method
    6170                                 } catch(e) {}
    6171                         }
    6172 
    6173                         if ( elem ) {
    6174                                 this.empty().append( value );
    6175                         }
    6176                 }, null, value, arguments.length );
    6177         },
    6178 
    6179         replaceWith: function() {
    6180                 var
    6181                         // Snapshot the DOM in case .domManip sweeps something relevant into its fragment
    6182                         args = jQuery.map( this, function( elem ) {
    6183                                 return [ elem.nextSibling, elem.parentNode ];
    6184                         }),
    6185                         i = 0;
    6186 
    6187                 // Make the changes, replacing each context element with the new content
    6188                 this.domManip( arguments, function( elem ) {
    6189                         var next = args[ i++ ],
    6190                                 parent = args[ i++ ];
    6191 
    6192                         if ( parent ) {
    6193                                 // Don't use the snapshot next if it has moved (#13810)
    6194                                 if ( next && next.parentNode !== parent ) {
    6195                                         next = this.nextSibling;
    6196                                 }
    6197                                 jQuery( this ).remove();
    6198                                 parent.insertBefore( elem, next );
    6199                         }
    6200                 // Allow new content to include elements from the context set
    6201                 }, true );
    6202 
    6203                 // Force removal if there was no new content (e.g., from empty arguments)
    6204                 return i ? this : this.remove();
    6205         },
    6206 
    6207         detach: function( selector ) {
    6208                 return this.remove( selector, true );
    6209         },
    6210 
    6211         domManip: function( args, callback, allowIntersection ) {
    6212 
    6213                 // Flatten any nested arrays
    6214                 args = core_concat.apply( [], args );
    6215 
    6216                 var first, node, hasScripts,
    6217                         scripts, doc, fragment,
    6218                         i = 0,
    6219                         l = this.length,
    6220                         set = this,
    6221                         iNoClone = l - 1,
    6222                         value = args[0],
    6223                         isFunction = jQuery.isFunction( value );
    6224 
    6225                 // We can't cloneNode fragments that contain checked, in WebKit
    6226                 if ( isFunction || !( l <= 1 || typeof value !== "string" || jQuery.support.checkClone || !rchecked.test( value ) ) ) {
    6227                         return this.each(function( index ) {
    6228                                 var self = set.eq( index );
    6229                                 if ( isFunction ) {
    6230                                         args[0] = value.call( this, index, self.html() );
    6231                                 }
    6232                                 self.domManip( args, callback, allowIntersection );
    6233                         });
    6234                 }
    6235 
    6236                 if ( l ) {
    6237                         fragment = jQuery.buildFragment( args, this[ 0 ].ownerDocument, false, !allowIntersection && this );
    6238                         first = fragment.firstChild;
    6239 
    6240                         if ( fragment.childNodes.length === 1 ) {
    6241                                 fragment = first;
    6242                         }
    6243 
    6244                         if ( first ) {
    6245                                 scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
    6246                                 hasScripts = scripts.length;
    6247 
    6248                                 // Use the original fragment for the last item instead of the first because it can end up
    6249                                 // being emptied incorrectly in certain situations (#8070).
    6250                                 for ( ; i < l; i++ ) {
    6251                                         node = fragment;
    6252 
    6253                                         if ( i !== iNoClone ) {
    6254                                                 node = jQuery.clone( node, true, true );
    6255 
    6256                                                 // Keep references to cloned scripts for later restoration
    6257                                                 if ( hasScripts ) {
    6258                                                         jQuery.merge( scripts, getAll( node, "script" ) );
    6259                                                 }
    6260                                         }
    6261 
    6262                                         callback.call( this[i], node, i );
    6263                                 }
    6264 
    6265                                 if ( hasScripts ) {
    6266                                         doc = scripts[ scripts.length - 1 ].ownerDocument;
    6267 
    6268                                         // Reenable scripts
    6269                                         jQuery.map( scripts, restoreScript );
    6270 
    6271                                         // Evaluate executable scripts on first document insertion
    6272                                         for ( i = 0; i < hasScripts; i++ ) {
    6273                                                 node = scripts[ i ];
    6274                                                 if ( rscriptType.test( node.type || "" ) &&
    6275                                                         !jQuery._data( node, "globalEval" ) && jQuery.contains( doc, node ) ) {
    6276 
    6277                                                         if ( node.src ) {
    6278                                                                 // Hope ajax is available...
    6279                                                                 jQuery._evalUrl( node.src );
    6280                                                         } else {
    6281                                                                 jQuery.globalEval( ( node.text || node.textContent || node.innerHTML || "" ).replace( rcleanScript, "" ) );
    6282                                                         }
    6283                                                 }
    6284                                         }
    6285                                 }
    6286 
    6287                                 // Fix #11809: Avoid leaking memory
    6288                                 fragment = first = null;
    6289                         }
    6290                 }
    6291 
    6292                 return this;
    6293         }
    6294 });
     5299function getAll( context, tag ) {
     5300        var elems, elem,
     5301                i = 0,
     5302                found = typeof context.getElementsByTagName !== strundefined ? context.getElementsByTagName( tag || "*" ) :
     5303                        typeof context.querySelectorAll !== strundefined ? context.querySelectorAll( tag || "*" ) :
     5304                        undefined;
     5305
     5306        if ( !found ) {
     5307                for ( found = [], elems = context.childNodes || context; (elem = elems[i]) != null; i++ ) {
     5308                        if ( !tag || jQuery.nodeName( elem, tag ) ) {
     5309                                found.push( elem );
     5310                        } else {
     5311                                jQuery.merge( found, getAll( elem, tag ) );
     5312                        }
     5313                }
     5314        }
     5315
     5316        return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
     5317                jQuery.merge( [ context ], found ) :
     5318                found;
     5319}
     5320
     5321// Used in buildFragment, fixes the defaultChecked property
     5322function fixDefaultChecked( elem ) {
     5323        if ( rcheckableType.test( elem.type ) ) {
     5324                elem.defaultChecked = elem.checked;
     5325        }
     5326}
    62955327
    62965328// Support: IE<8
     
    62985330function manipulationTarget( elem, content ) {
    62995331        return jQuery.nodeName( elem, "table" ) &&
    6300                 jQuery.nodeName( content.nodeType === 1 ? content : content.firstChild, "tr" ) ?
     5332                jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ?
    63015333
    63025334                elem.getElementsByTagName("tbody")[0] ||
     
    63685400
    63695401        // IE6-8 copies events bound via attachEvent when using cloneNode.
    6370         if ( !jQuery.support.noCloneEvent && dest[ jQuery.expando ] ) {
     5402        if ( !support.noCloneEvent && dest[ jQuery.expando ] ) {
    63715403                data = jQuery._data( dest );
    63725404
     
    63955427                // If the src has innerHTML and the destination does not,
    63965428                // copy the src.innerHTML into the dest.innerHTML. #10324
    6397                 if ( jQuery.support.html5Clone && ( src.innerHTML && !jQuery.trim(dest.innerHTML) ) ) {
     5429                if ( support.html5Clone && ( src.innerHTML && !jQuery.trim(dest.innerHTML) ) ) {
    63985430                        dest.innerHTML = src.innerHTML;
    63995431                }
    64005432
    6401         } else if ( nodeName === "input" && manipulation_rcheckableType.test( src.type ) ) {
     5433        } else if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
    64025434                // IE6-8 fails to persist the checked state of a cloned checkbox
    64035435                // or radio button. Worse, IE6-7 fail to give the cloned element
     
    64235455        }
    64245456}
     5457
     5458jQuery.extend({
     5459        clone: function( elem, dataAndEvents, deepDataAndEvents ) {
     5460                var destElements, node, clone, i, srcElements,
     5461                        inPage = jQuery.contains( elem.ownerDocument, elem );
     5462
     5463                if ( support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test( "<" + elem.nodeName + ">" ) ) {
     5464                        clone = elem.cloneNode( true );
     5465
     5466                // IE<=8 does not properly clone detached, unknown element nodes
     5467                } else {
     5468                        fragmentDiv.innerHTML = elem.outerHTML;
     5469                        fragmentDiv.removeChild( clone = fragmentDiv.firstChild );
     5470                }
     5471
     5472                if ( (!support.noCloneEvent || !support.noCloneChecked) &&
     5473                                (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
     5474
     5475                        // We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
     5476                        destElements = getAll( clone );
     5477                        srcElements = getAll( elem );
     5478
     5479                        // Fix all IE cloning issues
     5480                        for ( i = 0; (node = srcElements[i]) != null; ++i ) {
     5481                                // Ensure that the destination node is not null; Fixes #9587
     5482                                if ( destElements[i] ) {
     5483                                        fixCloneNodeIssues( node, destElements[i] );
     5484                                }
     5485                        }
     5486                }
     5487
     5488                // Copy the events from the original to the clone
     5489                if ( dataAndEvents ) {
     5490                        if ( deepDataAndEvents ) {
     5491                                srcElements = srcElements || getAll( elem );
     5492                                destElements = destElements || getAll( clone );
     5493
     5494                                for ( i = 0; (node = srcElements[i]) != null; i++ ) {
     5495                                        cloneCopyEvent( node, destElements[i] );
     5496                                }
     5497                        } else {
     5498                                cloneCopyEvent( elem, clone );
     5499                        }
     5500                }
     5501
     5502                // Preserve script evaluation history
     5503                destElements = getAll( clone, "script" );
     5504                if ( destElements.length > 0 ) {
     5505                        setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
     5506                }
     5507
     5508                destElements = srcElements = node = null;
     5509
     5510                // Return the cloned set
     5511                return clone;
     5512        },
     5513
     5514        buildFragment: function( elems, context, scripts, selection ) {
     5515                var j, elem, contains,
     5516                        tmp, tag, tbody, wrap,
     5517                        l = elems.length,
     5518
     5519                        // Ensure a safe fragment
     5520                        safe = createSafeFragment( context ),
     5521
     5522                        nodes = [],
     5523                        i = 0;
     5524
     5525                for ( ; i < l; i++ ) {
     5526                        elem = elems[ i ];
     5527
     5528                        if ( elem || elem === 0 ) {
     5529
     5530                                // Add nodes directly
     5531                                if ( jQuery.type( elem ) === "object" ) {
     5532                                        jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
     5533
     5534                                // Convert non-html into a text node
     5535                                } else if ( !rhtml.test( elem ) ) {
     5536                                        nodes.push( context.createTextNode( elem ) );
     5537
     5538                                // Convert html into DOM nodes
     5539                                } else {
     5540                                        tmp = tmp || safe.appendChild( context.createElement("div") );
     5541
     5542                                        // Deserialize a standard representation
     5543                                        tag = (rtagName.exec( elem ) || [ "", "" ])[ 1 ].toLowerCase();
     5544                                        wrap = wrapMap[ tag ] || wrapMap._default;
     5545
     5546                                        tmp.innerHTML = wrap[1] + elem.replace( rxhtmlTag, "<$1></$2>" ) + wrap[2];
     5547
     5548                                        // Descend through wrappers to the right content
     5549                                        j = wrap[0];
     5550                                        while ( j-- ) {
     5551                                                tmp = tmp.lastChild;
     5552                                        }
     5553
     5554                                        // Manually add leading whitespace removed by IE
     5555                                        if ( !support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
     5556                                                nodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[0] ) );
     5557                                        }
     5558
     5559                                        // Remove IE's autoinserted <tbody> from table fragments
     5560                                        if ( !support.tbody ) {
     5561
     5562                                                // String was a <table>, *may* have spurious <tbody>
     5563                                                elem = tag === "table" && !rtbody.test( elem ) ?
     5564                                                        tmp.firstChild :
     5565
     5566                                                        // String was a bare <thead> or <tfoot>
     5567                                                        wrap[1] === "<table>" && !rtbody.test( elem ) ?
     5568                                                                tmp :
     5569                                                                0;
     5570
     5571                                                j = elem && elem.childNodes.length;
     5572                                                while ( j-- ) {
     5573                                                        if ( jQuery.nodeName( (tbody = elem.childNodes[j]), "tbody" ) && !tbody.childNodes.length ) {
     5574                                                                elem.removeChild( tbody );
     5575                                                        }
     5576                                                }
     5577                                        }
     5578
     5579                                        jQuery.merge( nodes, tmp.childNodes );
     5580
     5581                                        // Fix #12392 for WebKit and IE > 9
     5582                                        tmp.textContent = "";
     5583
     5584                                        // Fix #12392 for oldIE
     5585                                        while ( tmp.firstChild ) {
     5586                                                tmp.removeChild( tmp.firstChild );
     5587                                        }
     5588
     5589                                        // Remember the top-level container for proper cleanup
     5590                                        tmp = safe.lastChild;
     5591                                }
     5592                        }
     5593                }
     5594
     5595                // Fix #11356: Clear elements from fragment
     5596                if ( tmp ) {
     5597                        safe.removeChild( tmp );
     5598                }
     5599
     5600                // Reset defaultChecked for any radios and checkboxes
     5601                // about to be appended to the DOM in IE 6/7 (#8060)
     5602                if ( !support.appendChecked ) {
     5603                        jQuery.grep( getAll( nodes, "input" ), fixDefaultChecked );
     5604                }
     5605
     5606                i = 0;
     5607                while ( (elem = nodes[ i++ ]) ) {
     5608
     5609                        // #4087 - If origin and destination elements are the same, and this is
     5610                        // that element, do not do anything
     5611                        if ( selection && jQuery.inArray( elem, selection ) !== -1 ) {
     5612                                continue;
     5613                        }
     5614
     5615                        contains = jQuery.contains( elem.ownerDocument, elem );
     5616
     5617                        // Append to fragment
     5618                        tmp = getAll( safe.appendChild( elem ), "script" );
     5619
     5620                        // Preserve script evaluation history
     5621                        if ( contains ) {
     5622                                setGlobalEval( tmp );
     5623                        }
     5624
     5625                        // Capture executables
     5626                        if ( scripts ) {
     5627                                j = 0;
     5628                                while ( (elem = tmp[ j++ ]) ) {
     5629                                        if ( rscriptType.test( elem.type || "" ) ) {
     5630                                                scripts.push( elem );
     5631                                        }
     5632                                }
     5633                        }
     5634                }
     5635
     5636                tmp = null;
     5637
     5638                return safe;
     5639        },
     5640
     5641        cleanData: function( elems, /* internal */ acceptData ) {
     5642                var elem, type, id, data,
     5643                        i = 0,
     5644                        internalKey = jQuery.expando,
     5645                        cache = jQuery.cache,
     5646                        deleteExpando = support.deleteExpando,
     5647                        special = jQuery.event.special;
     5648
     5649                for ( ; (elem = elems[i]) != null; i++ ) {
     5650                        if ( acceptData || jQuery.acceptData( elem ) ) {
     5651
     5652                                id = elem[ internalKey ];
     5653                                data = id && cache[ id ];
     5654
     5655                                if ( data ) {
     5656                                        if ( data.events ) {
     5657                                                for ( type in data.events ) {
     5658                                                        if ( special[ type ] ) {
     5659                                                                jQuery.event.remove( elem, type );
     5660
     5661                                                        // This is a shortcut to avoid jQuery.event.remove's overhead
     5662                                                        } else {
     5663                                                                jQuery.removeEvent( elem, type, data.handle );
     5664                                                        }
     5665                                                }
     5666                                        }
     5667
     5668                                        // Remove cache only if it was not already removed by jQuery.event.remove
     5669                                        if ( cache[ id ] ) {
     5670
     5671                                                delete cache[ id ];
     5672
     5673                                                // IE does not allow us to delete expando properties from nodes,
     5674                                                // nor does it have a removeAttribute function on Document nodes;
     5675                                                // we must handle all of these cases
     5676                                                if ( deleteExpando ) {
     5677                                                        delete elem[ internalKey ];
     5678
     5679                                                } else if ( typeof elem.removeAttribute !== strundefined ) {
     5680                                                        elem.removeAttribute( internalKey );
     5681
     5682                                                } else {
     5683                                                        elem[ internalKey ] = null;
     5684                                                }
     5685
     5686                                                deletedIds.push( id );
     5687                                        }
     5688                                }
     5689                        }
     5690                }
     5691        }
     5692});
     5693
     5694jQuery.fn.extend({
     5695        text: function( value ) {
     5696                return access( this, function( value ) {
     5697                        return value === undefined ?
     5698                                jQuery.text( this ) :
     5699                                this.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) );
     5700                }, null, value, arguments.length );
     5701        },
     5702
     5703        append: function() {
     5704                return this.domManip( arguments, function( elem ) {
     5705                        if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
     5706                                var target = manipulationTarget( this, elem );
     5707                                target.appendChild( elem );
     5708                        }
     5709                });
     5710        },
     5711
     5712        prepend: function() {
     5713                return this.domManip( arguments, function( elem ) {
     5714                        if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
     5715                                var target = manipulationTarget( this, elem );
     5716                                target.insertBefore( elem, target.firstChild );
     5717                        }
     5718                });
     5719        },
     5720
     5721        before: function() {
     5722                return this.domManip( arguments, function( elem ) {
     5723                        if ( this.parentNode ) {
     5724                                this.parentNode.insertBefore( elem, this );
     5725                        }
     5726                });
     5727        },
     5728
     5729        after: function() {
     5730                return this.domManip( arguments, function( elem ) {
     5731                        if ( this.parentNode ) {
     5732                                this.parentNode.insertBefore( elem, this.nextSibling );
     5733                        }
     5734                });
     5735        },
     5736
     5737        remove: function( selector, keepData /* Internal Use Only */ ) {
     5738                var elem,
     5739                        elems = selector ? jQuery.filter( selector, this ) : this,
     5740                        i = 0;
     5741
     5742                for ( ; (elem = elems[i]) != null; i++ ) {
     5743
     5744                        if ( !keepData && elem.nodeType === 1 ) {
     5745                                jQuery.cleanData( getAll( elem ) );
     5746                        }
     5747
     5748                        if ( elem.parentNode ) {
     5749                                if ( keepData && jQuery.contains( elem.ownerDocument, elem ) ) {
     5750                                        setGlobalEval( getAll( elem, "script" ) );
     5751                                }
     5752                                elem.parentNode.removeChild( elem );
     5753                        }
     5754                }
     5755
     5756                return this;
     5757        },
     5758
     5759        empty: function() {
     5760                var elem,
     5761                        i = 0;
     5762
     5763                for ( ; (elem = this[i]) != null; i++ ) {
     5764                        // Remove element nodes and prevent memory leaks
     5765                        if ( elem.nodeType === 1 ) {
     5766                                jQuery.cleanData( getAll( elem, false ) );
     5767                        }
     5768
     5769                        // Remove any remaining nodes
     5770                        while ( elem.firstChild ) {
     5771                                elem.removeChild( elem.firstChild );
     5772                        }
     5773
     5774                        // If this is a select, ensure that it displays empty (#12336)
     5775                        // Support: IE<9
     5776                        if ( elem.options && jQuery.nodeName( elem, "select" ) ) {
     5777                                elem.options.length = 0;
     5778                        }
     5779                }
     5780
     5781                return this;
     5782        },
     5783
     5784        clone: function( dataAndEvents, deepDataAndEvents ) {
     5785                dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
     5786                deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
     5787
     5788                return this.map(function() {
     5789                        return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
     5790                });
     5791        },
     5792
     5793        html: function( value ) {
     5794                return access( this, function( value ) {
     5795                        var elem = this[ 0 ] || {},
     5796                                i = 0,
     5797                                l = this.length;
     5798
     5799                        if ( value === undefined ) {
     5800                                return elem.nodeType === 1 ?
     5801                                        elem.innerHTML.replace( rinlinejQuery, "" ) :
     5802                                        undefined;
     5803                        }
     5804
     5805                        // See if we can take a shortcut and just use innerHTML
     5806                        if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
     5807                                ( support.htmlSerialize || !rnoshimcache.test( value )  ) &&
     5808                                ( support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&
     5809                                !wrapMap[ (rtagName.exec( value ) || [ "", "" ])[ 1 ].toLowerCase() ] ) {
     5810
     5811                                value = value.replace( rxhtmlTag, "<$1></$2>" );
     5812
     5813                                try {
     5814                                        for (; i < l; i++ ) {
     5815                                                // Remove element nodes and prevent memory leaks
     5816                                                elem = this[i] || {};
     5817                                                if ( elem.nodeType === 1 ) {
     5818                                                        jQuery.cleanData( getAll( elem, false ) );
     5819                                                        elem.innerHTML = value;
     5820                                                }
     5821                                        }
     5822
     5823                                        elem = 0;
     5824
     5825                                // If using innerHTML throws an exception, use the fallback method
     5826                                } catch(e) {}
     5827                        }
     5828
     5829                        if ( elem ) {
     5830                                this.empty().append( value );
     5831                        }
     5832                }, null, value, arguments.length );
     5833        },
     5834
     5835        replaceWith: function() {
     5836                var arg = arguments[ 0 ];
     5837
     5838                // Make the changes, replacing each context element with the new content
     5839                this.domManip( arguments, function( elem ) {
     5840                        arg = this.parentNode;
     5841
     5842                        jQuery.cleanData( getAll( this ) );
     5843
     5844                        if ( arg ) {
     5845                                arg.replaceChild( elem, this );
     5846                        }
     5847                });
     5848
     5849                // Force removal if there was no new content (e.g., from empty arguments)
     5850                return arg && (arg.length || arg.nodeType) ? this : this.remove();
     5851        },
     5852
     5853        detach: function( selector ) {
     5854                return this.remove( selector, true );
     5855        },
     5856
     5857        domManip: function( args, callback ) {
     5858
     5859                // Flatten any nested arrays
     5860                args = concat.apply( [], args );
     5861
     5862                var first, node, hasScripts,
     5863                        scripts, doc, fragment,
     5864                        i = 0,
     5865                        l = this.length,
     5866                        set = this,
     5867                        iNoClone = l - 1,
     5868                        value = args[0],
     5869                        isFunction = jQuery.isFunction( value );
     5870
     5871                // We can't cloneNode fragments that contain checked, in WebKit
     5872                if ( isFunction ||
     5873                                ( l > 1 && typeof value === "string" &&
     5874                                        !support.checkClone && rchecked.test( value ) ) ) {
     5875                        return this.each(function( index ) {
     5876                                var self = set.eq( index );
     5877                                if ( isFunction ) {
     5878                                        args[0] = value.call( this, index, self.html() );
     5879                                }
     5880                                self.domManip( args, callback );
     5881                        });
     5882                }
     5883
     5884                if ( l ) {
     5885                        fragment = jQuery.buildFragment( args, this[ 0 ].ownerDocument, false, this );
     5886                        first = fragment.firstChild;
     5887
     5888                        if ( fragment.childNodes.length === 1 ) {
     5889                                fragment = first;
     5890                        }
     5891
     5892                        if ( first ) {
     5893                                scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
     5894                                hasScripts = scripts.length;
     5895
     5896                                // Use the original fragment for the last item instead of the first because it can end up
     5897                                // being emptied incorrectly in certain situations (#8070).
     5898                                for ( ; i < l; i++ ) {
     5899                                        node = fragment;
     5900
     5901                                        if ( i !== iNoClone ) {
     5902                                                node = jQuery.clone( node, true, true );
     5903
     5904                                                // Keep references to cloned scripts for later restoration
     5905                                                if ( hasScripts ) {
     5906                                                        jQuery.merge( scripts, getAll( node, "script" ) );
     5907                                                }
     5908                                        }
     5909
     5910                                        callback.call( this[i], node, i );
     5911                                }
     5912
     5913                                if ( hasScripts ) {
     5914                                        doc = scripts[ scripts.length - 1 ].ownerDocument;
     5915
     5916                                        // Reenable scripts
     5917                                        jQuery.map( scripts, restoreScript );
     5918
     5919                                        // Evaluate executable scripts on first document insertion
     5920                                        for ( i = 0; i < hasScripts; i++ ) {
     5921                                                node = scripts[ i ];
     5922                                                if ( rscriptType.test( node.type || "" ) &&
     5923                                                        !jQuery._data( node, "globalEval" ) && jQuery.contains( doc, node ) ) {
     5924
     5925                                                        if ( node.src ) {
     5926                                                                // Optional AJAX dependency, but won't run scripts if not present
     5927                                                                if ( jQuery._evalUrl ) {
     5928                                                                        jQuery._evalUrl( node.src );
     5929                                                                }
     5930                                                        } else {
     5931                                                                jQuery.globalEval( ( node.text || node.textContent || node.innerHTML || "" ).replace( rcleanScript, "" ) );
     5932                                                        }
     5933                                                }
     5934                                        }
     5935                                }
     5936
     5937                                // Fix #11809: Avoid leaking memory
     5938                                fragment = first = null;
     5939                        }
     5940                }
     5941
     5942                return this;
     5943        }
     5944});
    64255945
    64265946jQuery.each({
     
    64435963
    64445964                        // Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get()
    6445                         core_push.apply( ret, elems.get() );
     5965                        push.apply( ret, elems.get() );
    64465966                }
    64475967
     
    64505970});
    64515971
    6452 function getAll( context, tag ) {
    6453         var elems, elem,
    6454                 i = 0,
    6455                 found = typeof context.getElementsByTagName !== core_strundefined ? context.getElementsByTagName( tag || "*" ) :
    6456                         typeof context.querySelectorAll !== core_strundefined ? context.querySelectorAll( tag || "*" ) :
    6457                         undefined;
    6458 
    6459         if ( !found ) {
    6460                 for ( found = [], elems = context.childNodes || context; (elem = elems[i]) != null; i++ ) {
    6461                         if ( !tag || jQuery.nodeName( elem, tag ) ) {
    6462                                 found.push( elem );
    6463                         } else {
    6464                                 jQuery.merge( found, getAll( elem, tag ) );
    6465                         }
    6466                 }
    6467         }
    6468 
    6469         return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
    6470                 jQuery.merge( [ context ], found ) :
    6471                 found;
     5972
     5973var iframe,
     5974        elemdisplay = {};
     5975
     5976/**
     5977 * Retrieve the actual display of a element
     5978 * @param {String} name nodeName of the element
     5979 * @param {Object} doc Document object
     5980 */
     5981// Called only from within defaultDisplay
     5982function actualDisplay( name, doc ) {
     5983        var elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),
     5984
     5985                // getDefaultComputedStyle might be reliably used only on attached element
     5986                display = window.getDefaultComputedStyle ?
     5987
     5988                        // Use of this method is a temporary fix (more like optmization) until something better comes along,
     5989                        // since it was removed from specification and supported only in FF
     5990                        window.getDefaultComputedStyle( elem[ 0 ] ).display : jQuery.css( elem[ 0 ], "display" );
     5991
     5992        // We don't have any data stored on the element,
     5993        // so use "detach" method as fast way to get rid of the element
     5994        elem.detach();
     5995
     5996        return display;
    64725997}
    64735998
    6474 // Used in buildFragment, fixes the defaultChecked property
    6475 function fixDefaultChecked( elem ) {
    6476         if ( manipulation_rcheckableType.test( elem.type ) ) {
    6477                 elem.defaultChecked = elem.checked;
    6478         }
     5999/**
     6000 * Try to determine the default display value of an element
     6001 * @param {String} nodeName
     6002 */
     6003function defaultDisplay( nodeName ) {
     6004        var doc = document,
     6005                display = elemdisplay[ nodeName ];
     6006
     6007        if ( !display ) {
     6008                display = actualDisplay( nodeName, doc );
     6009
     6010                // If the simple way fails, read from inside an iframe
     6011                if ( display === "none" || !display ) {
     6012
     6013                        // Use the already-created iframe if possible
     6014                        iframe = (iframe || jQuery( "<iframe frameborder='0' width='0' height='0'/>" )).appendTo( doc.documentElement );
     6015
     6016                        // Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
     6017                        doc = ( iframe[ 0 ].contentWindow || iframe[ 0 ].contentDocument ).document;
     6018
     6019                        // Support: IE
     6020                        doc.write();
     6021                        doc.close();
     6022
     6023                        display = actualDisplay( nodeName, doc );
     6024                        iframe.detach();
     6025                }
     6026
     6027                // Store the correct default display
     6028                elemdisplay[ nodeName ] = display;
     6029        }
     6030
     6031        return display;
    64796032}
    64806033
    6481 jQuery.extend({
    6482         clone: function( elem, dataAndEvents, deepDataAndEvents ) {
    6483                 var destElements, node, clone, i, srcElements,
    6484                         inPage = jQuery.contains( elem.ownerDocument, elem );
    6485 
    6486                 if ( jQuery.support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test( "<" + elem.nodeName + ">" ) ) {
    6487                         clone = elem.cloneNode( true );
    6488 
    6489                 // IE<=8 does not properly clone detached, unknown element nodes
    6490                 } else {
    6491                         fragmentDiv.innerHTML = elem.outerHTML;
    6492                         fragmentDiv.removeChild( clone = fragmentDiv.firstChild );
    6493                 }
    6494 
    6495                 if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
    6496                                 (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
    6497 
    6498                         // We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
    6499                         destElements = getAll( clone );
    6500                         srcElements = getAll( elem );
    6501 
    6502                         // Fix all IE cloning issues
    6503                         for ( i = 0; (node = srcElements[i]) != null; ++i ) {
    6504                                 // Ensure that the destination node is not null; Fixes #9587
    6505                                 if ( destElements[i] ) {
    6506                                         fixCloneNodeIssues( node, destElements[i] );
    6507                                 }
    6508                         }
    6509                 }
    6510 
    6511                 // Copy the events from the original to the clone
    6512                 if ( dataAndEvents ) {
    6513                         if ( deepDataAndEvents ) {
    6514                                 srcElements = srcElements || getAll( elem );
    6515                                 destElements = destElements || getAll( clone );
    6516 
    6517                                 for ( i = 0; (node = srcElements[i]) != null; i++ ) {
    6518                                         cloneCopyEvent( node, destElements[i] );
    6519                                 }
    6520                         } else {
    6521                                 cloneCopyEvent( elem, clone );
    6522                         }
    6523                 }
    6524 
    6525                 // Preserve script evaluation history
    6526                 destElements = getAll( clone, "script" );
    6527                 if ( destElements.length > 0 ) {
    6528                         setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
    6529                 }
    6530 
    6531                 destElements = srcElements = node = null;
    6532 
    6533                 // Return the cloned set
    6534                 return clone;
    6535         },
    6536 
    6537         buildFragment: function( elems, context, scripts, selection ) {
    6538                 var j, elem, contains,
    6539                         tmp, tag, tbody, wrap,
    6540                         l = elems.length,
    6541 
    6542                         // Ensure a safe fragment
    6543                         safe = createSafeFragment( context ),
    6544 
    6545                         nodes = [],
    6546                         i = 0;
    6547 
    6548                 for ( ; i < l; i++ ) {
    6549                         elem = elems[ i ];
    6550 
    6551                         if ( elem || elem === 0 ) {
    6552 
    6553                                 // Add nodes directly
    6554                                 if ( jQuery.type( elem ) === "object" ) {
    6555                                         jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
    6556 
    6557                                 // Convert non-html into a text node
    6558                                 } else if ( !rhtml.test( elem ) ) {
    6559                                         nodes.push( context.createTextNode( elem ) );
    6560 
    6561                                 // Convert html into DOM nodes
    6562                                 } else {
    6563                                         tmp = tmp || safe.appendChild( context.createElement("div") );
    6564 
    6565                                         // Deserialize a standard representation
    6566                                         tag = ( rtagName.exec( elem ) || ["", ""] )[1].toLowerCase();
    6567                                         wrap = wrapMap[ tag ] || wrapMap._default;
    6568 
    6569                                         tmp.innerHTML = wrap[1] + elem.replace( rxhtmlTag, "<$1></$2>" ) + wrap[2];
    6570 
    6571                                         // Descend through wrappers to the right content
    6572                                         j = wrap[0];
    6573                                         while ( j-- ) {
    6574                                                 tmp = tmp.lastChild;
    6575                                         }
    6576 
    6577                                         // Manually add leading whitespace removed by IE
    6578                                         if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
    6579                                                 nodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[0] ) );
    6580                                         }
    6581 
    6582                                         // Remove IE's autoinserted <tbody> from table fragments
    6583                                         if ( !jQuery.support.tbody ) {
    6584 
    6585                                                 // String was a <table>, *may* have spurious <tbody>
    6586                                                 elem = tag === "table" && !rtbody.test( elem ) ?
    6587                                                         tmp.firstChild :
    6588 
    6589                                                         // String was a bare <thead> or <tfoot>
    6590                                                         wrap[1] === "<table>" && !rtbody.test( elem ) ?
    6591                                                                 tmp :
    6592                                                                 0;
    6593 
    6594                                                 j = elem && elem.childNodes.length;
    6595                                                 while ( j-- ) {
    6596                                                         if ( jQuery.nodeName( (tbody = elem.childNodes[j]), "tbody" ) && !tbody.childNodes.length ) {
    6597                                                                 elem.removeChild( tbody );
    6598                                                         }
    6599                                                 }
    6600                                         }
    6601 
    6602                                         jQuery.merge( nodes, tmp.childNodes );
    6603 
    6604                                         // Fix #12392 for WebKit and IE > 9
    6605                                         tmp.textContent = "";
    6606 
    6607                                         // Fix #12392 for oldIE
    6608                                         while ( tmp.firstChild ) {
    6609                                                 tmp.removeChild( tmp.firstChild );
    6610                                         }
    6611 
    6612                                         // Remember the top-level container for proper cleanup
    6613                                         tmp = safe.lastChild;
    6614                                 }
    6615                         }
    6616                 }
    6617 
    6618                 // Fix #11356: Clear elements from fragment
    6619                 if ( tmp ) {
    6620                         safe.removeChild( tmp );
    6621                 }
    6622 
    6623                 // Reset defaultChecked for any radios and checkboxes
    6624                 // about to be appended to the DOM in IE 6/7 (#8060)
    6625                 if ( !jQuery.support.appendChecked ) {
    6626                         jQuery.grep( getAll( nodes, "input" ), fixDefaultChecked );
    6627                 }
    6628 
    6629                 i = 0;
    6630                 while ( (elem = nodes[ i++ ]) ) {
    6631 
    6632                         // #4087 - If origin and destination elements are the same, and this is
    6633                         // that element, do not do anything
    6634                         if ( selection && jQuery.inArray( elem, selection ) !== -1 ) {
    6635                                 continue;
    6636                         }
    6637 
    6638                         contains = jQuery.contains( elem.ownerDocument, elem );
    6639 
    6640                         // Append to fragment
    6641                         tmp = getAll( safe.appendChild( elem ), "script" );
    6642 
    6643                         // Preserve script evaluation history
    6644                         if ( contains ) {
    6645                                 setGlobalEval( tmp );
    6646                         }
    6647 
    6648                         // Capture executables
    6649                         if ( scripts ) {
    6650                                 j = 0;
    6651                                 while ( (elem = tmp[ j++ ]) ) {
    6652                                         if ( rscriptType.test( elem.type || "" ) ) {
    6653                                                 scripts.push( elem );
    6654                                         }
    6655                                 }
    6656                         }
    6657                 }
    6658 
    6659                 tmp = null;
    6660 
    6661                 return safe;
    6662         },
    6663 
    6664         cleanData: function( elems, /* internal */ acceptData ) {
    6665                 var elem, type, id, data,
    6666                         i = 0,
    6667                         internalKey = jQuery.expando,
    6668                         cache = jQuery.cache,
    6669                         deleteExpando = jQuery.support.deleteExpando,
    6670                         special = jQuery.event.special;
    6671 
    6672                 for ( ; (elem = elems[i]) != null; i++ ) {
    6673 
    6674                         if ( acceptData || jQuery.acceptData( elem ) ) {
    6675 
    6676                                 id = elem[ internalKey ];
    6677                                 data = id && cache[ id ];
    6678 
    6679                                 if ( data ) {
    6680                                         if ( data.events ) {
    6681                                                 for ( type in data.events ) {
    6682                                                         if ( special[ type ] ) {
    6683                                                                 jQuery.event.remove( elem, type );
    6684 
    6685                                                         // This is a shortcut to avoid jQuery.event.remove's overhead
    6686                                                         } else {
    6687                                                                 jQuery.removeEvent( elem, type, data.handle );
    6688                                                         }
    6689                                                 }
    6690                                         }
    6691 
    6692                                         // Remove cache only if it was not already removed by jQuery.event.remove
    6693                                         if ( cache[ id ] ) {
    6694 
    6695                                                 delete cache[ id ];
    6696 
    6697                                                 // IE does not allow us to delete expando properties from nodes,
    6698                                                 // nor does it have a removeAttribute function on Document nodes;
    6699                                                 // we must handle all of these cases
    6700                                                 if ( deleteExpando ) {
    6701                                                         delete elem[ internalKey ];
    6702 
    6703                                                 } else if ( typeof elem.removeAttribute !== core_strundefined ) {
    6704                                                         elem.removeAttribute( internalKey );
    6705 
    6706                                                 } else {
    6707                                                         elem[ internalKey ] = null;
    6708                                                 }
    6709 
    6710                                                 core_deletedIds.push( id );
    6711                                         }
    6712                                 }
    6713                         }
    6714                 }
    6715         },
    6716 
    6717         _evalUrl: function( url ) {
    6718                 return jQuery.ajax({
    6719                         url: url,
    6720                         type: "GET",
    6721                         dataType: "script",
    6722                         async: false,
    6723                         global: false,
    6724                         "throws": true
     6034
     6035(function() {
     6036        var a, shrinkWrapBlocksVal,
     6037                div = document.createElement( "div" ),
     6038                divReset =
     6039                        "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;" +
     6040                        "display:block;padding:0;margin:0;border:0";
     6041
     6042        // Setup
     6043        div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
     6044        a = div.getElementsByTagName( "a" )[ 0 ];
     6045
     6046        a.style.cssText = "float:left;opacity:.5";
     6047
     6048        // Make sure that element opacity exists
     6049        // (IE uses filter instead)
     6050        // Use a regex to work around a WebKit issue. See #5145
     6051        support.opacity = /^0.5/.test( a.style.opacity );
     6052
     6053        // Verify style float existence
     6054        // (IE uses styleFloat instead of cssFloat)
     6055        support.cssFloat = !!a.style.cssFloat;