Changeset 27372


Ignore:
Timestamp:
02/13/14 23:57:07 (5 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                     &n