Changeset 103623 in spip-zone


Ignore:
Timestamp:
Mar 27, 2017, 7:50:49 PM (3 years ago)
Author:
real3t@…
Message:

jquery de 1.12.4 à 2.2.4

Location:
_plugins_/crayons
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/crayons/js/jquery.js

    r103620 r103623  
    11/*!
    2  * jQuery JavaScript Library v1.12.4
     2 * jQuery JavaScript Library v2.2.4
    33 * http://jquery.com/
    44 *
     
    1010 * http://jquery.org/license
    1111 *
    12  * Date: 2016-05-20T17:17Z
     12 * Date: 2016-05-20T17:23Z
    1313 */
    1414
     
    4343// you try to trace through "use strict" call chains. (#13335)
    4444//"use strict";
    45 var deletedIds = [];
     45var arr = [];
    4646
    4747var document = window.document;
    4848
    49 var slice = deletedIds.slice;
    50 
    51 var concat = deletedIds.concat;
    52 
    53 var push = deletedIds.push;
    54 
    55 var indexOf = deletedIds.indexOf;
     49var slice = arr.slice;
     50
     51var concat = arr.concat;
     52
     53var push = arr.push;
     54
     55var indexOf = arr.indexOf;
    5656
    5757var class2type = {};
     
    6666
    6767var
    68         version = "1.12.4",
     68        version = "2.2.4",
    6969
    7070        // Define a local copy of jQuery
     
    7676        },
    7777
    78         // Support: Android<4.1, IE<9
     78        // Support: Android<4.1
    7979        // Make sure we trim BOM and NBSP
    8080        rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
     
    169169        // Behaves like an Array's method, not like a jQuery method.
    170170        push: push,
    171         sort: deletedIds.sort,
    172         splice: deletedIds.splice
     171        sort: arr.sort,
     172        splice: arr.splice
    173173};
    174174
    175175jQuery.extend = jQuery.fn.extend = function() {
    176         var src, copyIsArray, copy, name, options, clone,
     176        var options, name, src, copy, copyIsArray, clone,
    177177                target = arguments[ 0 ] || {},
    178178                i = 1,
     
    184184                deep = target;
    185185
    186                 // skip the boolean and the target
     186                // Skip the boolean and the target
    187187                target = arguments[ i ] || {};
    188188                i++;
     
    194194        }
    195195
    196         // extend jQuery itself if only one argument is passed
     196        // Extend jQuery itself if only one argument is passed
    197197        if ( i === length ) {
    198198                target = this;
     
    256256        noop: function() {},
    257257
    258         // See test/unit/core.js for details concerning isFunction.
    259         // Since version 1.3, DOM methods and functions like alert
    260         // aren't supported. They return false on IE (#2968).
    261258        isFunction: function( obj ) {
    262259                return jQuery.type( obj ) === "function";
    263260        },
    264261
    265         isArray: Array.isArray || function( obj ) {
    266                 return jQuery.type( obj ) === "array";
    267         },
     262        isArray: Array.isArray,
    268263
    269264        isWindow: function( obj ) {
    270                 /* jshint eqeqeq: false */
    271                 return obj != null && obj == obj.window;
     265                return obj != null && obj === obj.window;
    272266        },
    273267
     
    282276        },
    283277
     278        isPlainObject: function( obj ) {
     279                var key;
     280
     281                // Not plain objects:
     282                // - Any object or value whose internal [[Class]] property is not "[object Object]"
     283                // - DOM nodes
     284                // - window
     285                if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
     286                        return false;
     287                }
     288
     289                // Not own constructor property must be Object
     290                if ( obj.constructor &&
     291                                !hasOwn.call( obj, "constructor" ) &&
     292                                !hasOwn.call( obj.constructor.prototype || {}, "isPrototypeOf" ) ) {
     293                        return false;
     294                }
     295
     296                // Own properties are enumerated firstly, so to speed up,
     297                // if last one is own, then all properties are own
     298                for ( key in obj ) {}
     299
     300                return key === undefined || hasOwn.call( obj, key );
     301        },
     302
    284303        isEmptyObject: function( obj ) {
    285304                var name;
     
    290309        },
    291310
    292         isPlainObject: function( obj ) {
    293                 var key;
    294 
    295                 // Must be an Object.
    296                 // Because of IE, we also have to check the presence of the constructor property.
    297                 // Make sure that DOM nodes and window objects don't pass through, as well
    298                 if ( !obj || jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
    299                         return false;
    300                 }
    301 
    302                 try {
    303 
    304                         // Not own constructor property must be Object
    305                         if ( obj.constructor &&
    306                                 !hasOwn.call( obj, "constructor" ) &&
    307                                 !hasOwn.call( obj.constructor.prototype, "isPrototypeOf" ) ) {
    308                                 return false;
    309                         }
    310                 } catch ( e ) {
    311 
    312                         // IE8,9 Will throw exceptions on certain host objects #9897
    313                         return false;
    314                 }
    315 
    316                 // Support: IE<9
    317                 // Handle iteration over inherited properties before own properties.
    318                 if ( !support.ownFirst ) {
    319                         for ( key in obj ) {
    320                                 return hasOwn.call( obj, key );
    321                         }
    322                 }
    323 
    324                 // Own properties are enumerated firstly, so to speed up,
    325                 // if last one is own, then all properties are own.
    326                 for ( key in obj ) {}
    327 
    328                 return key === undefined || hasOwn.call( obj, key );
    329         },
    330 
    331311        type: function( obj ) {
    332312                if ( obj == null ) {
    333313                        return obj + "";
    334314                }
     315
     316                // Support: Android<4.0, iOS<6 (functionish RegExp)
    335317                return typeof obj === "object" || typeof obj === "function" ?
    336318                        class2type[ toString.call( obj ) ] || "object" :
     
    338320        },
    339321
    340         // Workarounds based on findings by Jim Driscoll
    341         // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
    342         globalEval: function( data ) {
    343                 if ( data && jQuery.trim( data ) ) {
    344 
    345                         // We use execScript on Internet Explorer
    346                         // We use an anonymous function so that context is window
    347                         // rather than jQuery in Firefox
    348                         ( window.execScript || function( data ) {
    349                                 window[ "eval" ].call( window, data ); // jscs:ignore requireDotNotation
    350                         } )( data );
     322        // Evaluates a script in a global context
     323        globalEval: function( code ) {
     324                var script,
     325                        indirect = eval;
     326
     327                code = jQuery.trim( code );
     328
     329                if ( code ) {
     330
     331                        // If the code includes a valid, prologue position
     332                        // strict mode pragma, execute code by injecting a
     333                        // script tag into the document.
     334                        if ( code.indexOf( "use strict" ) === 1 ) {
     335                                script = document.createElement( "script" );
     336                                script.text = code;
     337                                document.head.appendChild( script ).parentNode.removeChild( script );
     338                        } else {
     339
     340                                // Otherwise, avoid the DOM node creation, insertion
     341                                // and removal by using an indirect global eval
     342
     343                                indirect( code );
     344                        }
    351345                }
    352346        },
    353347
    354348        // Convert dashed to camelCase; used by the css and data modules
     349        // Support: IE9-11+
    355350        // Microsoft forgot to hump their vendor prefix (#9572)
    356351        camelCase: function( string ) {
     
    383378        },
    384379
    385         // Support: Android<4.1, IE<9
     380        // Support: Android<4.1
    386381        trim: function( text ) {
    387382                return text == null ?
     
    409404
    410405        inArray: function( elem, arr, i ) {
    411                 var len;
    412 
    413                 if ( arr ) {
    414                         if ( indexOf ) {
    415                                 return indexOf.call( arr, elem, i );
    416                         }
    417 
    418                         len = arr.length;
    419                         i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
    420 
    421                         for ( ; i < len; i++ ) {
    422 
    423                                 // Skip accessing in sparse arrays
    424                                 if ( i in arr && arr[ i ] === elem ) {
    425                                         return i;
    426                                 }
    427                         }
    428                 }
    429 
    430                 return -1;
     406                return arr == null ? -1 : indexOf.call( arr, elem, i );
    431407        },
    432408
     
    436412                        i = first.length;
    437413
    438                 while ( j < len ) {
    439                         first[ i++ ] = second[ j++ ];
    440                 }
    441 
    442                 // Support: IE<9
    443                 // Workaround casting of .length to NaN on otherwise arraylike objects (e.g., NodeLists)
    444                 if ( len !== len ) {
    445                         while ( second[ j ] !== undefined ) {
    446                                 first[ i++ ] = second[ j++ ];
    447                         }
     414                for ( ; j < len; j++ ) {
     415                        first[ i++ ] = second[ j ];
    448416                }
    449417
     
    510478        // arguments.
    511479        proxy: function( fn, context ) {
    512                 var args, proxy, tmp;
     480                var tmp, args, proxy;
    513481
    514482                if ( typeof context === "string" ) {
     
    536504        },
    537505
    538         now: function() {
    539                 return +( new Date() );
    540         },
     506        now: Date.now,
    541507
    542508        // jQuery.support is not used in Core but other projects attach their
     
    551517/* jshint ignore: start */
    552518if ( typeof Symbol === "function" ) {
    553         jQuery.fn[ Symbol.iterator ] = deletedIds[ Symbol.iterator ];
     519        jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
    554520}
    555521/* jshint ignore: end */
     
    27882754
    27892755        return jQuery.grep( elements, function( elem ) {
    2790                 return ( jQuery.inArray( elem, qualifier ) > -1 ) !== not;
     2756                return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
    27912757        } );
    27922758}
     
    28092775        find: function( selector ) {
    28102776                var i,
     2777                        len = this.length,
    28112778                        ret = [],
    2812                         self = this,
    2813                         len = self.length;
     2779                        self = this;
    28142780
    28152781                if ( typeof selector !== "string" ) {
     
    28722838                }
    28732839
    2874                 // init accepts an alternate rootjQuery
     2840                // Method init() accepts an alternate rootjQuery
    28752841                // so migrate can support jQuery.sub (gh-2101)
    28762842                root = root || rootjQuery;
     
    28782844                // Handle HTML strings
    28792845                if ( typeof selector === "string" ) {
    2880                         if ( selector.charAt( 0 ) === "<" &&
    2881                                 selector.charAt( selector.length - 1 ) === ">" &&
     2846                        if ( selector[ 0 ] === "<" &&
     2847                                selector[ selector.length - 1 ] === ">" &&
    28822848                                selector.length >= 3 ) {
    28832849
     
    28962862                                        context = context instanceof jQuery ? context[ 0 ] : context;
    28972863
    2898                                         // scripts is true for back-compat
     2864                                        // Option to run scripts is true for back-compat
    28992865                                        // Intentionally let the error be thrown if parseHTML is not present
    29002866                                        jQuery.merge( this, jQuery.parseHTML(
     
    29252891                                        elem = document.getElementById( match[ 2 ] );
    29262892
    2927                                         // Check parentNode to catch when Blackberry 4.6 returns
    2928                                         // nodes that are no longer in the document #6963
     2893                                        // Support: Blackberry 4.6
     2894                                        // gEBID returns nodes no longer in the document (#6963)
    29292895                                        if ( elem && elem.parentNode ) {
    29302896
    2931                                                 // Handle the case where IE and Opera return items
    2932                                                 // by name instead of ID
    2933                                                 if ( elem.id !== match[ 2 ] ) {
    2934                                                         return rootjQuery.find( selector );
    2935                                                 }
    2936 
    2937                                                 // Otherwise, we inject the element directly into the jQuery object
     2897                                                // Inject the element directly into the jQuery object
    29382898                                                this.length = 1;
    29392899                                                this[ 0 ] = elem;
     
    29642924                // Shortcut for document ready
    29652925                } else if ( jQuery.isFunction( selector ) ) {
    2966                         return typeof root.ready !== "undefined" ?
     2926                        return root.ready !== undefined ?
    29672927                                root.ready( selector ) :
    29682928
     
    29882948var rparentsprev = /^(?:parents|prev(?:Until|All))/,
    29892949
    2990         // methods guaranteed to produce a unique set when starting from a unique set
     2950        // Methods guaranteed to produce a unique set when starting from a unique set
    29912951        guaranteedUnique = {
    29922952                children: true,
     
    29982958jQuery.fn.extend( {
    29992959        has: function( target ) {
    3000                 var i,
    3001                         targets = jQuery( target, this ),
    3002                         len = targets.length;
     2960                var targets = jQuery( target, this ),
     2961                        l = targets.length;
    30032962
    30042963                return this.filter( function() {
    3005                         for ( i = 0; i < len; i++ ) {
     2964                        var i = 0;
     2965                        for ( ; i < l; i++ ) {
    30062966                                if ( jQuery.contains( this, targets[ i ] ) ) {
    30072967                                        return true;
     
    30403000        },
    30413001
    3042         // Determine the position of an element within
    3043         // the matched set of elements
     3002        // Determine the position of an element within the set
    30443003        index: function( elem ) {
    30453004
     
    30493008                }
    30503009
    3051                 // index in selector
     3010                // Index in selector
    30523011                if ( typeof elem === "string" ) {
    3053                         return jQuery.inArray( this[ 0 ], jQuery( elem ) );
     3012                        return indexOf.call( jQuery( elem ), this[ 0 ] );
    30543013                }
    30553014
    30563015                // Locate the position of the desired element
    3057                 return jQuery.inArray(
     3016                return indexOf.call( this,
    30583017
    30593018                        // If it receives a jQuery object, the first element is used
    3060                         elem.jquery ? elem[ 0 ] : elem, this );
     3019                        elem.jquery ? elem[ 0 ] : elem
     3020                );
    30613021        },
    30623022
     
    30773037
    30783038function sibling( cur, dir ) {
    3079         do {
    3080                 cur = cur[ dir ];
    3081         } while ( cur && cur.nodeType !== 1 );
    3082 
     3039        while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
    30833040        return cur;
    30843041}
     
    31203077        },
    31213078        contents: function( elem ) {
    3122                 return jQuery.nodeName( elem, "iframe" ) ?
    3123                         elem.contentDocument || elem.contentWindow.document :
    3124                         jQuery.merge( [], elem.childNodes );
     3079                return elem.contentDocument || jQuery.merge( [], elem.childNodes );
    31253080        }
    31263081}, function( name, fn ) {
    31273082        jQuery.fn[ name ] = function( until, selector ) {
    3128                 var ret = jQuery.map( this, fn, until );
     3083                var matched = jQuery.map( this, fn, until );
    31293084
    31303085                if ( name.slice( -5 ) !== "Until" ) {
     
    31333088
    31343089                if ( selector && typeof selector === "string" ) {
    3135                         ret = jQuery.filter( selector, ret );
     3090                        matched = jQuery.filter( selector, matched );
    31363091                }
    31373092
     
    31403095                        // Remove duplicates
    31413096                        if ( !guaranteedUnique[ name ] ) {
    3142                                 ret = jQuery.uniqueSort( ret );
     3097                                jQuery.uniqueSort( matched );
    31433098                        }
    31443099
    31453100                        // Reverse order for parents* and prev-derivatives
    31463101                        if ( rparentsprev.test( name ) ) {
    3147                                 ret = ret.reverse();
    3148                         }
    3149                 }
    3150 
    3151                 return this.pushStack( ret );
     3102                                matched.reverse();
     3103                        }
     3104                }
     3105
     3106                return this.pushStack( matched );
    31523107        };
    31533108} );
     
    33433298                        // Abort any pending executions
    33443299                        lock: function() {
    3345                                 locked = true;
     3300                                locked = queue = [];
    33463301                                if ( !memory ) {
    3347                                         self.disable();
     3302                                        list = memory = "";
    33483303                                }
    33493304                                return this;
     
    34983453                                        if ( values === progressValues ) {
    34993454                                                deferred.notifyWith( contexts, values );
    3500 
    35013455                                        } else if ( !( --remaining ) ) {
    35023456                                                deferred.resolveWith( contexts, values );
     
    35073461                        progressValues, progressContexts, resolveContexts;
    35083462
    3509                 // add listeners to Deferred subordinates; treat others as resolved
     3463                // Add listeners to Deferred subordinates; treat others as resolved
    35103464                if ( length > 1 ) {
    35113465                        progressValues = new Array( length );
     
    35243478                }
    35253479
    3526                 // if we're not waiting on anything, resolve the master
     3480                // If we're not waiting on anything, resolve the master
    35273481                if ( !remaining ) {
    35283482                        deferred.resolveWith( resolveContexts, resolveValues );
     
    35913545
    35923546/**
    3593  * Clean-up method for dom ready events
    3594  */
    3595 function detach() {
    3596         if ( document.addEventListener ) {
    3597                 document.removeEventListener( "DOMContentLoaded", completed );
    3598                 window.removeEventListener( "load", completed );
    3599 
    3600         } else {
    3601                 document.detachEvent( "onreadystatechange", completed );
    3602                 window.detachEvent( "onload", completed );
    3603         }
    3604 }
    3605 
    3606 /**
    36073547 * The ready event handler and self cleanup method
    36083548 */
    36093549function completed() {
    3610 
    3611         // readyState === "complete" is good enough for us to call the dom ready in oldIE
    3612         if ( document.addEventListener ||
    3613                 window.event.type === "load" ||
    3614                 document.readyState === "complete" ) {
    3615 
    3616                 detach();
    3617                 jQuery.ready();
    3618         }
     3550        document.removeEventListener( "DOMContentLoaded", completed );
     3551        window.removeEventListener( "load", completed );
     3552        jQuery.ready();
    36193553}
    36203554
     
    36263560                // Catch cases where $(document).ready() is called
    36273561                // after the browser event has already occurred.
    3628                 // Support: IE6-10
     3562                // Support: IE9-10 only
    36293563                // Older IE sometimes signals "interactive" too soon
    36303564                if ( document.readyState === "complete" ||
     
    36343568                        window.setTimeout( jQuery.ready );
    36353569
    3636                 // Standards-based browsers support DOMContentLoaded
    3637                 } else if ( document.addEventListener ) {
     3570                } else {
    36383571
    36393572                        // Use the handy event callback
     
    36423575                        // A fallback to window.onload, that will always work
    36433576                        window.addEventListener( "load", completed );
    3644 
    3645                 // If IE event model is used
    3646                 } else {
    3647 
    3648                         // Ensure firing before onload, maybe late but safe also for iframes
    3649                         document.attachEvent( "onreadystatechange", completed );
    3650 
    3651                         // A fallback to window.onload, that will always work
    3652                         window.attachEvent( "onload", completed );
    3653 
    3654                         // If IE and not a frame
    3655                         // continually check to see if the document is ready
    3656                         var top = false;
    3657 
    3658                         try {
    3659                                 top = window.frameElement == null && document.documentElement;
    3660                         } catch ( e ) {}
    3661 
    3662                         if ( top && top.doScroll ) {
    3663                                 ( function doScrollCheck() {
    3664                                         if ( !jQuery.isReady ) {
    3665 
    3666                                                 try {
    3667 
    3668                                                         // Use the trick by Diego Perini
    3669                                                         // http://javascript.nwbox.com/IEContentLoaded/
    3670                                                         top.doScroll( "left" );
    3671                                                 } catch ( e ) {
    3672                                                         return window.setTimeout( doScrollCheck, 50 );
    3673                                                 }
    3674 
    3675                                                 // detach all dom ready events
    3676                                                 detach();
    3677 
    3678                                                 // and execute any waiting functions
    3679                                                 jQuery.ready();
    3680                                         }
    3681                                 } )();
    3682                         }
    36833577                }
    36843578        }
     
    36923586
    36933587
    3694 // Support: IE<9
    3695 // Iteration over object's inherited properties before its own
    3696 var i;
    3697 for ( i in jQuery( support ) ) {
    3698         break;
     3588// Multifunctional method to get and set values of a collection
     3589// The value/s can optionally be executed if it's a function
     3590var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
     3591        var i = 0,
     3592                len = elems.length,
     3593                bulk = key == null;
     3594
     3595        // Sets many values
     3596        if ( jQuery.type( key ) === "object" ) {
     3597                chainable = true;
     3598                for ( i in key ) {
     3599                        access( elems, fn, i, key[ i ], true, emptyGet, raw );
     3600                }
     3601
     3602        // Sets one value
     3603        } else if ( value !== undefined ) {
     3604                chainable = true;
     3605
     3606                if ( !jQuery.isFunction( value ) ) {
     3607                        raw = true;
     3608                }
     3609
     3610                if ( bulk ) {
     3611
     3612                        // Bulk operations run against the entire set
     3613                        if ( raw ) {
     3614                                fn.call( elems, value );
     3615                                fn = null;
     3616
     3617                        // ...except when executing function values
     3618                        } else {
     3619                                bulk = fn;
     3620                                fn = function( elem, key, value ) {
     3621                                        return bulk.call( jQuery( elem ), value );
     3622                                };
     3623                        }
     3624                }
     3625
     3626                if ( fn ) {
     3627                        for ( ; i < len; i++ ) {
     3628                                fn(
     3629                                        elems[ i ], key, raw ?
     3630                                        value :
     3631                                        value.call( elems[ i ], i, fn( elems[ i ], key ) )
     3632                                );
     3633                        }
     3634                }
     3635        }
     3636
     3637        return chainable ?
     3638                elems :
     3639
     3640                // Gets
     3641                bulk ?
     3642                        fn.call( elems ) :
     3643                        len ? fn( elems[ 0 ], key ) : emptyGet;
     3644};
     3645var acceptData = function( owner ) {
     3646
     3647        // Accepts only:
     3648        //  - Node
     3649        //    - Node.ELEMENT_NODE
     3650        //    - Node.DOCUMENT_NODE
     3651        //  - Object
     3652        //    - Any
     3653        /* jshint -W018 */
     3654        return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
     3655};
     3656
     3657
     3658
     3659
     3660function Data() {
     3661        this.expando = jQuery.expando + Data.uid++;
    36993662}
    3700 support.ownFirst = i === "0";
    3701 
    3702 // Note: most support tests are defined in their respective modules.
    3703 // false until the test is run
    3704 support.inlineBlockNeedsLayout = false;
    3705 
    3706 // Execute ASAP in case we need to set body.style.zoom
    3707 jQuery( function() {
    3708 
    3709         // Minified: var a,b,c,d
    3710         var val, div, body, container;
    3711 
    3712         body = document.getElementsByTagName( "body" )[ 0 ];
    3713         if ( !body || !body.style ) {
    3714 
    3715                 // Return for frameset docs that don't have a body
    3716                 return;
    3717         }
    3718 
    3719         // Setup
    3720         div = document.createElement( "div" );
    3721         container = document.createElement( "div" );
    3722         container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px";
    3723         body.appendChild( container ).appendChild( div );
    3724 
    3725         if ( typeof div.style.zoom !== "undefined" ) {
    3726 
    3727                 // Support: IE<8
    3728                 // Check if natively block-level elements act like inline-block
    3729                 // elements when setting their display to 'inline' and giving
    3730                 // them layout
    3731                 div.style.cssText = "display:inline;margin:0;border:0;padding:1px;width:1px;zoom:1";
    3732 
    3733                 support.inlineBlockNeedsLayout = val = div.offsetWidth === 3;
    3734                 if ( val ) {
    3735 
    3736                         // Prevent IE 6 from affecting layout for positioned elements #11048
    3737                         // Prevent IE from shrinking the body in IE 7 mode #12869
    3738                         // Support: IE<8
    3739                         body.style.zoom = 1;
    3740                 }
    3741         }
    3742 
    3743         body.removeChild( container );
    3744 } );
    3745 
    3746 
    3747 ( function() {
    3748         var div = document.createElement( "div" );
    3749 
    3750         // Support: IE<9
    3751         support.deleteExpando = true;
    3752         try {
    3753                 delete div.test;
    3754         } catch ( e ) {
    3755                 support.deleteExpando = false;
    3756         }
    3757 
    3758         // Null elements to avoid leaks in IE.
    3759         div = null;
    3760 } )();
    3761 var acceptData = function( elem ) {
    3762         var noData = jQuery.noData[ ( elem.nodeName + " " ).toLowerCase() ],
    3763                 nodeType = +elem.nodeType || 1;
    3764 
    3765         // Do not set data on non-element DOM nodes because it will not be cleared (#8335).
    3766         return nodeType !== 1 && nodeType !== 9 ?
    3767                 false :
    3768 
    3769                 // Nodes accept data unless otherwise specified; rejection can be conditional
    3770                 !noData || noData !== true && elem.getAttribute( "classid" ) === noData;
    3771 };
    3772 
    3773 
    3774 
    3775 
    3776 var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
    3777         rmultiDash = /([A-Z])/g;
    3778 
    3779 function dataAttr( elem, key, data ) {
    3780 
    3781         // If nothing was found internally, try to fetch any
    3782         // data from the HTML5 data-* attribute
    3783         if ( data === undefined && elem.nodeType === 1 ) {
    3784 
    3785                 var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
    3786 
    3787                 data = elem.getAttribute( name );
    3788 
     3663
     3664Data.uid = 1;
     3665
     3666Data.prototype = {
     3667
     3668        register: function( owner, initial ) {
     3669                var value = initial || {};
     3670
     3671                // If it is a node unlikely to be stringify-ed or looped over
     3672                // use plain assignment
     3673                if ( owner.nodeType ) {
     3674                        owner[ this.expando ] = value;
     3675
     3676                // Otherwise secure it in a non-enumerable, non-writable property
     3677                // configurability must be true to allow the property to be
     3678                // deleted with the delete operator
     3679                } else {
     3680                        Object.defineProperty( owner, this.expando, {
     3681                                value: value,
     3682                                writable: true,
     3683                                configurable: true
     3684                        } );
     3685                }
     3686                return owner[ this.expando ];
     3687        },
     3688        cache: function( owner ) {
     3689
     3690                // We can accept data for non-element nodes in modern browsers,
     3691                // but we should not, see #8335.
     3692                // Always return an empty object.
     3693                if ( !acceptData( owner ) ) {
     3694                        return {};
     3695                }
     3696
     3697                // Check if the owner object already has a cache
     3698                var value = owner[ this.expando ];
     3699
     3700                // If not, create one
     3701                if ( !value ) {
     3702                        value = {};
     3703
     3704                        // We can accept data for non-element nodes in modern browsers,
     3705                        // but we should not, see #8335.
     3706                        // Always return an empty object.
     3707                        if ( acceptData( owner ) ) {
     3708
     3709                                // If it is a node unlikely to be stringify-ed or looped over
     3710                                // use plain assignment
     3711                                if ( owner.nodeType ) {
     3712                                        owner[ this.expando ] = value;
     3713
     3714                                // Otherwise secure it in a non-enumerable property
     3715                                // configurable must be true to allow the property to be
     3716                                // deleted when data is removed
     3717                                } else {
     3718                                        Object.defineProperty( owner, this.expando, {
     3719                                                value: value,
     3720                                                configurable: true
     3721                                        } );
     3722                                }
     3723                        }
     3724                }
     3725
     3726                return value;
     3727        },
     3728        set: function( owner, data, value ) {
     3729                var prop,
     3730                        cache = this.cache( owner );
     3731
     3732                // Handle: [ owner, key, value ] args
    37893733                if ( typeof data === "string" ) {
    3790                         try {
    3791                                 data = data === "true" ? true :
    3792                                         data === "false" ? false :
    3793                                         data === "null" ? null :
    3794 
    3795                                         // Only convert to a number if it doesn't change the string
    3796                                         +data + "" === data ? +data :
    3797                                         rbrace.test( data ) ? jQuery.parseJSON( data ) :
    3798                                         data;
    3799                         } catch ( e ) {}
    3800 
    3801                         // Make sure we set the data so it isn't changed later
    3802                         jQuery.data( elem, key, data );
    3803 
     3734                        cache[ data ] = value;
     3735
     3736                // Handle: [ owner, { properties } ] args
    38043737                } else {
    3805                         data = undefined;
    3806                 }
    3807         }
    3808 
    3809         return data;
    3810 }
    3811 
    3812 // checks a cache object for emptiness
    3813 function isEmptyDataObject( obj ) {
    3814         var name;
    3815         for ( name in obj ) {
    3816 
    3817                 // if the public data object is empty, the private is still empty
    3818                 if ( name === "data" && jQuery.isEmptyObject( obj[ name ] ) ) {
    3819                         continue;
    3820                 }
    3821                 if ( name !== "toJSON" ) {
    3822                         return false;
    3823                 }
    3824         }
    3825 
    3826         return true;
    3827 }
    3828 
    3829 function internalData( elem, name, data, pvt /* Internal Use Only */ ) {
    3830         if ( !acceptData( elem ) ) {
    3831                 return;
    3832         }
    3833 
    3834         var ret, thisCache,
    3835                 internalKey = jQuery.expando,
    3836 
    3837                 // We have to handle DOM nodes and JS objects differently because IE6-7
    3838                 // can't GC object references properly across the DOM-JS boundary
    3839                 isNode = elem.nodeType,
    3840 
    3841                 // Only DOM nodes need the global jQuery cache; JS object data is
    3842                 // attached directly to the object so GC can occur automatically
    3843                 cache = isNode ? jQuery.cache : elem,
    3844 
    3845                 // Only defining an ID for JS objects if its cache already exists allows
    3846                 // the code to shortcut on the same path as a DOM node with no cache
    3847                 id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;
    3848 
    3849         // Avoid doing any more work than we need to when trying to get data on an
    3850         // object that has no data at all
    3851         if ( ( !id || !cache[ id ] || ( !pvt && !cache[ id ].data ) ) &&
    3852                 data === undefined && typeof name === "string" ) {
    3853                 return;
    3854         }
    3855 
    3856         if ( !id ) {
    3857 
    3858                 // Only DOM nodes need a new unique ID for each element since their data
    3859                 // ends up in the global cache
    3860                 if ( isNode ) {
    3861                         id = elem[ internalKey ] = deletedIds.pop() || jQuery.guid++;
     3738
     3739                        // Copy the properties one-by-one to the cache object
     3740                        for ( prop in data ) {
     3741                                cache[ prop ] = data[ prop ];
     3742                        }
     3743                }
     3744                return cache;
     3745        },
     3746        get: function( owner, key ) {
     3747                return key === undefined ?
     3748                        this.cache( owner ) :
     3749                        owner[ this.expando ] && owner[ this.expando ][ key ];
     3750        },
     3751        access: function( owner, key, value ) {
     3752                var stored;
     3753
     3754                // In cases where either:
     3755                //
     3756                //   1. No key was specified
     3757                //   2. A string key was specified, but no value provided
     3758                //
     3759                // Take the "read" path and allow the get method to determine
     3760                // which value to return, respectively either:
     3761                //
     3762                //   1. The entire cache object
     3763                //   2. The data stored at the key
     3764                //
     3765                if ( key === undefined ||
     3766                                ( ( key && typeof key === "string" ) && value === undefined ) ) {
     3767
     3768                        stored = this.get( owner, key );
     3769
     3770                        return stored !== undefined ?
     3771                                stored : this.get( owner, jQuery.camelCase( key ) );
     3772                }
     3773
     3774                // When the key is not a string, or both a key and value
     3775                // are specified, set or extend (existing objects) with either:
     3776                //
     3777                //   1. An object of properties
     3778                //   2. A key and value
     3779                //
     3780                this.set( owner, key, value );
     3781
     3782                // Since the "set" path can have two possible entry points
     3783                // return the expected data based on which path was taken[*]
     3784                return value !== undefined ? value : key;
     3785        },
     3786        remove: function( owner, key ) {
     3787                var i, name, camel,
     3788                        cache = owner[ this.expando ];
     3789
     3790                if ( cache === undefined ) {
     3791                        return;
     3792                }
     3793
     3794                if ( key === undefined ) {
     3795                        this.register( owner );
     3796
    38623797                } else {
    3863                         id = internalKey;
    3864                 }
    3865         }
    3866 
    3867         if ( !cache[ id ] ) {
    3868 
    3869                 // Avoid exposing jQuery metadata on plain JS objects when the object
    3870                 // is serialized using JSON.stringify
    3871                 cache[ id ] = isNode ? {} : { toJSON: jQuery.noop };
    3872         }
    3873 
    3874         // An object can be passed to jQuery.data instead of a key/value pair; this gets
    3875         // shallow copied over onto the existing cache
    3876         if ( typeof name === "object" || typeof name === "function" ) {
    3877                 if ( pvt ) {
    3878                         cache[ id ] = jQuery.extend( cache[ id ], name );
    3879                 } else {
    3880                         cache[ id ].data = jQuery.extend( cache[ id ].data, name );
    3881                 }
    3882         }
    3883 
    3884         thisCache = cache[ id ];
    3885 
    3886         // jQuery data() is stored in a separate object inside the object's internal data
    3887         // cache in order to avoid key collisions between internal data and user-defined
    3888         // data.
    3889         if ( !pvt ) {
    3890                 if ( !thisCache.data ) {
    3891                         thisCache.data = {};
    3892                 }
    3893 
    3894                 thisCache = thisCache.data;
    3895         }
    3896 
    3897         if ( data !== undefined ) {
    3898                 thisCache[ jQuery.camelCase( name ) ] = data;
    3899         }
    3900 
    3901         // Check for both converted-to-camel and non-converted data property names
    3902         // If a data property was specified
    3903         if ( typeof name === "string" ) {
    3904 
    3905                 // First Try to find as-is property data
    3906                 ret = thisCache[ name ];
    3907 
    3908                 // Test for null|undefined property data
    3909                 if ( ret == null ) {
    3910 
    3911                         // Try to find the camelCased property
    3912                         ret = thisCache[ jQuery.camelCase( name ) ];
    3913                 }
    3914         } else {
    3915                 ret = thisCache;
    3916         }
    3917 
    3918         return ret;
    3919 }
    3920 
    3921 function internalRemoveData( elem, name, pvt ) {
    3922         if ( !acceptData( elem ) ) {
    3923                 return;
    3924         }
    3925 
    3926         var thisCache, i,
    3927                 isNode = elem.nodeType,
    3928 
    3929                 // See jQuery.data for more information
    3930                 cache = isNode ? jQuery.cache : elem,
    3931                 id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
    3932 
    3933         // If there is already no cache entry for this object, there is no
    3934         // purpose in continuing
    3935         if ( !cache[ id ] ) {
    3936                 return;
    3937         }
    3938 
    3939         if ( name ) {
    3940 
    3941                 thisCache = pvt ? cache[ id ] : cache[ id ].data;
    3942 
    3943                 if ( thisCache ) {
    3944 
    3945                         // Support array or space separated string names for data keys
    3946                         if ( !jQuery.isArray( name ) ) {
    3947 
    3948                                 // try the string as a key before any manipulation
    3949                                 if ( name in thisCache ) {
    3950                                         name = [ name ];
    3951                                 } else {
    3952 
    3953                                         // split the camel cased version by spaces unless a key with the spaces exists
    3954                                         name = jQuery.camelCase( name );
    3955                                         if ( name in thisCache ) {
    3956                                                 name = [ name ];
    3957                                         } else {
    3958                                                 name = name.split( " " );
    3959                                         }
    3960                                 }
    3961                         } else {
     3798
     3799                        // Support array or space separated string of keys
     3800                        if ( jQuery.isArray( key ) ) {
    39623801
    39633802                                // If "name" is an array of keys...
     
    39673806                                // both plain key and camelCase key. #12786
    39683807                                // This will only penalize the array argument path.
    3969                                 name = name.concat( jQuery.map( name, jQuery.camelCase ) );
     3808                                name = key.concat( key.map( jQuery.camelCase ) );
     3809                        } else {
     3810                                camel = jQuery.camelCase( key );
     3811
     3812                                // Try the string as a key before any manipulation
     3813                                if ( key in cache ) {
     3814                                        name = [ key, camel ];
     3815                                } else {
     3816
     3817                                        // If a key with the spaces exists, use it.
     3818                                        // Otherwise, create an array by matching non-whitespace
     3819                                        name = camel;
     3820                                        name = name in cache ?
     3821                                                [ name ] : ( name.match( rnotwhite ) || [] );
     3822                                }
    39703823                        }
    39713824
    39723825                        i = name.length;
     3826
    39733827                        while ( i-- ) {
    3974                                 delete thisCache[ name[ i ] ];
    3975                         }
    3976 
    3977                         // If there is no data left in the cache, we want to continue
    3978                         // and let the cache object itself get destroyed
    3979                         if ( pvt ? !isEmptyDataObject( thisCache ) : !jQuery.isEmptyObject( thisCache ) ) {
    3980                                 return;
    3981                         }
    3982                 }
    3983         }
    3984 
    3985         // See jQuery.data for more information
    3986         if ( !pvt ) {
    3987                 delete cache[ id ].data;
    3988 
    3989                 // Don't destroy the parent cache unless the internal data object
    3990                 // had been the only thing left in it
    3991                 if ( !isEmptyDataObject( cache[ id ] ) ) {
    3992                         return;
    3993                 }
    3994         }
    3995 
    3996         // Destroy the cache
    3997         if ( isNode ) {
    3998                 jQuery.cleanData( [ elem ], true );
    3999 
    4000         // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
    4001         /* jshint eqeqeq: false */
    4002         } else if ( support.deleteExpando || cache != cache.window ) {
    4003                 /* jshint eqeqeq: true */
    4004                 delete cache[ id ];
    4005 
    4006         // When all else fails, undefined
    4007         } else {
    4008                 cache[ id ] = undefined;
    4009         }
     3828                                delete cache[ name[ i ] ];
     3829                        }
     3830                }
     3831
     3832                // Remove the expando if there's no more data
     3833                if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
     3834
     3835                        // Support: Chrome <= 35-45+
     3836                        // Webkit & Blink performance suffers when deleting properties
     3837                        // from DOM nodes, so set to undefined instead
     3838                        // https://code.google.com/p/chromium/issues/detail?id=378607
     3839                        if ( owner.nodeType ) {
     3840                                owner[ this.expando ] = undefined;
     3841                        } else {
     3842                                delete owner[ this.expando ];
     3843                        }
     3844                }
     3845        },
     3846        hasData: function( owner ) {
     3847                var cache = owner[ this.expando ];
     3848                return cache !== undefined && !jQuery.isEmptyObject( cache );
     3849        }
     3850};
     3851var dataPriv = new Data();
     3852
     3853var dataUser = new Data();
     3854
     3855
     3856
     3857//      Implementation Summary
     3858//
     3859//      1. Enforce API surface and semantic compatibility with 1.9.x branch
     3860//      2. Improve the module's maintainability by reducing the storage
     3861//              paths to a single mechanism.
     3862//      3. Use the same single mechanism to support "private" and "user" data.
     3863//      4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
     3864//      5. Avoid exposing implementation details on user objects (eg. expando properties)
     3865//      6. Provide a clear path for implementation upgrade to WeakMap in 2014
     3866
     3867var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
     3868        rmultiDash = /[A-Z]/g;
     3869
     3870function dataAttr( elem, key, data ) {
     3871        var name;
     3872
     3873        // If nothing was found internally, try to fetch any
     3874        // data from the HTML5 data-* attribute
     3875        if ( data === undefined && elem.nodeType === 1 ) {
     3876                name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
     3877                data = elem.getAttribute( name );
     3878
     3879                if ( typeof data === "string" ) {
     3880                        try {
     3881                                data = data === "true" ? true :
     3882                                        data === "false" ? false :
     3883                                        data === "null" ? null :
     3884
     3885                                        // Only convert to a number if it doesn't change the string
     3886                                        +data + "" === data ? +data :
     3887                                        rbrace.test( data ) ? jQuery.parseJSON( data ) :
     3888                                        data;
     3889                        } catch ( e ) {}
     3890
     3891                        // Make sure we set the data so it isn't changed later
     3892                        dataUser.set( elem, key, data );
     3893                } else {
     3894                        data = undefined;
     3895                }
     3896        }
     3897        return data;
    40103898}
    40113899
    40123900jQuery.extend( {
    4013         cache: {},
    4014 
    4015         // The following elements (space-suffixed to avoid Object.prototype collisions)
    4016         // throw uncatchable exceptions if you attempt to set expando properties
    4017         noData: {
    4018                 "applet ": true,
    4019                 "embed ": true,
    4020 
    4021                 // ...but Flash objects (which have this classid) *can* handle expandos
    4022                 "object ": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"
    4023         },
    4024 
    40253901        hasData: function( elem ) {
    4026                 elem = elem.nodeType ? jQuery.cache[ elem[ jQuery.expando ] ] : elem[ jQuery.expando ];
    4027                 return !!elem && !isEmptyDataObject( elem );
     3902                return dataUser.hasData( elem ) || dataPriv.hasData( elem );
    40283903        },
    40293904
    40303905        data: function( elem, name, data ) {
    4031                 return internalData( elem, name, data );
     3906                return dataUser.access( elem, name, data );
    40323907        },
    40333908
    40343909        removeData: function( elem, name ) {
    4035                 return internalRemoveData( elem, name );
    4036         },
    4037 
    4038         // For internal use only.
     3910                dataUser.remove( elem, name );
     3911        },
     3912
     3913        // TODO: Now that all calls to _data and _removeData have been replaced
     3914        // with direct calls to dataPriv methods, these can be deprecated.
    40393915        _data: function( elem, name, data ) {
    4040                 return internalData( elem, name, data, true );
     3916                return dataPriv.access( elem, name, data );
    40413917        },
    40423918
    40433919        _removeData: function( elem, name ) {
    4044                 return internalRemoveData( elem, name, true );
     3920                dataPriv.remove( elem, name );
    40453921        }
    40463922} );
     
    40523928                        attrs = elem && elem.attributes;
    40533929
    4054                 // Special expections of .data basically thwart jQuery.access,
    4055                 // so implement the relevant behavior ourselves
    4056 
    40573930                // Gets all values
    40583931                if ( key === undefined ) {
    40593932                        if ( this.length ) {
    4060                                 data = jQuery.data( elem );
    4061 
    4062                                 if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
     3933                                data = dataUser.get( elem );
     3934
     3935                                if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
    40633936                                        i = attrs.length;
    40643937                                        while ( i-- ) {
     
    40743947                                                }
    40753948                                        }
    4076                                         jQuery._data( elem, "parsedAttrs", true );
     3949                                        dataPriv.set( elem, "hasDataAttrs", true );
    40773950                                }
    40783951                        }
     
    40843957                if ( typeof key === "object" ) {
    40853958                        return this.each( function() {
    4086                                 jQuery.data( this, key );
     3959                                dataUser.set( this, key );
    40873960                        } );
    40883961                }
    40893962
    4090                 return arguments.length > 1 ?
    4091 
    4092                         // Sets one value
     3963                return access( this, function( value ) {
     3964                        var data, camelKey;
     3965
     3966                        // The calling jQuery object (element matches) is not empty
     3967                        // (and therefore has an element appears at this[ 0 ]) and the
     3968                        // `value` parameter was not undefined. An empty jQuery object
     3969                        // will result in `undefined` for elem = this[ 0 ] which will
     3970                        // throw an exception if an attempt to read a data cache is made.
     3971                        if ( elem && value === undefined ) {
     3972
     3973                                // Attempt to get data from the cache
     3974                                // with the key as-is
     3975                                data = dataUser.get( elem, key ) ||
     3976
     3977                                        // Try to find dashed key if it exists (gh-2779)
     3978                                        // This is for 2.2.x only
     3979                                        dataUser.get( elem, key.replace( rmultiDash, "-$&" ).toLowerCase() );
     3980
     3981                                if ( data !== undefined ) {
     3982                                        return data;
     3983                                }
     3984
     3985                                camelKey = jQuery.camelCase( key );
     3986
     3987                                // Attempt to get data from the cache
     3988                                // with the key camelized
     3989                                data = dataUser.get( elem, camelKey );
     3990                                if ( data !== undefined ) {
     3991                                        return data;
     3992                                }
     3993
     3994                                // Attempt to "discover" the data in
     3995                                // HTML5 custom data-* attrs
     3996                                data = dataAttr( elem, camelKey, undefined );
     3997                                if ( data !== undefined ) {
     3998                                        return data;
     3999                                }
     4000
     4001                                // We tried really hard, but the data doesn't exist.
     4002                                return;
     4003                        }
     4004
     4005                        // Set the data...
     4006                        camelKey = jQuery.camelCase( key );
    40934007                        this.each( function() {
    4094                                 jQuery.data( this, key, value );
    4095                         } ) :
    4096 
    4097                         // Gets one value
    4098                         // Try to fetch any internally stored data first
    4099                         elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : undefined;
     4008
     4009                                // First, attempt to store a copy or reference of any
     4010                                // data that might've been store with a camelCased key.
     4011                                var data = dataUser.get( this, camelKey );
     4012
     4013                                // For HTML5 data-* attribute interop, we have to
     4014                                // store property names with dashes in a camelCase form.
     4015                                // This might not apply to all properties...*
     4016                                dataUser.set( this, camelKey, value );
     4017
     4018                                // *... In the case of properties that might _actually_
     4019                                // have dashes, we need to also store a copy of that
     4020                                // unchanged property.
     4021                                if ( key.indexOf( "-" ) > -1 && data !== undefined ) {
     4022                                        dataUser.set( this, key, value );
     4023                                }
     4024                        } );
     4025                }, null, value, arguments.length > 1, null, true );
    41004026        },
    41014027
    41024028        removeData: function( key ) {
    41034029                return this.each( function() {
    4104                         jQuery.removeData( this, key );
     4030                        dataUser.remove( this, key );
    41054031                } );
    41064032        }
     
    41144040                if ( elem ) {
    41154041                        type = ( type || "fx" ) + "queue";
    4116                         queue = jQuery._data( elem, type );
     4042                        queue = dataPriv.get( elem, type );
    41174043
    41184044                        // Speed up dequeue by getting out quickly if this is just a lookup
    41194045                        if ( data ) {
    41204046                                if ( !queue || jQuery.isArray( data ) ) {
    4121                                         queue = jQuery._data( elem, type, jQuery.makeArray( data ) );
     4047                                        queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
    41224048                                } else {
    41234049                                        queue.push( data );
     
    41534079                        }
    41544080
    4155                         // clear up the last queue stop function
     4081                        // Clear up the last queue stop function
    41564082                        delete hooks.stop;
    41574083                        fn.call( elem, next, hooks );
     
    41634089        },
    41644090
    4165         // not intended for public consumption - generates a queueHooks object,
    4166         // or returns the current one
     4091        // Not public - generate a queueHooks object, or return the current one
    41674092        _queueHooks: function( elem, type ) {
    41684093                var key = type + "queueHooks";
    4169                 return jQuery._data( elem, key ) || jQuery._data( elem, key, {
     4094                return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
    41704095                        empty: jQuery.Callbacks( "once memory" ).add( function() {
    4171                                 jQuery._removeData( elem, type + "queue" );
    4172                                 jQuery._removeData( elem, key );
     4096                                dataPriv.remove( elem, [ type + "queue", key ] );
    41734097                        } )
    41744098                } );
     
    41954119                                var queue = jQuery.queue( this, type, data );
    41964120
    4197                                 // ensure a hooks for this queue
     4121                                // Ensure a hooks for this queue
    41984122                                jQuery._queueHooks( this, type );
    41994123
     
    42334157
    42344158                while ( i-- ) {
    4235                         tmp = jQuery._data( elements[ i ], type + "queueHooks" );
     4159                        tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
    42364160                        if ( tmp && tmp.empty ) {
    42374161                                count++;
     
    42434167        }
    42444168} );
    4245 
    4246 
    4247 ( function() {
    4248         var shrinkWrapBlocksVal;
    4249 
    4250         support.shrinkWrapBlocks = function() {
    4251                 if ( shrinkWrapBlocksVal != null ) {
    4252                         return shrinkWrapBlocksVal;
    4253                 }
    4254 
    4255                 // Will be changed later if needed.
    4256                 shrinkWrapBlocksVal = false;
    4257 
    4258                 // Minified: var b,c,d
    4259                 var div, body, container;
    4260 
    4261                 body = document.getElementsByTagName( "body" )[ 0 ];
    4262                 if ( !body || !body.style ) {
    4263 
    4264                         // Test fired too early or in an unsupported environment, exit.
    4265                         return;
    4266                 }
    4267 
    4268                 // Setup
    4269                 div = document.createElement( "div" );
    4270                 container = document.createElement( "div" );
    4271                 container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px";
    4272                 body.appendChild( container ).appendChild( div );
    4273 
    4274                 // Support: IE6
    4275                 // Check if elements with layout shrink-wrap their children
    4276                 if ( typeof div.style.zoom !== "undefined" ) {
    4277 
    4278                         // Reset CSS: box-sizing; display; margin; border
    4279                         div.style.cssText =
    4280 
    4281                                 // Support: Firefox<29, Android 2.3
    4282                                 // Vendor-prefix box-sizing
    4283                                 "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" +
    4284                                 "box-sizing:content-box;display:block;margin:0;border:0;" +
    4285                                 "padding:1px;width:1px;zoom:1";
    4286                         div.appendChild( document.createElement( "div" ) ).style.width = "5px";
    4287                         shrinkWrapBlocksVal = div.offsetWidth !== 3;
    4288                 }
    4289 
    4290                 body.removeChild( container );
    4291 
    4292                 return shrinkWrapBlocksVal;
    4293         };
    4294 
    4295 } )();
    42964169var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
    42974170
     
    43694242        return adjusted;
    43704243}
    4371 
    4372 
    4373 // Multifunctional method to get and set values of a collection
    4374 // The value/s can optionally be executed if it's a function
    4375 var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
    4376         var i = 0,
    4377                 length = elems.length,
    4378                 bulk = key == null;
    4379 
    4380         // Sets many values
    4381         if ( jQuery.type( key ) === "object" ) {
    4382                 chainable = true;
    4383                 for ( i in key ) {
    4384                         access( elems, fn, i, key[ i ], true, emptyGet, raw );
    4385                 }
    4386 
    4387         // Sets one value
    4388         } else if ( value !== undefined ) {
    4389                 chainable = true;
    4390 
    4391                 if ( !jQuery.isFunction( value ) ) {
    4392                         raw = true;
    4393                 }
    4394 
    4395                 if ( bulk ) {
    4396 
    4397                         // Bulk operations run against the entire set
    4398                         if ( raw ) {
    4399                                 fn.call( elems, value );
    4400                                 fn = null;
    4401 
    4402                         // ...except when executing function values
    4403                         } else {
    4404                                 bulk = fn;
    4405                                 fn = function( elem, key, value ) {
    4406                                         return bulk.call( jQuery( elem ), value );
    4407                                 };
    4408                         }
    4409                 }
    4410 
    4411                 if ( fn ) {
    4412                         for ( ; i < length; i++ ) {
    4413                                 fn(
    4414                                         elems[ i ],
    4415                                         key,
    4416                                         raw ? value : value.call( elems[ i ], i, fn( elems[ i ], key ) )
    4417                                 );
    4418                         }
    4419                 }
    4420         }
    4421 
    4422         return chainable ?
    4423                 elems :
    4424 
    4425                 // Gets
    4426                 bulk ?
    4427                         fn.call( elems ) :
    4428                         length ? fn( elems[ 0 ], key ) : emptyGet;
    4429 };
    44304244var rcheckableType = ( /^(?:checkbox|radio)$/i );
    44314245
     
    44344248var rscriptType = ( /^$|\/(?:java|ecma)script/i );
    44354249
    4436 var rleadingWhitespace = ( /^\s+/ );
    4437 
    4438 var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|" +
    4439                 "details|dialog|figcaption|figure|footer|header|hgroup|main|" +
    4440                 "mark|meter|nav|output|picture|progress|section|summary|template|time|video";
    4441 
    4442 
    4443 
    4444 function createSafeFragment( document ) {
    4445         var list = nodeNames.split( "|" ),
    4446                 safeFrag = document.createDocumentFragment();
    4447 
    4448         if ( safeFrag.createElement ) {
    4449                 while ( list.length ) {
    4450                         safeFrag.createElement(
    4451                                 list.pop()
    4452                         );
    4453                 }
    4454         }
    4455         return safeFrag;
    4456 }
    4457 
    4458 
    4459 ( function() {
    4460         var div = document.createElement( "div" ),
    4461                 fragment = document.createDocumentFragment(),
    4462                 input = document.createElement( "input" );
    4463 
    4464         // Setup
    4465         div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
    4466 
    4467         // IE strips leading whitespace when .innerHTML is used
    4468         support.leadingWhitespace = div.firstChild.nodeType === 3;
    4469 
    4470         // Make sure that tbody elements aren't automatically inserted
    4471         // IE will insert them into empty tables
    4472         support.tbody = !div.getElementsByTagName( "tbody" ).length;
    4473 
    4474         // Make sure that link elements get serialized correctly by innerHTML
    4475         // This requires a wrapper element in IE
    4476         support.htmlSerialize = !!div.getElementsByTagName( "link" ).length;
    4477 
    4478         // Makes sure cloning an html5 element does not cause problems
    4479         // Where outerHTML is undefined, this still works
    4480         support.html5Clone =
    4481                 document.createElement( "nav" ).cloneNode( true ).outerHTML !== "<:nav></:nav>";
    4482 
    4483         // Check if a disconnected checkbox will retain its checked
    4484         // value of true after appended to the DOM (IE6/7)
    4485         input.type = "checkbox";
    4486         input.checked = true;
    4487         fragment.appendChild( input );
    4488         support.appendChecked = input.checked;
    4489 
    4490         // Make sure textarea (and checkbox) defaultValue is properly cloned
    4491         // Support: IE6-IE11+
    4492         div.innerHTML = "<textarea>x</textarea>";
    4493         support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
    4494 
    4495         // #11217 - WebKit loses check when the name is after the checked attribute
    4496         fragment.appendChild( div );
    4497 
    4498         // Support: Windows Web Apps (WWA)
    4499         // `name` and `type` must use .setAttribute for WWA (#14901)
    4500         input = document.createElement( "input" );
    4501         input.setAttribute( "type", "radio" );
    4502         input.setAttribute( "checked", "checked" );
    4503         input.setAttribute( "name", "t" );
    4504 
    4505         div.appendChild( input );
    4506 
    4507         // Support: Safari 5.1, iOS 5.1, Android 4.x, Android 2.3
    4508         // old WebKit doesn't clone checked state correctly in fragments
    4509         support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
    4510 
    4511         // Support: IE<9
    4512         // Cloned elements keep attachEvent handlers, we use addEventListener on IE9+
    4513         support.noCloneEvent = !!div.addEventListener;
    4514 
    4515         // Support: IE<9
    4516         // Since attributes and properties are the same in IE,
    4517         // cleanData must set properties to undefined rather than use removeAttribute
    4518         div[ jQuery.expando ] = 1;
    4519         support.attributes = !div.getAttribute( jQuery.expando );
    4520 } )();
    45214250
    45224251
    45234252// We have to close these tags to support XHTML (#13200)
    45244253var wrapMap = {
     4254
     4255        // Support: IE9
    45254256        option: [ 1, "<select multiple='multiple'>", "</select>" ],
    4526         legend: [ 1, "<fieldset>", "</fieldset>" ],
    4527         area: [ 1, "<map>", "</map>" ],
    4528 
    4529         // Support: IE8
    4530         param: [ 1, "<object>", "</object>" ],
     4257
     4258        // XHTML parsers do not magically insert elements in the
     4259        // same way that tag soup parsers do. So we cannot shorten
     4260        // this by omitting <tbody> or other required elements.
    45314261        thead: [ 1, "<table>", "</table>" ],
     4262        col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
    45324263        tr: [ 2, "<table><tbody>", "</tbody></table>" ],
    4533         col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
    45344264        td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
    45354265
    4536         // IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
    4537         // unless wrapped in a div with non-breaking characters in front of it.
    4538         _default: support.htmlSerialize ? [ 0, "", "" ] : [ 1, "X<div>", "</div>" ]
     4266        _default: [ 0, "", "" ]
    45394267};
    45404268
    4541 // Support: IE8-IE9
     4269// Support: IE9
    45424270wrapMap.optgroup = wrapMap.option;
    45434271
     
    45474275
    45484276function getAll( context, tag ) {
    4549         var elems, elem,
    4550                 i = 0,
    4551                 found = typeof context.getElementsByTagName !== "undefined" ?
     4277
     4278        // Support: IE9-11+
     4279        // Use typeof to avoid zero-argument method invocation on host objects (#15151)
     4280        var ret = typeof context.getElementsByTagName !== "undefined" ?
    45524281                        context.getElementsByTagName( tag || "*" ) :
    45534282                        typeof context.querySelectorAll !== "undefined" ?
    45544283                                context.querySelectorAll( tag || "*" ) :
    4555                                 undefined;
    4556 
    4557         if ( !found ) {
    4558                 for ( found = [], elems = context.childNodes || context;
    4559                         ( elem = elems[ i ] ) != null;
    4560                         i++
    4561                 ) {
    4562                         if ( !tag || jQuery.nodeName( elem, tag ) ) {
    4563                                 found.push( elem );
    4564                         } else {
    4565                                 jQuery.merge( found, getAll( elem, tag ) );
    4566                         }
    4567                 }
    4568         }
     4284                        [];
    45694285
    45704286        return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
    4571                 jQuery.merge( [ context ], found ) :
    4572                 found;
     4287                jQuery.merge( [ context ], ret ) :
     4288                ret;
    45734289}
    45744290
     
    45764292// Mark scripts as having already been evaluated
    45774293function setGlobalEval( elems, refElements ) {
    4578         var elem,
    4579                 i = 0;
    4580         for ( ; ( elem = elems[ i ] ) != null; i++ ) {
    4581                 jQuery._data(
    4582                         elem,
     4294        var i = 0,
     4295                l = elems.length;
     4296
     4297        for ( ; i < l; i++ ) {
     4298                dataPriv.set(
     4299                        elems[ i ],
    45834300                        "globalEval",
    4584                         !refElements || jQuery._data( refElements[ i ], "globalEval" )
     4301                        !refElements || dataPriv.get( refElements[ i ], "globalEval" )
    45854302                );
    45864303        }
     
    45884305
    45894306
    4590 var rhtml = /<|&#?\w+;/,
    4591         rtbody = /<tbody/i;
    4592 
    4593 function fixDefaultChecked( elem ) {
    4594         if ( rcheckableType.test( elem.type ) ) {
    4595                 elem.defaultChecked = elem.checked;
    4596         }
    4597 }
     4307var rhtml = /<|&#?\w+;/;
    45984308
    45994309function buildFragment( elems, context, scripts, selection, ignored ) {
    4600         var j, elem, contains,
    4601                 tmp, tag, tbody, wrap,
    4602                 l = elems.length,
    4603 
    4604                 // Ensure a safe fragment
    4605                 safe = createSafeFragment( context ),
    4606 
     4310        var elem, tmp, tag, wrap, contains, j,
     4311                fragment = context.createDocumentFragment(),
    46074312                nodes = [],
    4608                 i = 0;
     4313                i = 0,
     4314                l = elems.length;
    46094315
    46104316        for ( ; i < l; i++ ) {
     
    46154321                        // Add nodes directly
    46164322                        if ( jQuery.type( elem ) === "object" ) {
     4323
     4324                                // Support: Android<4.1, PhantomJS<2
     4325                                // push.apply(_, arraylike) throws on ancient WebKit
    46174326                                jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
    46184327
     
    46234332                        // Convert html into DOM nodes
    46244333                        } else {
    4625                                 tmp = tmp || safe.appendChild( context.createElement( "div" ) );
     4334                                tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
    46264335
    46274336                                // Deserialize a standard representation
    46284337                                tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
    46294338                                wrap = wrapMap[ tag ] || wrapMap._default;
    4630 
    46314339                                tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
    46324340
     
    46374345                                }
    46384346
    4639                                 // Manually add leading whitespace removed by IE
    4640                                 if ( !support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
    4641                                         nodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[ 0 ] ) );
    4642                                 }
    4643 
    4644                                 // Remove IE's autoinserted <tbody> from table fragments
    4645                                 if ( !support.tbody ) {
    4646 
    4647                                         // String was a <table>, *may* have spurious <tbody>
    4648                                         elem = tag === "table" && !rtbody.test( elem ) ?
    4649                                                 tmp.firstChild :
    4650 
    4651                                                 // String was a bare <thead> or <tfoot>
    4652                                                 wrap[ 1 ] === "<table>" && !rtbody.test( elem ) ?
    4653                                                         tmp :
    4654                                                         0;
    4655 
    4656                                         j = elem && elem.childNodes.length;
    4657                                         while ( j-- ) {
    4658                                                 if ( jQuery.nodeName( ( tbody = elem.childNodes[ j ] ), "tbody" ) &&
    4659                                                         !tbody.childNodes.length ) {
    4660 
    4661                                                         elem.removeChild( tbody );
    4662                                                 }
    4663                                         }
    4664                                 }
    4665 
     4347                                // Support: Android<4.1, PhantomJS<2
     4348                                // push.apply(_, arraylike) throws on ancient WebKit
    46664349                                jQuery.merge( nodes, tmp.childNodes );
    46674350
    4668                                 // Fix #12392 for WebKit and IE > 9
     4351                                // Remember the top-level container
     4352                                tmp = fragment.firstChild;
     4353
     4354                                // Ensure the created nodes are orphaned (#12392)
    46694355                                tmp.textContent = "";
    4670 
    4671                                 // Fix #12392 for oldIE
    4672                                 while ( tmp.firstChild ) {
    4673                                         tmp.removeChild( tmp.firstChild );
    4674                                 }
    4675 
    4676                                 // Remember the top-level container for proper cleanup
    4677                                 tmp = safe.lastChild;
    4678                         }
    4679                 }
    4680         }
    4681 
    4682         // Fix #11356: Clear elements from fragment
    4683         if ( tmp ) {
    4684                 safe.removeChild( tmp );
    4685         }
    4686 
    4687         // Reset defaultChecked for any radios and checkboxes
    4688         // about to be appended to the DOM in IE 6/7 (#8060)
    4689         if ( !support.appendChecked ) {
    4690                 jQuery.grep( getAll( nodes, "input" ), fixDefaultChecked );
    4691         }
     4356                        }
     4357                }
     4358        }
     4359
     4360        // Remove wrapper from fragment
     4361        fragment.textContent = "";
    46924362
    46934363        i = 0;
     
    46994369                                ignored.push( elem );
    47004370                        }
    4701 
    47024371                        continue;
    47034372                }
     
    47064375
    47074376                // Append to fragment
    4708                 tmp = getAll( safe.appendChild( elem ), "script" );
     4377                tmp = getAll( fragment.appendChild( elem ), "script" );
    47094378
    47104379                // Preserve script evaluation history
     
    47244393        }
    47254394
    4726         tmp = null;
    4727 
    4728         return safe;
     4395        return fragment;
    47294396}
    47304397
    47314398
    47324399( function() {
    4733         var i, eventName,
    4734                 div = document.createElement( "div" );
    4735 
    4736         // Support: IE<9 (lack submit/change bubble), Firefox (lack focus(in | out) events)
    4737         for ( i in { submit: true, change: true, focusin: true } ) {
    4738                 eventName = "on" + i;
    4739 
    4740                 if ( !( support[ i ] = eventName in window ) ) {
    4741 
    4742                         // Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP)
    4743                         div.setAttribute( eventName, "t" );
    4744                         support[ i ] = div.attributes[ eventName ].expando === false;
    4745                 }
    4746         }
    4747 
    4748         // Null elements to avoid leaks in IE.
    4749         div = null;
     4400        var fragment = document.createDocumentFragment(),
     4401                div = fragment.appendChild( document.createElement( "div" ) ),
     4402                input = document.createElement( "input" );
     4403
     4404        // Support: Android 4.0-4.3, Safari<=5.1
     4405        // Check state lost if the name is set (#11217)
     4406        // Support: Windows Web Apps (WWA)
     4407        // `name` and `type` must use .setAttribute for WWA (#14901)
     4408        input.setAttribute( "type", "radio" );
     4409        input.setAttribute( "checked", "checked" );
     4410        input.setAttribute( "name", "t" );
     4411
     4412        div.appendChild( input );
     4413
     4414        // Support: Safari<=5.1, Android<4.2
     4415        // Older WebKit doesn't clone checked state correctly in fragments
     4416        support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
     4417
     4418        // Support: IE<=11+
     4419        // Make sure textarea (and checkbox) defaultValue is properly cloned
     4420        div.innerHTML = "<textarea>x</textarea>";
     4421        support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
    47504422} )();
    47514423
    47524424
    4753 var rformElems = /^(?:input|select|textarea)$/i,
     4425var
    47544426        rkeyEvent = /^key/,
    47554427        rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
    4756         rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
    47574428        rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
    47584429
     
    48434514
    48444515        add: function( elem, types, handler, data, selector ) {
    4845                 var tmp, events, t, handleObjIn,
    4846                         special, eventHandle, handleObj,
    4847                         handlers, type, namespaces, origType,
    4848                         elemData = jQuery._data( elem );
     4516
     4517                var handleObjIn, eventHandle, tmp,
     4518                        events, t, handleObj,
     4519                        special, handlers, type, namespaces, origType,
     4520                        elemData = dataPriv.get( elem );
    48494521
    48504522                // Don't attach events to noData or text/comment nodes (but allow plain objects)
     
    48744546                                // Discard the second event of a jQuery.event.trigger() and
    48754547                                // when an event is called after a page has unloaded
    4876                                 return typeof jQuery !== "undefined" &&
    4877                                         ( !e || jQuery.event.triggered !== e.type ) ?
    4878                                         jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
    4879                                         undefined;
     4548                                return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
     4549                                        jQuery.event.dispatch.apply( elem, arguments ) : undefined;
    48804550                        };
    4881 
    4882                         // Add elem as a property of the handle fn to prevent a memory leak
    4883                         // with IE non-native events
    4884                         eventHandle.elem = elem;
    48854551                }
    48864552
     
    49244590                                handlers.delegateCount = 0;
    49254591
    4926                                 // Only use addEventListener/attachEvent if the special events handler returns false
     4592                                // Only use addEventListener if the special events handler returns false
    49274593                                if ( !special.setup ||
    49284594                                        special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
    49294595
    4930                                         // Bind the global event handler to the element
    49314596                                        if ( elem.addEventListener ) {
    4932                                                 elem.addEventListener( type, eventHandle, false );
    4933 
    4934                                         } else if ( elem.attachEvent ) {
    4935                                                 elem.attachEvent( "on" + type, eventHandle );
     4597                                                elem.addEventListener( type, eventHandle );
    49364598                                        }
    49374599                                }
     
    49574619                }
    49584620
    4959                 // Nullify elem to prevent memory leaks in IE
    4960                 elem = null;
    49614621        },
    49624622
    49634623        // Detach an event or set of events from an element
    49644624        remove: function( elem, types, handler, selector, mappedTypes ) {
    4965                 var j, handleObj, tmp,
    4966                         origCount, t, events,
    4967                         special, handlers, type,
    4968                         namespaces, origType,
    4969                         elemData = jQuery.hasData( elem ) && jQuery._data( elem );
     4625
     4626                var j, origCount, tmp,
     4627                        events, t, handleObj,
     4628                        special, handlers, type, namespaces, origType,
     4629                        elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
    49704630
    49714631                if ( !elemData || !( events = elemData.events ) ) {
     
    50294689                }
    50304690
    5031                 // Remove the expando if it's no longer used
     4691                // Remove data and the expando if it's no longer used
    50324692                if ( jQuery.isEmptyObject( events ) ) {
    5033                         delete elemData.handle;
    5034 
    5035                         // removeData also checks for emptiness and clears the expando if empty
    5036                         // so use it instead of delete
    5037                         jQuery._removeData( elem, "events" );
    5038                 }
    5039         },
    5040 
    5041         trigger: function( event, data, elem, onlyHandlers ) {
    5042                 var handle, ontype, cur,
    5043                         bubbleType, special, tmp, i,
    5044                         eventPath = [ elem || document ],
    5045                         type = hasOwn.call( event, "type" ) ? event.type : event,
    5046                         namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
    5047 
    5048                 cur = tmp = elem = elem || document;
    5049 
    5050                 // Don't do events on text and comment nodes
    5051                 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
    5052                         return;
    5053                 }
    5054 
    5055                 // focus/blur morphs to focusin/out; ensure we're not firing them right now
    5056                 if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
    5057                         return;
    5058                 }
    5059 
    5060                 if ( type.indexOf( "." ) > -1 ) {
    5061 
    5062                         // Namespaced trigger; create a regexp to match event type in handle()
    5063                         namespaces = type.split( "." );
    5064                         type = namespaces.shift();
    5065                         namespaces.sort();
    5066                 }
    5067                 ontype = type.indexOf( ":" ) < 0 && "on" + type;
    5068 
    5069                 // Caller can pass in a jQuery.Event object, Object, or just an event type string
    5070                 event = event[ jQuery.expando ] ?
    5071                         event :
    5072                         new jQuery.Event( type, typeof event === "object" && event );
    5073 
    5074                 // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
    5075                 event.isTrigger = onlyHandlers ? 2 : 3;
    5076                 event.namespace = namespaces.join( "." );
    5077                 event.rnamespace = event.namespace ?
    5078                         new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
    5079                         null;
    5080 
    5081                 // Clean up the event in case it is being reused
    5082                 event.result = undefined;
    5083                 if ( !event.target ) {
    5084                         event.target = elem;
    5085                 }
    5086 
    5087                 // Clone any incoming data and prepend the event, creating the handler arg list
    5088                 data = data == null ?
    5089                         [ event ] :
    5090                         jQuery.makeArray( data, [ event ] );
    5091 
    5092                 // Allow special events to draw outside the lines
    5093                 special = jQuery.event.special[ type ] || {};
    5094                 if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
    5095                         return;
    5096                 }
    5097 
    5098                 // Determine event propagation path in advance, per W3C events spec (#9951)
    5099                 // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
    5100                 if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
    5101 
    5102                         bubbleType = special.delegateType || type;
    5103                         if ( !rfocusMorph.test( bubbleType + type ) ) {
    5104                                 cur = cur.parentNode;
    5105                         }
    5106                         for ( ; cur; cur = cur.parentNode ) {
    5107                                 eventPath.push( cur );
    5108                                 tmp = cur;
    5109                         }
    5110 
    5111                         // Only add window if we got to document (e.g., not plain obj or detached DOM)
    5112                         if ( tmp === ( elem.ownerDocument || document ) ) {
    5113                                 eventPath.push( tmp.defaultView || tmp.parentWindow || window );
    5114                         }
    5115                 }
    5116 
    5117                 // Fire handlers on the event path
    5118                 i = 0;
    5119                 while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
    5120 
    5121                         event.type = i > 1 ?
    5122                                 bubbleType :
    5123                                 special.bindType || type;
    5124 
    5125                         // jQuery handler
    5126                         handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] &&
    5127                                 jQuery._data( cur, "handle" );
    5128 
    5129                         if ( handle ) {
    5130                                 handle.apply( cur, data );
    5131                         }
    5132 
    5133                         // Native handler
    5134                         handle = ontype && cur[ ontype ];
    5135                         if ( handle && handle.apply && acceptData( cur ) ) {
    5136                                 event.result = handle.apply( cur, data );
    5137                                 if ( event.result === false ) {
    5138                                         event.preventDefault();
    5139                                 }
    5140                         }
    5141                 }
    5142                 event.type = type;
    5143 
    5144                 // If nobody prevented the default action, do it now
    5145                 if ( !onlyHandlers && !event.isDefaultPrevented() ) {
    5146 
    5147                         if (
    5148                                 ( !special._default ||
    5149                                  special._default.apply( eventPath.pop(), data ) === false
    5150                                 ) && acceptData( elem )
    5151                         ) {
    5152 
    5153                                 // Call a native DOM method on the target with the same name name as the event.
    5154                                 // Can't use an .isFunction() check here because IE6/7 fails that test.
    5155                                 // Don't do default actions on window, that's where global variables be (#6170)
    5156                                 if ( ontype && elem[ type ] && !jQuery.isWindow( elem ) ) {
    5157 
    5158                                         // Don't re-trigger an onFOO event when we call its FOO() method
    5159                                         tmp = elem[ ontype ];
    5160 
    5161                                         if ( tmp ) {
    5162                                                 elem[ ontype ] = null;
    5163                                         }
    5164 
    5165                                         // Prevent re-triggering of the same event, since we already bubbled it above
    5166                                         jQuery.event.triggered = type;
    5167                                         try {
    5168                                                 elem[ type ]();
    5169                                         } catch ( e ) {
    5170 
    5171                                                 // IE<9 dies on focus/blur to hidden element (#1486,#12518)
    5172                                                 // only reproducible on winXP IE8 native, not IE9 in IE8 mode
    5173                                         }
    5174                                         jQuery.event.triggered = undefined;
    5175 
    5176                                         if ( tmp ) {
    5177                                                 elem[ ontype ] = tmp;
    5178                                         }
    5179                                 }
    5180                         }
    5181                 }
    5182 
    5183                 return event.result;
     4693                        dataPriv.remove( elem, "handle events" );
     4694                }
    51844695        },
    51854696
     
    51924703                        handlerQueue = [],
    51934704                        args = slice.call( arguments ),
    5194                         handlers = ( jQuery._data( this, "events" ) || {} )[ event.type ] || [],
     4705                        handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [],
    51954706                        special = jQuery.event.special[ event.type ] || {};
    51964707
     
    52594770                        ( event.type !== "click" || isNaN( event.button ) || event.button < 1 ) ) {
    52604771
    5261                         /* jshint eqeqeq: false */
    5262                         for ( ; cur != this; cur = cur.parentNode || this ) {
    5263                                 /* jshint eqeqeq: true */
     4772                        for ( ; cur !== this; cur = cur.parentNode || this ) {
    52644773
    52654774                                // Don't check non-elements (#13208)
     
    52974806        },
    52984807
    5299         fix: function( event ) {
    5300                 if ( event[ jQuery.expando ] ) {
    5301                         return event;
    5302                 }
    5303 
    5304                 // Create a writable copy of the event object and normalize some properties
    5305                 var i, prop, copy,
    5306                         type = event.type,
    5307                         originalEvent = event,
    5308                         fixHook = this.fixHooks[ type ];
    5309 
    5310                 if ( !fixHook ) {
    5311                         this.fixHooks[ type ] = fixHook =
    5312                                 rmouseEvent.test( type ) ? this.mouseHooks :
    5313                                 rkeyEvent.test( type ) ? this.keyHooks :
    5314                                 {};
    5315                 }
    5316                 copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
    5317 
    5318                 event = new jQuery.Event( originalEvent );
    5319 
    5320                 i = copy.length;
    5321                 while ( i-- ) {
    5322                         prop = copy[ i ];
    5323                         event[ prop ] = originalEvent[ prop ];
    5324                 }
    5325 
    5326                 // Support: IE<9
    5327                 // Fix target property (#1925)
    5328                 if ( !event.target ) {
    5329                         event.target = originalEvent.srcElement || document;
    5330                 }
    5331 
    5332                 // Support: Safari 6-8+
    5333                 // Target should not be a text node (#504, #13143)
    5334                 if ( event.target.nodeType === 3 ) {
    5335                         event.target = event.target.parentNode;
    5336                 }
    5337 
    5338                 // Support: IE<9
    5339                 // For mouse/key events, metaKey==false if it's undefined (#3368, #11328)
    5340                 event.metaKey = !!event.metaKey;
    5341 
    5342                 return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
    5343         },
    5344 
    53454808        // Includes some event props shared by KeyEvent and MouseEvent
    53464809        props: ( "altKey bubbles cancelable ctrlKey currentTarget detail eventPhase " +
     
    53634826
    53644827        mouseHooks: {
    5365                 props: ( "button buttons clientX clientY fromElement offsetX offsetY " +
    5366                         "pageX pageY screenX screenY toElement" ).split( " " ),
     4828                props: ( "button buttons clientX clientY offsetX offsetY pageX pageY " +
     4829                        "screenX screenY toElement" ).split( " " ),
    53674830                filter: function( event, original ) {
    5368                         var body, eventDoc, doc,
    5369                                 button = original.button,
    5370                                 fromElement = original.fromElement;
     4831                        var eventDoc, doc, body,
     4832                                button = original.button;
    53714833
    53724834                        // Calculate pageX/Y if missing and clientX/Y available
     
    53844846                        }
    53854847
    5386                         // Add relatedTarget, if necessary
    5387                         if ( !event.relatedTarget && fromElement ) {
    5388                                 event.relatedTarget = fromElement === event.target ?
    5389                                         original.toElement :
    5390                                         fromElement;
    5391                         }
    5392 
    53934848                        // Add which for click: 1 === left; 2 === middle; 3 === right
    53944849                        // Note: button is not normalized, so don't use it
     
    54014856        },
    54024857
     4858        fix: function( event ) {
     4859                if ( event[ jQuery.expando ] ) {
     4860                        return event;
     4861                }
     4862
     4863                // Create a writable copy of the event object and normalize some properties
     4864                var i, prop, copy,
     4865                        type = event.type,
     4866                        originalEvent = event,
     4867                        fixHook = this.fixHooks[ type ];
     4868
     4869                if ( !fixHook ) {
     4870                        this.fixHooks[ type ] = fixHook =
     4871                                rmouseEvent.test( type ) ? this.mouseHooks :
     4872                                rkeyEvent.test( type ) ? this.keyHooks :
     4873                                {};
     4874                }
     4875                copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
     4876
     4877                event = new jQuery.Event( originalEvent );
     4878
     4879                i = copy.length;
     4880                while ( i-- ) {
     4881                        prop = copy[ i ];
     4882                        event[ prop ] = originalEvent[ prop ];
     4883                }
     4884
     4885                // Support: Cordova 2.5 (WebKit) (#13255)
     4886                // All events should have a target; Cordova deviceready doesn't
     4887                if ( !event.target ) {
     4888                        event.target = document;
     4889                }
     4890
     4891                // Support: Safari 6.0+, Chrome<28
     4892                // Target should not be a text node (#504, #13143)
     4893                if ( event.target.nodeType === 3 ) {
     4894                        event.target = event.target.parentNode;
     4895                }
     4896
     4897                return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
     4898        },
     4899
    54034900        special: {
    54044901                load: {
     
    54124909                        trigger: function() {
    54134910                                if ( this !== safeActiveElement() && this.focus ) {
    5414                                         try {
    5415                                                 this.focus();
    5416                                                 return false;
    5417                                         } catch ( e ) {
    5418 
    5419                                                 // Support: IE<9
    5420                                                 // If we error on focus to hidden element (#1486, #12518),
    5421                                                 // let .trigger() run the handlers
    5422                                         }
     4911                                        this.focus();
     4912                                        return false;
    54234913                                }
    54244914                        },
     
    54384928                        // For checkbox, fire native event so checked state will be right
    54394929                        trigger: function() {
    5440                                 if ( jQuery.nodeName( this, "input" ) && this.type === "checkbox" && this.click ) {
     4930                                if ( this.type === "checkbox" && this.click && jQuery.nodeName( this, "input" ) ) {
    54414931                                        this.click();
    54424932                                        return false;
     
    54604950                        }
    54614951                }
    5462         },
    5463 
    5464         // Piggyback on a donor event to simulate a different one
    5465         simulate: function( type, elem, event ) {
    5466                 var e = jQuery.extend(
    5467                         new jQuery.Event(),
    5468                         event,
    5469                         {
    5470                                 type: type,
    5471                                 isSimulated: true
    5472 
    5473                                 // Previously, `originalEvent: {}` was set here, so stopPropagation call
    5474                                 // would not be triggered on donor event, since in our own
    5475                                 // jQuery.event.stopPropagation function we had a check for existence of
    5476                                 // originalEvent.stopPropagation method, so, consequently it would be a noop.
    5477                                 //
    5478                                 // Guard for simulated events was moved to jQuery.event.stopPropagation function
    5479                                 // since `originalEvent` should point to the original event for the
    5480                                 // constancy with other events and for more focused logic
    5481                         }
    5482                 );
    5483 
    5484                 jQuery.event.trigger( e, null, elem );
    5485 
    5486                 if ( e.isDefaultPrevented() ) {
    5487                         event.preventDefault();
    5488                 }
    54894952        }
    54904953};
    54914954
    5492 jQuery.removeEvent = document.removeEventListener ?
    5493         function( elem, type, handle ) {
    5494 
    5495                 // This "if" is needed for plain objects
    5496                 if ( elem.removeEventListener ) {
    5497                         elem.removeEventListener( type, handle );
    5498                 }
    5499         } :
    5500         function( elem, type, handle ) {
    5501                 var name = "on" + type;
    5502 
    5503                 if ( elem.detachEvent ) {
    5504 
    5505                         // #8545, #7054, preventing memory leaks for custom events in IE6-8
    5506                         // detachEvent needed property on element, by name of that event,
    5507                         // to properly expose it to GC
    5508                         if ( typeof elem[ name ] === "undefined" ) {
    5509                                 elem[ name ] = null;
    5510                         }
    5511 
    5512                         elem.detachEvent( name, handle );
    5513                 }
    5514         };
     4955jQuery.removeEvent = function( elem, type, handle ) {
     4956
     4957        // This "if" is needed for plain objects
     4958        if ( elem.removeEventListener ) {
     4959                elem.removeEventListener( type, handle );
     4960        }
     4961};
    55154962
    55164963jQuery.Event = function( src, props ) {
     
    55314978                                src.defaultPrevented === undefined &&
    55324979
    5533                                 // Support: IE < 9, Android < 4.0
     4980                                // Support: Android<4.0
    55344981                                src.returnValue === false ?
    55354982                        returnTrue :
     
    55605007        isPropagationStopped: returnFalse,
    55615008        isImmediatePropagationStopped: returnFalse,
     5009        isSimulated: false,
    55625010
    55635011        preventDefault: function() {
     
    55655013
    55665014                this.isDefaultPrevented = returnTrue;
    5567                 if ( !e ) {
    5568                         return;
    5569                 }
    5570 
    5571                 // If preventDefault exists, run it on the original event
    5572                 if ( e.preventDefault ) {
     5015
     5016                if ( e && !this.isSimulated ) {
    55735017                        e.preventDefault();
    5574 
    5575                 // Support: IE
    5576                 // Otherwise set the returnValue property of the original event to false
    5577                 } else {
    5578                         e.returnValue = false;
    55795018                }
    55805019        },
     
    55845023                this.isPropagationStopped = returnTrue;
    55855024
    5586                 if ( !e || this.isSimulated ) {
    5587                         return;
    5588                 }
    5589 
    5590                 // If stopPropagation exists, run it on the original event
    5591                 if ( e.stopPropagation ) {
     5025                if ( e && !this.isSimulated ) {
    55925026                        e.stopPropagation();
    55935027                }
    5594 
    5595                 // Support: IE
    5596                 // Set the cancelBubble property of the original event to true
    5597                 e.cancelBubble = true;
    55985028        },
    55995029        stopImmediatePropagation: function() {
     
    56025032                this.isImmediatePropagationStopped = returnTrue;
    56035033
    5604                 if ( e && e.stopImmediatePropagation ) {
     5034                if ( e && !this.isSimulated ) {
    56055035                        e.stopImmediatePropagation();
    56065036                }
     
    56465076} );
    56475077
    5648 // IE submit delegation
    5649 if ( !support.submit ) {
    5650 
    5651         jQuery.event.special.submit = {
    5652                 setup: function() {
    5653 
    5654                         // Only need this for delegated form submit events
    5655                         if ( jQuery.nodeName( this, "form" ) ) {
    5656                                 return false;
    5657                         }
    5658 
    5659                         // Lazy-add a submit handler when a descendant form may potentially be submitted
    5660                         jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
    5661 
    5662                                 // Node name check avoids a VML-related crash in IE (#9807)
    5663                                 var elem = e.target,
    5664                                         form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ?
    5665 
    5666                                                 // Support: IE <=8
    5667                                                 // We use jQuery.prop instead of elem.form
    5668                                                 // to allow fixing the IE8 delegated submit issue (gh-2332)
    5669                                                 // by 3rd party polyfills/workarounds.
    5670                                                 jQuery.prop( elem, "form" ) :
    5671                                                 undefined;
    5672 
    5673                                 if ( form && !jQuery._data( form, "submit" ) ) {
    5674                                         jQuery.event.add( form, "submit._submit", function( event ) {
    5675                                                 event._submitBubble = true;
    5676                                         } );
    5677                                         jQuery._data( form, "submit", true );
    5678                                 }
    5679                         } );
    5680 
    5681                         // return undefined since we don't need an event listener
    5682                 },
    5683 
    5684                 postDispatch: function( event ) {
    5685 
    5686                         // If form was submitted by the user, bubble the event up the tree
    5687                         if ( event._submitBubble ) {
    5688                                 delete event._submitBubble;
    5689                                 if ( this.parentNode && !event.isTrigger ) {
    5690                                         jQuery.event.simulate( "submit", this.parentNode, event );
    5691                                 }
    5692                         }
    5693                 },
    5694 
    5695                 teardown: function() {
    5696 
    5697                         // Only need this for delegated form submit events
    5698                         if ( jQuery.nodeName( this, "form" ) ) {
    5699                                 return false;
    5700                         }
    5701 
    5702                         // Remove delegated handlers; cleanData eventually reaps submit handlers attached above
    5703                         jQuery.event.remove( this, "._submit" );
    5704                 }
    5705         };
    5706 }
    5707 
    5708 // IE change delegation and checkbox/radio fix
    5709 if ( !support.change ) {
    5710 
    5711         jQuery.event.special.change = {
    5712 
    5713                 setup: function() {
    5714 
    5715                         if ( rformElems.test( this.nodeName ) ) {
    5716 
    5717                                 // IE doesn't fire change on a check/radio until blur; trigger it on click
    5718                                 // after a propertychange. Eat the blur-change in special.change.handle.
    5719                                 // This still fires onchange a second time for check/radio after blur.
    5720                                 if ( this.type === "checkbox" || this.type === "radio" ) {
    5721                                         jQuery.event.add( this, "propertychange._change", function( event ) {
    5722                                                 if ( event.originalEvent.propertyName === "checked" ) {
    5723                                                         this._justChanged = true;
    5724                                                 }
    5725                                         } );
    5726                                         jQuery.event.add( this, "click._change", function( event ) {
    5727                                                 if ( this._justChanged && !event.isTrigger ) {
    5728                                                         this._justChanged = false;
    5729                                                 }
    5730 
    5731                                                 // Allow triggered, simulated change events (#11500)
    5732                                                 jQuery.event.simulate( "change", this, event );
    5733                                         } );
    5734                                 }
    5735                                 return false;
    5736                         }
    5737 
    5738                         // Delegated event; lazy-add a change handler on descendant inputs
    5739                         jQuery.event.add( this, "beforeactivate._change", function( e ) {
    5740                                 var elem = e.target;
    5741 
    5742                                 if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "change" ) ) {
    5743                                         jQuery.event.add( elem, "change._change", function( event ) {
    5744                                                 if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
    5745                                                         jQuery.event.simulate( "change", this.parentNode, event );
    5746                                                 }
    5747                                         } );
    5748                                         jQuery._data( elem, "change", true );
    5749                                 }
    5750                         } );
    5751                 },
    5752 
    5753                 handle: function( event ) {
    5754                         var elem = event.target;
    5755 
    5756                         // Swallow native change events from checkbox/radio, we already triggered them above
    5757                         if ( this !== elem || event.isSimulated || event.isTrigger ||
    5758                                 ( elem.type !== "radio" && elem.type !== "checkbox" ) ) {
    5759 
    5760                                 return event.handleObj.handler.apply( this, arguments );
    5761                         }
    5762                 },
    5763 
    5764                 teardown: function() {
    5765                         jQuery.event.remove( this, "._change" );
    5766 
    5767                         return !rformElems.test( this.nodeName );
    5768                 }
    5769         };
    5770 }
    5771 
    5772 // Support: Firefox
    5773 // Firefox doesn't have focus(in | out) events
    5774 // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
    5775 //
    5776 // Support: Chrome, Safari
    5777 // focus(in | out) events fire after focus & blur events,
    5778 // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
    5779 // Related ticket - https://code.google.com/p/chromium/issues/detail?id=449857
    5780 if ( !support.focusin ) {
    5781         jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {
    5782 
    5783                 // Attach a single capturing handler on the document while someone wants focusin/focusout
    5784                 var handler = function( event ) {
    5785                         jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
    5786                 };
    5787 
    5788                 jQuery.event.special[ fix ] = {
    5789                         setup: function() {
    5790                                 var doc = this.ownerDocument || this,
    5791                                         attaches = jQuery._data( doc, fix );
    5792 
    5793                                 if ( !attaches ) {
    5794                                         doc.addEventListener( orig, handler, true );
    5795                                 }
    5796                                 jQuery._data( doc, fix, ( attaches || 0 ) + 1 );
    5797                         },
    5798                         teardown: function() {
    5799                                 var doc = this.ownerDocument || this,
    5800                                         attaches = jQuery._data( doc, fix ) - 1;
    5801 
    5802                                 if ( !attaches ) {
    5803                                         doc.removeEventListener( orig, handler, true );
    5804                                         jQuery._removeData( doc, fix );
    5805                                 } else {
    5806                                         jQuery._data( doc, fix, attaches );
    5807                                 }
    5808                         }
    5809                 };
    5810         } );
    5811 }
    5812 
    58135078jQuery.fn.extend( {
    5814 
    58155079        on: function( types, selector, data, fn ) {
    58165080                return on( this, types, selector, data, fn );
     
    58545118                        jQuery.event.remove( this, types, fn, selector );
    58555119                } );
    5856         },
    5857 
    5858         trigger: function( type, data ) {
    5859                 return this.each( function() {
    5860                         jQuery.event.trigger( type, data, this );
    5861                 } );
    5862         },
    5863         triggerHandler: function( type, data ) {
    5864                 var elem = this[ 0 ];
    5865                 if ( elem ) {
    5866                         return jQuery.event.trigger( type, data, elem, true );
    5867                 }
    58685120        }
    58695121} );
    58705122
    58715123
    5872 var rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g,
    5873         rnoshimcache = new RegExp( "<(?:" + nodeNames + ")[\\s/>]", "i" ),
     5124var
    58745125        rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi,
    58755126
     
    58825133        rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
    58835134        rscriptTypeMasked = /^true\/(.*)/,
    5884         rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,
    5885         safeFragment = createSafeFragment( document ),
    5886         fragmentDiv = safeFragment.appendChild( document.createElement( "div" ) );
    5887 
    5888 // Support: IE<8
     5135        rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
     5136
    58895137// Manipulating tables requires a tbody
    58905138function manipulationTarget( elem, content ) {
     
    58995147// Replace/restore the type attribute of script elements for safe DOM manipulation
    59005148function disableScript( elem ) {
    5901         elem.type = ( jQuery.find.attr( elem, "type" ) !== null ) + "/" + elem.type;
     5149        elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
    59025150        return elem;
    59035151}
    59045152function restoreScript( elem ) {
    59055153        var match = rscriptTypeMasked.exec( elem.type );
     5154
    59065155        if ( match ) {
    59075156                elem.type = match[ 1 ];
     
    59095158                elem.removeAttribute( "type" );
    59105159        }
     5160
    59115161        return elem;
    59125162}
    59135163
    59145164function cloneCopyEvent( src, dest ) {
    5915         if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
    5916                 return;
    5917         }
    5918 
    5919         var type, i, l,
    5920                 oldData = jQuery._data( src ),
    5921                 curData = jQuery._data( dest, oldData ),
    5922                 events = oldData.events;
    5923 
    5924         if ( events ) {
    5925                 delete curData.handle;
    5926                 curData.events = {};
    5927 
    5928                 for ( type in events ) {
    5929                         for ( i = 0, l = events[ type ].length; i < l; i++ ) {
    5930                                 jQuery.event.add( dest, type, events[ type ][ i ] );
    5931                         }
    5932                 }
    5933         }
    5934 
    5935         // make the cloned public data object a copy from the original
    5936         if ( curData.data ) {
    5937                 curData.data = jQuery.extend( {}, curData.data );
    5938         }
    5939 }
    5940 
    5941 function fixCloneNodeIssues( src, dest ) {
    5942         var nodeName, e, data;
    5943 
    5944         // We do not need to do anything for non-Elements
     5165        var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
     5166
    59455167        if ( dest.nodeType !== 1 ) {
    59465168                return;
    59475169        }
    59485170
    5949         nodeName = dest.nodeName.toLowerCase();
    5950 
    5951         // IE6-8 copies events bound via attachEvent when using cloneNode.
    5952         if ( !support.noCloneEvent && dest[ jQuery.expando ] ) {
    5953                 data = jQuery._data( dest );
    5954 
    5955                 for ( e in data.events ) {
    5956                         jQuery.removeEvent( dest, e, data.handle );
    5957                 }
    5958 
    5959                 // Event data gets referenced instead of copied if the expando gets copied too
    5960                 dest.removeAttribute( jQuery.expando );
    5961         }
    5962 
    5963         // IE blanks contents when cloning scripts, and tries to evaluate newly-set text
    5964         if ( nodeName === "script" && dest.text !== src.text ) {
    5965                 disableScript( dest ).text = src.text;
    5966                 restoreScript( dest );
    5967 
    5968         // IE6-10 improperly clones children of object elements using classid.
    5969         // IE10 throws NoModificationAllowedError if parent is null, #12132.
    5970         } else if ( nodeName === "object" ) {
    5971                 if ( dest.parentNode ) {
    5972                         dest.outerHTML = src.outerHTML;
    5973                 }
    5974 
    5975                 // This path appears unavoidable for IE9. When cloning an object
    5976                 // element in IE9, the outerHTML strategy above is not sufficient.
    5977                 // If the src has innerHTML and the destination does not,
    5978                 // copy the src.innerHTML into the dest.innerHTML. #10324
    5979                 if ( support.html5Clone && ( src.innerHTML && !jQuery.trim( dest.innerHTML ) ) ) {
    5980                         dest.innerHTML = src.innerHTML;
    5981                 }
    5982 
    5983         } else if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
    5984 
    5985                 // IE6-8 fails to persist the checked state of a cloned checkbox
    5986                 // or radio button. Worse, IE6-7 fail to give the cloned element
    5987                 // a checked appearance if the defaultChecked value isn't also set
    5988 
    5989                 dest.defaultChecked = dest.checked = src.checked;
    5990 
    5991                 // IE6-7 get confused and end up setting the value of a cloned
    5992                 // checkbox/radio button to an empty string instead of "on"
    5993                 if ( dest.value !== src.value ) {
    5994                         dest.value = src.value;
    5995                 }
    5996 
    5997         // IE6-8 fails to return the selected option to the default selected
    5998         // state when cloning options
    5999         } else if ( nodeName === "option" ) {
    6000                 dest.defaultSelected = dest.selected = src.defaultSelected;
    6001 
    6002         // IE6-8 fails to set the defaultValue to the correct value when
    6003         // cloning other types of input fields
     5171        // 1. Copy private data: events, handlers, etc.
     5172        if ( dataPriv.hasData( src ) ) {
     5173                pdataOld = dataPriv.access( src );
     5174                pdataCur = dataPriv.set( dest, pdataOld );
     5175                events = pdataOld.events;
     5176
     5177                if ( events ) {
     5178                        delete pdataCur.handle;
     5179                        pdataCur.events = {};
     5180
     5181                        for ( type in events ) {
     5182                                for ( i = 0, l = events[ type ].length; i < l; i++ ) {
     5183                                        jQuery.event.add( dest, type, events[ type ][ i ] );
     5184                                }
     5185                        }
     5186                }
     5187        }
     5188
     5189        // 2. Copy user data
     5190        if ( dataUser.hasData( src ) ) {
     5191                udataOld = dataUser.access( src );
     5192                udataCur = jQuery.extend( {}, udataOld );
     5193
     5194                dataUser.set( dest, udataCur );
     5195        }
     5196}
     5197
     5198// Fix IE bugs, see support tests
     5199function fixInput( src, dest ) {
     5200        var nodeName = dest.nodeName.toLowerCase();
     5201
     5202        // Fails to persist the checked state of a cloned checkbox or radio button.
     5203        if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
     5204                dest.checked = src.checked;
     5205
     5206        // Fails to return the selected option to the default selected state when cloning options
    60045207        } else if ( nodeName === "input" || nodeName === "textarea" ) {
    60055208                dest.defaultValue = src.defaultValue;
     
    60125215        args = concat.apply( [], args );
    60135216
    6014         var first, node, hasScripts,
    6015                 scripts, doc, fragment,
     5217        var fragment, first, scripts, hasScripts, node, doc,
    60165218                i = 0,
    60175219                l = collection.length,
     
    60775279                                        node = scripts[ i ];
    60785280                                        if ( rscriptType.test( node.type || "" ) &&
    6079                                                 !jQuery._data( node, "globalEval" ) &&
     5281                                                !dataPriv.access( node, "globalEval" ) &&
    60805282                                                jQuery.contains( doc, node ) ) {
    60815283
     
    60875289                                                        }
    60885290                                                } else {
    6089                                                         jQuery.globalEval(
    6090                                                                 ( node.text || node.textContent || node.innerHTML || "" )
    6091                                                                         .replace( rcleanScript, "" )
    6092                                                         );
     5291                                                        jQuery.globalEval( node.textContent.replace( rcleanScript, "" ) );
    60935292                                                }
    60945293                                        }
    60955294                                }
    60965295                        }
    6097 
    6098                         // Fix #11809: Avoid leaking memory
    6099                         fragment = first = null;
    61005296                }
    61015297        }
     
    61065302function remove( elem, selector, keepData ) {
    61075303        var node,
    6108                 elems = selector ? jQuery.filter( selector, elem ) : elem,
     5304                nodes = selector ? jQuery.filter( selector, elem ) : elem,
    61095305                i = 0;
    61105306
    6111         for ( ; ( node = elems[ i ] ) != null; i++ ) {
    6112 
     5307        for ( ; ( node = nodes[ i ] ) != null; i++ ) {
    61135308                if ( !keepData && node.nodeType === 1 ) {
    61145309                        jQuery.cleanData( getAll( node ) );
     
    61325327
    61335328        clone: function( elem, dataAndEvents, deepDataAndEvents ) {
    6134                 var destElements, node, clone, i, srcElements,
     5329                var i, l, srcElements, destElements,
     5330                        clone = elem.cloneNode( true ),
    61355331                        inPage = jQuery.contains( elem.ownerDocument, elem );
    61365332
    6137                 if ( support.html5Clone || jQuery.isXMLDoc( elem ) ||
    6138                         !rnoshimcache.test( "<" + elem.nodeName + ">" ) ) {
    6139 
    6140                         clone = elem.cloneNode( true );
    6141 
    6142                 // IE<=8 does not properly clone detached, unknown element nodes
    6143                 } else {
    6144                         fragmentDiv.innerHTML = elem.outerHTML;
    6145                         fragmentDiv.removeChild( clone = fragmentDiv.firstChild );
    6146                 }
    6147 
    6148                 if ( ( !support.noCloneEvent || !support.noCloneChecked ) &&
    6149                                 ( elem.nodeType === 1 || elem.nodeType === 11 ) && !jQuery.isXMLDoc( elem ) ) {
     5333                // Fix IE cloning issues
     5334                if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
     5335                                !jQuery.isXMLDoc( elem ) ) {
    61505336
    61515337                        // We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
     
    61535339                        srcElements = getAll( elem );
    61545340
    6155                         // Fix all IE cloning issues
    6156                         for ( i = 0; ( node = srcElements[ i ] ) != null; ++i ) {
    6157 
    6158                                 // Ensure that the destination node is not null; Fixes #9587
    6159                                 if ( destElements[ i ] ) {
    6160                                         fixCloneNodeIssues( node, destElements[ i ] );
    6161                                 }
     5341                        for ( i = 0, l = srcElements.length; i < l; i++ ) {
     5342                                fixInput( srcElements[ i ], destElements[ i ] );
    61625343                        }
    61635344                }
     
    61695350                                destElements = destElements || getAll( clone );
    61705351
    6171                                 for ( i = 0; ( node = srcElements[ i ] ) != null; i++ ) {
    6172                                         cloneCopyEvent( node, destElements[ i ] );
     5352                                for ( i = 0, l = srcElements.length; i < l; i++ ) {
     5353                                        cloneCopyEvent( srcElements[ i ], destElements[ i ] );
    61735354                                }
    61745355                        } else {
     
    61835364                }
    61845365
    6185                 destElements = srcElements = node = null;
    6186 
    61875366                // Return the cloned set
    61885367                return clone;
    61895368        },
    61905369
    6191         cleanData: function( elems, /* internal */ forceAcceptData ) {
    6192                 var elem, type, id, data,
    6193                         i = 0,
    6194                         internalKey = jQuery.expando,
    6195                         cache = jQuery.cache,
    6196                         attributes = support.attributes,
    6197                         special = jQuery.event.special;
    6198 
    6199                 for ( ; ( elem = elems[ i ] ) != null; i++ ) {
    6200                         if ( forceAcceptData || acceptData( elem ) ) {
    6201 
    6202                                 id = elem[ internalKey ];
    6203                                 data = id && cache[ id ];
    6204 
    6205                                 if ( data ) {
     5370        cleanData: function( elems ) {
     5371                var data, elem, type,
     5372                        special = jQuery.event.special,
     5373                        i = 0;
     5374
     5375                for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
     5376                        if ( acceptData( elem ) ) {
     5377                                if ( ( data = elem[ dataPriv.expando ] ) ) {
    62065378                                        if ( data.events ) {
    62075379                                                for ( type in data.events ) {
     
    62165388                                        }
    62175389
    6218                                         // Remove cache only if it was not already removed by jQuery.event.remove
    6219                                         if ( cache[ id ] ) {
    6220 
    6221                                                 delete cache[ id ];
    6222 
    6223                                                 // Support: IE<9
    6224                                                 // IE does not allow us to delete expando properties from nodes
    6225                                                 // IE creates expando attributes along with the property
    6226                                                 // IE does not have a removeAttribute function on Document nodes
    6227                                                 if ( !attributes && typeof elem.removeAttribute !== "undefined" ) {
    6228                                                         elem.removeAttribute( internalKey );
    6229 
    6230                                                 // Webkit & Blink performance suffers when deleting properties
    6231                                                 // from DOM nodes, so set to undefined instead
    6232                                                 // https://code.google.com/p/chromium/issues/detail?id=378607
    6233                                                 } else {
    6234                                                         elem[ internalKey ] = undefined;
    6235                                                 }
    6236 
    6237                                                 deletedIds.push( id );
    6238                                         }
     5390                                        // Support: Chrome <= 35-45+
     5391                                        // Assign undefined instead of using delete, see Data#remove
     5392                                        elem[ dataPriv.expando ] = undefined;
     5393                                }
     5394                                if ( elem[ dataUser.expando ] ) {
     5395
     5396                                        // Support: Chrome <= 35-45+
     5397                                        // Assign undefined instead of using delete, see Data#remove
     5398                                        elem[ dataUser.expando ] = undefined;
    62395399                                }
    62405400                        }
     
    62605420                        return value === undefined ?
    62615421                                jQuery.text( this ) :
    6262                                 this.empty().append(
    6263                                         ( this[ 0 ] && this[ 0 ].ownerDocument || document ).createTextNode( value )
    6264                                 );
     5422                                this.empty().each( function() {
     5423                                        if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
     5424                                                this.textContent = value;
     5425                                        }
     5426                                } );
    62655427                }, null, value, arguments.length );
    62665428        },
     
    63055467
    63065468                for ( ; ( elem = this[ i ] ) != null; i++ ) {
    6307 
    6308                         // Remove element nodes and prevent memory leaks
    63095469                        if ( elem.nodeType === 1 ) {
     5470
     5471                                // Prevent memory leaks
    63105472                                jQuery.cleanData( getAll( elem, false ) );
    6311                         }
    6312 
    6313                         // Remove any remaining nodes
    6314                         while ( elem.firstChild ) {
    6315                                 elem.removeChild( elem.firstChild );
    6316                         }
    6317 
    6318                         // If this is a select, ensure that it displays empty (#12336)
    6319                         // Support: IE<9
    6320                         if ( elem.options && jQuery.nodeName( elem, "select" ) ) {
    6321                                 elem.options.length = 0;
     5473
     5474                                // Remove any remaining nodes
     5475                                elem.textContent = "";
    63225476                        }
    63235477                }
     
    63415495                                l = this.length;
    63425496
    6343                         if ( value === undefined ) {
    6344                                 return elem.nodeType === 1 ?
    6345                                         elem.innerHTML.replace( rinlinejQuery, "" ) :
    6346                                         undefined;
     5497                        if ( value === undefined && elem.nodeType === 1 ) {
     5498                                return elem.innerHTML;
    63475499                        }
    63485500
    63495501                        // See if we can take a shortcut and just use innerHTML
    63505502                        if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
    6351                                 ( support.htmlSerialize || !rnoshimcache.test( value )  ) &&
    6352                                 ( support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&
    63535503                                !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
    63545504
     
    63575507                                try {
    63585508                                        for ( ; i < l; i++ ) {
     5509                                                elem = this[ i ] || {};
    63595510
    63605511                                                // Remove element nodes and prevent memory leaks
    6361                                                 elem = this[ i ] || {};
    63625512                                                if ( elem.nodeType === 1 ) {
    63635513                                                        jQuery.cleanData( getAll( elem, false ) );
     
    64065556        jQuery.fn[ name ] = function( selector ) {
    64075557                var elems,
    6408                         i = 0,
    64095558                        ret = [],
    64105559                        insert = jQuery( selector ),
    6411                         last = insert.length - 1;
     5560                        last = insert.length - 1,
     5561                        i = 0;
    64125562
    64135563                for ( ; i <= last; i++ ) {
     
    64155565                        jQuery( insert[ i ] )[ original ]( elems );
    64165566
    6417                         // Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get()
     5567                        // Support: QtWebKit
     5568                        // .get() because push.apply(_, arraylike) throws
    64185569                        push.apply( ret, elems.get() );
    64195570                }
     
    64715622
    64725623                        // Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
    6473                         doc = ( iframe[ 0 ].contentWindow || iframe[ 0 ].contentDocument ).document;
     5624                        doc = iframe[ 0 ].contentDocument;
    64745625
    64755626                        // Support: IE
     
    64905641
    64915642var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
     5643
     5644var getStyles = function( elem ) {
     5645
     5646                // Support: IE<=11+, Firefox<=30+ (#15098, #14150)
     5647                // IE throws on elements created in popups
     5648                // FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
     5649                var view = elem.ownerDocument.defaultView;
     5650
     5651                if ( !view || !view.opener ) {
     5652                        view = window;
     5653                }
     5654
     5655                return view.getComputedStyle( elem );
     5656        };
    64925657
    64935658var swap = function( elem, options, callback, args ) {
     
    65175682
    65185683( function() {
    6519         var pixelPositionVal, pixelMarginRightVal, boxSizingReliableVal,
    6520                 reliableHiddenOffsetsVal, reliableMarginRightVal, reliableMarginLeftVal,
     5684        var pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal,
    65215685                container = document.createElement( "div" ),
    65225686                div = document.createElement( "div" );
     
    65275691        }
    65285692
    6529         div.style.cssText = "float:left;opacity:.5";
    6530 
    6531         // Support: IE<9
    6532         // Make sure that element opacity exists (as opposed to filter)
    6533         support.opacity = div.style.opacity === "0.5";
    6534 
    6535         // Verify style float existence
    6536         // (IE uses styleFloat instead of cssFloat)
    6537         support.cssFloat = !!div.style.cssFloat;
    6538 
     5693        // Support: IE9-11+
     5694        // Style of cloned element affects source element cloned (#8908)
    65395695        div.style.backgroundClip = "content-box";
    65405696        div.cloneNode( true ).style.backgroundClip = "";
    65415697        support.clearCloneStyle = div.style.backgroundClip === "content-box";
    65425698
    6543         container = document.createElement( "div" );
    65445699        container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" +
    65455700                "padding:0;margin-top:1px;position:absolute";
    6546         div.innerHTML = "";
    65475701        container.appendChild( div );
    65485702
    6549         // Support: Firefox<29, Android 2.3
    6550         // Vendor-prefix box-sizing
    6551         support.boxSizing = div.style.boxSizing === "" || div.style.MozBoxSizing === "" ||
    6552                 div.style.WebkitBoxSizing === "";
    6553 
    6554         jQuery.extend( support, {
    6555                 reliableHiddenOffsets: function() {
    6556                         if ( pixelPositionVal == null ) {
    6557                                 computeStyleTests();
    6558                         }
    6559                         return reliableHiddenOffsetsVal;
    6560                 },
    6561 
    6562                 boxSizingReliable: function() {
    6563 
    6564                         // We're checking for pixelPositionVal here instead of boxSizingReliableVal
    6565                         // since that compresses better and they're computed together anyway.
    6566                         if ( pixelPositionVal == null ) {
    6567                                 computeStyleTests();
    6568                         }
    6569                         return boxSizingReliableVal;
    6570                 },
    6571 
    6572                 pixelMarginRight: function() {
    6573 
    6574                         // Support: Android 4.0-4.3
    6575                         if ( pixelPositionVal == null ) {
    6576                                 computeStyleTests();
    6577                         }
    6578                         return pixelMarginRightVal;
    6579                 },
    6580 
    6581                 pixelPosition: function() {
    6582                         if ( pixelPositionVal == null ) {
    6583                                 computeStyleTests();
    6584                         }
    6585                         return pixelPositionVal;
    6586                 },
    6587 
    6588                 reliableMarginRight: function() {
    6589 
    6590                         // Support: Android 2.3
    6591                         if ( pixelPositionVal == null ) {
    6592                                 computeStyleTests();
    6593                         }
    6594                         return reliableMarginRightVal;
    6595                 },
    6596 
    6597                 reliableMarginLeft: function() {
    6598 
    6599                         // Support: IE <=8 only, Android 4.0 - 4.3 only, Firefox <=3 - 37
    6600                         if ( pixelPositionVal == null ) {
    6601                                 computeStyleTests();
    6602                         }
    6603                         return reliableMarginLeftVal;
    6604                 }
    6605         } );
    6606 
     5703        // Executing both pixelPosition & boxSizingReliable tests require only one layout
     5704        // so they're executed at the same time to save the second computation.
    66075705        function computeStyleTests() {
    6608                 var contents, divStyle,
    6609                         documentElement = document.documentElement;
    6610 
    6611                 // Setup
    6612                 documentElement.appendChild( container );
    6613 
    66145706                div.style.cssText =
    66155707
    6616                         // Support: Android 2.3
     5708                        // Support: Firefox<29, Android 2.3
    66175709                        // Vendor-prefix box-sizing
    6618                         "-webkit-box-sizing:border-box;box-sizing:border-box;" +
     5710                        "-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;" +
    66195711                        "position:relative;display:block;" +
    66205712                        "margin:auto;border:1px;padding:1px;" +
    66215713                        "top:1%;width:50%";
    6622 
    6623                 // Support: IE<9
    6624                 // Assume reasonable values in the absence of getComputedStyle
    6625                 pixelPositionVal = boxSizingReliableVal = reliableMarginLeftVal = false;
    6626                 pixelMarginRightVal = reliableMarginRightVal = true;
    6627 
    6628                 // Check for getComputedStyle so that this code is not run in IE<9.
    6629                 if ( window.getComputedStyle ) {
    6630                         divStyle = window.getComputedStyle( div );
    6631                         pixelPositionVal = ( divStyle || {} ).top !== "1%";
    6632                         reliableMarginLeftVal = ( divStyle || {} ).marginLeft === "2px";
    6633                         boxSizingReliableVal = ( divStyle || { width: "4px" } ).width === "4px";
    6634 
    6635                         // Support: Android 4.0 - 4.3 only
    6636                         // Some styles come back with percentage values, even though they shouldn't
    6637                         div.style.marginRight = "50%";
    6638                         pixelMarginRightVal = ( divStyle || { marginRight: "4px" } ).marginRight === "4px";
    6639 
    6640                         // Support: Android 2.3 only
    6641                         // Div with explicit width and no margin-right incorrectly
    6642                         // gets computed margin-right based on width of container (#3333)
     5714                div.innerHTML = "";
     5715                documentElement.appendChild( container );
     5716
     5717                var divStyle = window.getComputedStyle( div );
     5718                pixelPositionVal = divStyle.top !== "1%";
     5719                reliableMarginLeftVal = divStyle.marginLeft === "2px";
     5720                boxSizingReliableVal = divStyle.width === "4px";
     5721
     5722                // Support: Android 4.0 - 4.3 only
     5723                // Some styles come back with percentage values, even though they shouldn't
     5724                div.style.marginRight = "50%";
     5725                pixelMarginRightVal = divStyle.marginRight === "4px";
     5726
     5727                documentElement.removeChild( container );
     5728        }
     5729
     5730        jQuery.extend( support, {
     5731                pixelPosition: function() {
     5732
     5733                        // This test is executed only once but we still do memoizing
     5734                        // since we can use the boxSizingReliable pre-computing.
     5735                        // No need to check if the test was already performed, though.
     5736                        computeStyleTests();
     5737                        return pixelPositionVal;
     5738                },
     5739                boxSizingReliable: function() {
     5740                        if ( boxSizingReliableVal == null ) {
     5741                                computeStyleTests();
     5742                        }
     5743                        return boxSizingReliableVal;
     5744                },
     5745                pixelMarginRight: function() {
     5746
     5747                        // Support: Android 4.0-4.3
     5748                        // We're checking for boxSizingReliableVal here instead of pixelMarginRightVal
     5749                        // since that compresses better and they're computed together anyway.
     5750                        if ( boxSizingReliableVal == null ) {
     5751                                computeStyleTests();
     5752                        }
     5753                        return pixelMarginRightVal;
     5754                },
     5755                reliableMarginLeft: function() {
     5756
     5757                        // Support: IE <=8 only, Android 4.0 - 4.3 only, Firefox <=3 - 37
     5758                        if ( boxSizingReliableVal == null ) {
     5759                                computeStyleTests();
     5760                        }
     5761                        return reliableMarginLeftVal;
     5762                },
     5763                reliableMarginRight: function() {
     5764
     5765                        // Support: Android 2.3
     5766                        // Check if div with explicit width and no margin-right incorrectly
     5767                        // gets computed margin-right based on width of container. (#3333)
    66435768                        // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
    6644                         contents = div.appendChild( document.createElement( "div" ) );
     5769                        // This support function is only executed once so no memoizing is needed.
     5770                        var ret,
     5771                                marginDiv = div.appendChild( document.createElement( "div" ) );
    66455772
    66465773                        // Reset CSS: box-sizing; display; margin; border; padding
    6647                         contents.style.cssText = div.style.cssText =
     5774                        marginDiv.style.cssText = div.style.cssText =
    66485775
    66495776                                // Support: Android 2.3
    66505777                                // Vendor-prefix box-sizing
    6651                                 "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" +
    6652                                 "box-sizing:content-box;display:block;margin:0;border:0;padding:0";
    6653                         contents.style.marginRight = contents.style.width = "0";
     5778                                "-webkit-box-sizing:content-box;box-sizing:content-box;" +
     5779                                "display:block;margin:0;border:0;padding:0";
     5780                        marginDiv.style.marginRight = marginDiv.style.width = "0";
    66545781                        div.style.width = "1px";
    6655 
    6656                         reliableMarginRightVal =
    6657                                 !parseFloat( ( window.getComputedStyle( contents ) || {} ).marginRight );
    6658 
    6659                         div.removeChild( contents );
    6660                 }
    6661 
    6662                 // Support: IE6-8
    6663                 // First check that getClientRects works as expected
    6664                 // Check if table cells still have offsetWidth/Height when they are set
    6665                 // to display:none and there are still other visible table cells in a
    6666                 // table row; if so, offsetWidth/Height are not reliable for use when
    6667                 // determining if an element has been hidden directly using
    6668                 // display:none (it is still safe to use offsets if a parent element is
    6669                 // hidden; don safety goggles and see bug #4512 for more information).
    6670                 div.style.display = "none";
    6671                 reliableHiddenOffsetsVal = div.getClientRects().length === 0;
    6672                 if ( reliableHiddenOffsetsVal ) {
    6673                         div.style.display = "";
    6674                         div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
    6675                         div.childNodes[ 0 ].style.borderCollapse = "separate";
    6676                         contents = div.getElementsByTagName( "td" );
    6677                         contents[ 0 ].style.cssText = "margin:0;border:0;padding:0;display:none";
    6678                         reliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0;
    6679                         if ( reliableHiddenOffsetsVal ) {
    6680                                 contents[ 0 ].style.display = "";
    6681                                 contents[ 1 ].style.display = "none";
    6682                                 reliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0;
    6683                         }
    6684                 }
    6685 
    6686                 // Teardown
    6687                 documentElement.removeChild( container );
    6688         }
    6689 
     5782                        documentElement.appendChild( container );
     5783
     5784                        ret = !parseFloat( window.getComputedStyle( marginDiv ).marginRight );
     5785
     5786                        documentElement.removeChild( container );
     5787                        div.removeChild( marginDiv );
     5788
     5789                        return ret;
     5790                }
     5791        } );
    66905792} )();
    66915793
    66925794
    6693 var getStyles, curCSS,
    6694         rposition = /^(top|right|bottom|left)$/;
    6695 
    6696 if ( window.getComputedStyle ) {
    6697         getStyles = function( elem ) {
    6698 
    6699                 // Support: IE<=11+, Firefox<=30+ (#15098, #14150)
    6700                 // IE throws on elements created in popups
    6701                 // FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
    6702                 var view = elem.ownerDocument.defaultView;
    6703 
    6704                 if ( !view || !view.opener ) {
    6705                         view = window;
    6706                 }
    6707 
    6708                 return view.getComputedStyle( elem );
    6709         };
    6710 
    6711         curCSS = function( elem, name, computed ) {
    6712                 var width, minWidth, maxWidth, ret,
    6713                         style = elem.style;
    6714 
    6715                 computed = computed || getStyles( elem );
    6716 
    6717                 // getPropertyValue is only needed for .css('filter') in IE9, see #12537
    6718                 ret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined;
    6719 
    6720                 // Support: Opera 12.1x only
    6721                 // Fall back to style even without computed
    6722                 // computed is undefined for elems on document fragments
    6723                 if ( ( ret === "" || ret === undefined ) && !jQuery.contains( elem.ownerDocument, elem ) ) {
    6724                         ret = jQuery.style( elem, name );
    6725                 }
    6726 
    6727                 if ( computed ) {
    6728 
    6729                         // A tribute to the "awesome hack by Dean Edwards"
    6730                         // Chrome < 17 and Safari 5.0 uses "computed value"
    6731                         // instead of "used value" for margin-right
    6732                         // Safari 5.1.7 (at least) returns percentage for a larger set of values,
    6733                         // but width seems to be reliably pixels
    6734                         // this is against the CSSOM draft spec:
    6735                         // http://dev.w3.org/csswg/cssom/#resolved-values
    6736                         if ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {
    6737 
    6738                                 // Remember the original values
    6739                                 width = style.width;
    6740                                 minWidth = style.minWidth;
    6741                                 maxWidth = style.maxWidth;
    6742 
    6743                                 // Put in the new values to get a computed value out
    6744                                 style.minWidth = style.maxWidth = style.width = ret;
    6745                                 ret = computed.width;
    6746 
    6747                                 // Revert the changed values
    6748                                 style.width = width;
    6749                                 style.minWidth = minWidth;
    6750                                 style.maxWidth = maxWidth;
    6751                         }
    6752                 }
    6753 
    6754                 // Support: IE
     5795function curCSS( elem, name, computed ) {
     5796        var width, minWidth, maxWidth, ret,
     5797                style = elem.style;
     5798
     5799        computed = computed || getStyles( elem );
     5800        ret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined;
     5801
     5802        // Support: Opera 12.1x only
     5803        // Fall back to style even without computed
     5804        // computed is undefined for elems on document fragments
     5805        if ( ( ret === "" || ret === undefined ) && !jQuery.contains( elem.ownerDocument, elem ) ) {
     5806                ret = jQuery.style( elem, name );
     5807        }
     5808
     5809        // Support: IE9
     5810        // getPropertyValue is only needed for .css('filter') (#12537)
     5811        if ( computed ) {
     5812
     5813                // A tribute to the "awesome hack by Dean Edwards"
     5814                // Android Browser returns percentage for some values,
     5815                // but width seems to be reliably pixels.
     5816                // This is against the CSSOM draft spec:
     5817                // http://dev.w3.org/csswg/cssom/#resolved-values
     5818                if ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {
     5819
     5820                        // Remember the original values
     5821                        width = style.width;
     5822                        minWidth = style.minWidth;
     5823                        maxWidth = style.maxWidth;
     5824
     5825                        // Put in the new values to get a computed value out
     5826                        style.minWidth = style.maxWidth = style.width = ret;
     5827                        ret = computed.width;
     5828
     5829                        // Revert the changed values
     5830                        style.width = width;
     5831                        style.minWidth = minWidth;
     5832                        style.maxWidth = maxWidth;
     5833                }
     5834        }
     5835
     5836        return ret !== undefined ?
     5837
     5838                // Support: IE9-11+
    67555839                // IE returns zIndex value as an integer.
    6756                 return ret === undefined ?
    6757                         ret :
    6758                         ret + "";
    6759         };
    6760 } else if ( documentElement.currentStyle ) {
    6761         getStyles = function( elem ) {
    6762                 return elem.currentStyle;
    6763         };
    6764 
    6765         curCSS = function( elem, name, computed ) {
    6766                 var left, rs, rsLeft, ret,
    6767                         style = elem.style;
    6768 
    6769                 computed = computed || getStyles( elem );
    6770                 ret = computed ? computed[ name ] : undefined;
    6771 
    6772                 // Avoid setting ret to empty string here
    6773                 // so we don't default to auto
    6774                 if ( ret == null && style && style[ name ] ) {
    6775                         ret = style[ name ];
    6776                 }
    6777 
    6778                 // From the awesome hack by Dean Edwards
    6779                 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
    6780 
    6781                 // If we're not dealing with a regular pixel number
    6782                 // but a number that has a weird ending, we need to convert it to pixels
    6783                 // but not position css attributes, as those are
    6784                 // proportional to the parent element instead
    6785                 // and we can't measure the parent instead because it
    6786                 // might trigger a "stacking dolls" problem
    6787                 if ( rnumnonpx.test( ret ) && !rposition.test( name ) ) {
    6788 
    6789                         // Remember the original values
    6790                         left = style.left;
    6791                         rs = elem.runtimeStyle;
    6792                         rsLeft = rs && rs.left;
    6793 
    6794                         // Put in the new values to get a computed value out
    6795                         if ( rsLeft ) {
    6796                                 rs.left = elem.currentStyle.left;
    6797                         }
    6798                         style.left = name === "fontSize" ? "1em" : ret;
    6799                         ret = style.pixelLeft + "px";
    6800 
    6801                         // Revert the changed values
    6802                         style.left = left;
    6803                         if ( rsLeft ) {
    6804                                 rs.left = rsLeft;
    6805                         }
    6806                 }
    6807 
    6808                 // Support: IE
    6809                 // IE returns zIndex value as an integer.
    6810                 return ret === undefined ?
    6811                         ret :
    6812                         ret + "" || "auto";
    6813         };
     5840                ret + "" :
     5841                ret;
    68145842}
    6815 
    6816 
    68175843
    68185844
     
    68395865var
    68405866
    6841                 ralpha = /alpha\([^)]*\)/i,
    6842         ropacity = /opacity\s*=\s*([^)]*)/i,
    6843 
    6844         // swappable if display is none or starts with table except
    6845         // "table", "table-cell", or "table-caption"
    6846         // see here for display values:
    6847         // https://developer.mozilla.org/en-US/docs/CSS/display
     5867        // Swappable if display is none or starts with table
     5868        // except "table", "table-cell", or "table-caption"
     5869        // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
    68485870        rdisplayswap = /^(none|table(?!-c[ea]).+)/,
    6849         rnumsplit = new RegExp( "^(" + pnum + ")(.*)$", "i" ),
    68505871
    68515872        cssShow = { position: "absolute", visibility: "hidden", display: "block" },
     
    68585879        emptyStyle = document.createElement( "div" ).style;
    68595880
    6860 
    6861 // return a css property mapped to a potentially vendor prefixed property
     5881// Return a css property mapped to a potentially vendor prefixed property
    68625882function vendorPropName( name ) {
    68635883
    6864         // shortcut for names that are not vendor prefixed
     5884        // Shortcut for names that are not vendor prefixed
    68655885        if ( name in emptyStyle ) {
    68665886                return name;
    68675887        }
    68685888
    6869         // check for vendor prefixed names
    6870         var capName = name.charAt( 0 ).toUpperCase() + name.slice( 1 ),
     5889        // Check for vendor prefixed names
     5890        var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
    68715891                i = cssPrefixes.length;
    68725892
     
    68795899}
    68805900
    6881 function showHide( elements, show ) {
    6882         var display, elem, hidden,
    6883                 values = [],
    6884                 index = 0,
    6885                 length = elements.length;
    6886 
    6887         for ( ; index < length; index++ ) {
    6888                 elem = elements[ index ];
    6889                 if ( !elem.style ) {
    6890                         continue;
    6891                 }
    6892 
    6893                 values[ index ] = jQuery._data( elem, "olddisplay" );
    6894                 display = elem.style.display;
    6895                 if ( show ) {
    6896 
    6897                         // Reset the inline display of this element to learn if it is
    6898                         // being hidden by cascaded rules or not
    6899                         if ( !values[ index ] && display === "none" ) {
    6900                                 elem.style.display = "";
    6901                         }
    6902 
    6903                         // Set elements which have been overridden with display: none
    6904                         // in a stylesheet to whatever the default browser style is
    6905                         // for such an element
    6906                         if ( elem.style.display === "" && isHidden( elem ) ) {
    6907                                 values[ index ] =
    6908                                         jQuery._data( elem, "olddisplay", defaultDisplay( elem.nodeName ) );
    6909                         }
    6910                 } else {
    6911                         hidden = isHidden( elem );
    6912 
    6913                         if ( display && display !== "none" || !hidden ) {
    6914                                 jQuery._data(
    6915                                         elem,
    6916                                         "olddisplay",
    6917                                         hidden ? display : jQuery.css( elem, "display" )
    6918                                 );
    6919                         }
    6920                 }
    6921         }
    6922 
    6923         // Set the display of most of the elements in a second loop
    6924         // to avoid the constant reflow
    6925         for ( index = 0; index < length; index++ ) {
    6926                 elem = elements[ index ];
    6927                 if ( !elem.style ) {
    6928                         continue;
    6929                 }
    6930                 if ( !show || elem.style.display === "none" || elem.style.display === "" ) {
    6931                         elem.style.display = show ? values[ index ] || "" : "none";
    6932                 }
    6933         }
    6934 
    6935         return elements;
    6936 }
    6937 
    69385901function setPositiveNumber( elem, value, subtract ) {
    6939         var matches = rnumsplit.exec( value );
     5902
     5903        // Any relative (+/-) values have already been
     5904        // normalized at this point
     5905        var matches = rcssNum.exec( value );
    69405906        return matches ?
    69415907
    69425908                // Guard against undefined "subtract", e.g., when used as in cssHooks
    6943                 Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) :
     5909                Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
    69445910                value;
    69455911}
     
    69585924        for ( ; i < 4; i += 2 ) {
    69595925
    6960                 // both box models exclude margin, so add it if we want it
     5926                // Both box models exclude margin, so add it if we want it
    69615927                if ( extra === "margin" ) {
    69625928                        val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
     
    69705936                        }
    69715937
    6972                         // at this point, extra isn't border nor margin, so remove border
     5938                        // At this point, extra isn't border nor margin, so remove border
    69735939                        if ( extra !== "margin" ) {
    69745940                                val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
     
    69765942                } else {
    69775943
    6978                         // at this point, extra isn't content, so add padding
     5944                        // At this point, extra isn't content, so add padding
    69795945                        val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
    69805946
    6981                         // at this point, extra isn't content nor padding, so add border
     5947                        // At this point, extra isn't content nor padding, so add border
    69825948                        if ( extra !== "padding" ) {
    69835949                                val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
     
    69955961                val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
    69965962                styles = getStyles( elem ),
    6997                 isBorderBox = support.boxSizing &&
    6998                         jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
    6999 
    7000         // some non-html elements return undefined for offsetWidth, so check for null/undefined
     5963                isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
     5964
     5965        // Some non-html elements return undefined for offsetWidth, so check for null/undefined
    70015966        // svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
    70025967        // MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
     
    70145979                }
    70155980
    7016                 // we need the check for style in case a browser which returns unreliable values
     5981                // Check for style in case a browser which returns unreliable values
    70175982                // for getComputedStyle silently falls back to the reliable elem.style
    70185983                valueIsBorderBox = isBorderBox &&
     
    70235988        }
    70245989
    7025         // use the active box-sizing model to add/subtract irrelevant styles
     5990        // Use the active box-sizing model to add/subtract irrelevant styles
    70265991        return ( val +
    70275992                augmentWidthOrHeight(
     
    70335998                )
    70345999        ) + "px";
     6000}
     6001
     6002function showHide( elements, show ) {
     6003        var display, elem, hidden,
     6004                values = [],
     6005                index = 0,
     6006                length = elements.length;
     6007
     6008        for ( ; index < length; index++ ) {
     6009                elem = elements[ index ];
     6010                if ( !elem.style ) {
     6011                        continue;
     6012                }
     6013
     6014                values[ index ] = dataPriv.get( elem, "olddisplay" );
     6015                display = elem.style.display;
     6016                if ( show ) {
     6017
     6018                        // Reset the inline display of this element to learn if it is
     6019                        // being hidden by cascaded rules or not
     6020                        if ( !values[ index ] && display === "none" ) {
     6021                                elem.style.display = "";
     6022                        }
     6023
     6024                        // Set elements which have been overridden with display: none
     6025                        // in a stylesheet to whatever the default browser style is
     6026                        // for such an element
     6027                        if ( elem.style.display === "" && isHidden( elem ) ) {
     6028                                values[ index ] = dataPriv.access(
     6029                                        elem,
     6030                                        "olddisplay",
     6031                                        defaultDisplay( elem.nodeName )
     6032                                );
     6033                        }
     6034                } else {
     6035                        hidden = isHidden( elem );
     6036
     6037                        if ( display !== "none" || !hidden ) {
     6038                                dataPriv.set(
     6039                                        elem,
     6040                                        "olddisplay",
     6041                                        hidden ? display : jQuery.css( elem, "display" )
     6042                                );
     6043                        }
     6044                }
     6045        }
     6046
     6047        // Set the display of most of the elements in a second loop
     6048        // to avoid the constant reflow
     6049        for ( index = 0; index < length; index++ ) {
     6050                elem = elements[ index ];
     6051                if ( !elem.style ) {
     6052                        continue;
     6053                }
     6054                if ( !show || elem.style.display === "none" || elem.style.display === "" ) {
     6055                        elem.style.display = show ? values[ index ] || "" : "none";
     6056                }
     6057        }
     6058
     6059        return elements;
    70356060}
    70366061
     
    70726097        // setting or getting the value
    70736098        cssProps: {
    7074 
    7075                 // normalize float css property
    7076                 "float": support.cssFloat ? "cssFloat" : "styleFloat"
     6099                "float": "cssFloat"
    70776100        },
    70786101
     
    70936116                        ( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );
    70946117
    7095                 // gets hook for the prefixed version
    7096                 // followed by the unprefixed version
     6118                // Gets hook for the prefixed version, then unprefixed version
    70976119                hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
    70986120
     
    71096131                        }
    71106132
    7111                         // Make sure that null and NaN values aren't set. See: #7116
     6133                        // Make sure that null and NaN values aren't set (#7116)
    71126134                        if ( value == null || value !== value ) {
    71136135                                return;
     
    71196141                        }
    71206142
    7121                         // Fixes #8908, it can be done more correctly by specifing setters in cssHooks,
    7122                         // but it would mean to define eight
    7123                         // (for every problematic property) identical functions
     6143                        // Support: IE9-11+
     6144                        // background-* props affect original clone's values
    71246145                        if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
    71256146                                style[ name ] = "inherit";
     
    71306151                                ( value = hooks.set( elem, value, extra ) ) !== undefined ) {
    71316152
    7132                                 // Support: IE
    7133                                 // Swallow errors from 'invalid' CSS values (#5509)
    7134                                 try {
    7135                                         style[ name ] = value;
    7136                                 } catch ( e ) {}
     6153                                style[ name ] = value;
    71376154                        }
    71386155
     
    71526169
    71536170        css: function( elem, name, extra, styles ) {
    7154                 var num, val, hooks,
     6171                var val, num, hooks,
    71556172                        origName = jQuery.camelCase( name );
    71566173
     
    71596176                        ( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );
    71606177
    7161                 // gets hook for the prefixed version
    7162                 // followed by the unprefixed version
     6178                // Try prefixed name followed by the unprefixed name
    71636179                hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
    71646180
     
    71736189                }
    71746190
    7175                 //convert "normal" to computed value
     6191                // Convert "normal" to computed value
    71766192                if ( val === "normal" && name in cssNormalTransform ) {
    71776193                        val = cssNormalTransform[ name ];
    71786194                }
    71796195
    7180                 // Return, converting to number if forced or a qualifier was provided and val looks numeric
     6196                // Make numeric if forced or a qualifier was provided and val looks numeric
    71816197                if ( extra === "" || extra ) {
    71826198                        num = parseFloat( val );
     
    71926208                        if ( computed ) {
    71936209
    7194                                 // certain elements can have dimension info if we invisibly show them
    7195                                 // however, it must have a current display style that would benefit from this
     6210                                // Certain elements can have dimension info if we invisibly show them
     6211                                // but it must have a current display style that would benefit
    71966212                                return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
    71976213                                        elem.offsetWidth === 0 ?
     
    72046220
    72056221                set: function( elem, value, extra ) {
    7206                         var styles = extra && getStyles( elem );
    7207                         return setPositiveNumber( elem, value, extra ?
    7208                                 augmentWidthOrHeight(
     6222                        var matches,
     6223                                styles = extra && getStyles( elem ),
     6224                                subtract = extra && augmentWidthOrHeight(
    72096225                                        elem,
    72106226                                        name,
    72116227                                        extra,
    7212                                         support.boxSizing &&
    7213                                                 jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
     6228                                        jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
    72146229                                        styles
    7215                                 ) : 0
    7216                         );
     6230                                );
     6231
     6232                        // Convert to pixels if value adjustment is needed
     6233                        if ( subtract && ( matches = rcssNum.exec( value ) ) &&
     6234                                ( matches[ 3 ] || "px" ) !== "px" ) {
     6235
     6236                                elem.style[ name ] = value;
     6237                                value = jQuery.css( elem, name );
     6238                        }
     6239
     6240                        return setPositiveNumber( elem, value, subtract );
    72176241                }
    72186242        };
    72196243} );
    72206244
    7221 if ( !support.opacity ) {
    7222         jQuery.cssHooks.opacity = {
    7223                 get: function( elem, computed ) {
    7224 
    7225                         // IE uses filters for opacity
    7226                         return ropacity.test( ( computed && elem.currentStyle ?
    7227                                 elem.currentStyle.filter :
    7228                                 elem.style.filter ) || "" ) ?
    7229                                         ( 0.01 * parseFloat( RegExp.$1 ) ) + "" :
    7230                                         computed ? "1" : "";
    7231                 },
    7232 
    7233                 set: function( elem, value ) {
    7234                         var style = elem.style,
    7235                                 currentStyle = elem.currentStyle,
    7236                                 opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "",
    7237                                 filter = currentStyle && currentStyle.filter || style.filter || "";
    7238 
    7239                         // IE has trouble with opacity if it does not have layout
    7240                         // Force it by setting the zoom level
    7241                         style.zoom = 1;
    7242 
    7243                         // if setting opacity to 1, and no other filters exist -
    7244                         // attempt to remove filter attribute #6652
    7245                         // if value === "", then remove inline opacity #12685
    7246                         if ( ( value >= 1 || value === "" ) &&
    7247                                         jQuery.trim( filter.replace( ralpha, "" ) ) === "" &&
    7248                                         style.removeAttribute ) {
    7249 
    7250                                 // Setting style.filter to null, "" & " " still leave "filter:" in the cssText
    7251                                 // if "filter:" is present at all, clearType is disabled, we want to avoid this
    7252                                 // style.removeAttribute is IE Only, but so apparently is this code path...
    7253                                 style.removeAttribute( "filter" );
    7254 
    7255                                 // if there is no filter style applied in a css rule
    7256                                 // or unset inline opacity, we are done
    7257                                 if ( value === "" || currentStyle && !currentStyle.filter ) {
    7258                                         return;
    7259                                 }
    7260                         }
    7261 
    7262                         // otherwise, set new filter values
    7263                         style.filter = ralpha.test( filter ) ?
    7264                                 filter.replace( ralpha, opacity ) :
    7265                                 filter + " " + opacity;
    7266                 }
    7267         };
    7268 }
    7269 
     6245jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
     6246        function( elem, computed ) {
     6247                if ( computed ) {
     6248                        return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
     6249                                elem.getBoundingClientRect().left -
     6250                                        swap( elem, { marginLeft: 0 }, function() {
     6251                                                return elem.getBoundingClientRect().left;
     6252                                        } )
     6253                                ) + "px";
     6254                }
     6255        }
     6256);
     6257
     6258// Support: Android 2.3
    72706259jQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight,
    72716260        function( elem, computed ) {
     
    72736262                        return swap( elem, { "display": "inline-block" },
    72746263                                curCSS, [ elem, "marginRight" ] );
    7275                 }
    7276         }
    7277 );
    7278 
    7279 jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
    7280         function( elem, computed ) {
    7281                 if ( computed ) {
    7282                         return (
    7283                                 parseFloat( curCSS( elem, "marginLeft" ) ) ||
    7284 
    7285                                 // Support: IE<=11+
    7286                                 // Running getBoundingClientRect on a disconnected node in IE throws an error
    7287                                 // Support: IE8 only
    7288                                 // getClientRects() errors on disconnected elems
    7289                                 ( jQuery.contains( elem.ownerDocument, elem ) ?
    7290                                         elem.getBoundingClientRect().left -
    7291                                                 swap( elem, { marginLeft: 0 }, function() {
    7292                                                         return elem.getBoundingClientRect().left;
    7293                                                 } ) :
    7294                                         0
    7295                                 )
    7296                         ) + "px";
    72976264                }
    72986265        }
     
    73106277                                expanded = {},
    73116278
    7312                                 // assumes a single number if not a string
     6279                                // Assumes a single number if not a string
    73136280                                parts = typeof value === "string" ? value.split( " " ) : [ value ];
    73146281
     
    74356402                        }
    74366403
    7437                         // passing an empty string as a 3rd parameter to .css will automatically
    7438                         // attempt a parseFloat and fallback to a string if the parse fails
    7439                         // so, simple values such as "10px" are parsed to Float.
    7440                         // complex values such as "rotate(1rad)" are returned as is.
     6404                        // Passing an empty string as a 3rd parameter to .css will automatically
     6405                        // attempt a parseFloat and fallback to a string if the parse fails.
     6406                        // Simple values such as "10px" are parsed to Float;
     6407                        // complex values such as "rotate(1rad)" are returned as-is.
    74416408                        result = jQuery.css( tween.elem, tween.prop, "" );
    74426409
     
    74466413                set: function( tween ) {
    74476414
    7448                         // use step hook for back compat - use cssHook if its there - use .style if its
    7449                         // available and use plain properties where available
     6415                        // Use step hook for back compat.
     6416                        // Use cssHook if its there.
     6417                        // Use .style if available and use plain properties where available.
    74506418                        if ( jQuery.fx.step[ tween.prop ] ) {
    74516419                                jQuery.fx.step[ tween.prop ]( tween );
     
    74616429};
    74626430
    7463 // Support: IE <=9
     6431// Support: IE9
    74646432// Panic based approach to setting things on disconnected nodes
    7465 
    74666433Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
    74676434        set: function( tween ) {
     
    75066473function genFx( type, includeWidth ) {
    75076474        var which,
    7508                 attrs = { height: type },
    7509                 i = 0;
    7510 
    7511         // if we include width, step value is 1 to do all cssExpand values,
    7512         // if we don't include width, step value is 2 to skip over Left and Right
     6475                i = 0,
     6476                attrs = { height: type };
     6477
     6478        // If we include width, step value is 1 to do all cssExpand values,
     6479        // otherwise step value is 2 to skip over Left and Right
    75136480        includeWidth = includeWidth ? 1 : 0;
    75146481        for ( ; i < 4 ; i += 2 - includeWidth ) {
     
    75326499                if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
    75336500
    7534                         // we're done with this property
     6501                        // We're done with this property
    75356502                        return tween;
    75366503                }
     
    75456512                style = elem.style,
    75466513                hidden = elem.nodeType && isHidden( elem ),
    7547                 dataShow = jQuery._data( elem, "fxshow" );
    7548 
    7549         // handle queue: false promises
     6514                dataShow = dataPriv.get( elem, "fxshow" );
     6515
     6516        // Handle queue: false promises
    75506517        if ( !opts.queue ) {
    75516518                hooks = jQuery._queueHooks( elem, "fx" );
     
    75636530                anim.always( function() {
    75646531
    7565                         // doing this makes sure that the complete handler will be called
    7566                         // before this completes
     6532                        // Ensure the complete handler is called before this completes
    75676533                        anim.always( function() {
    75686534                                hooks.unqueued--;
     
    75746540        }
    75756541
    7576         // height/width overflow pass
     6542        // Height/width overflow pass
    75776543        if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
    75786544
    75796545                // Make sure that nothing sneaks out
    7580                 // Record all 3 overflow attributes because IE does not
     6546                // Record all 3 overflow attributes because IE9-10 do not
    75816547                // change the overflow attribute when overflowX and
    75826548                // overflowY are set to the same value
     
    75896555                // Test default display if display is currently "none"
    75906556                checkDisplay = display === "none" ?
    7591                         jQuery._data( elem, "olddisplay" ) || defaultDisplay( elem.nodeName ) : display;
     6557                        dataPriv.get( elem, "olddisplay" ) || defaultDisplay( elem.nodeName ) : display;
    75926558
    75936559                if ( checkDisplay === "inline" && jQuery.css( elem, "float" ) === "none" ) {
    7594 
    7595                         // inline-level elements accept inline-block;
    7596                         // block-level elements need to be inline with layout
    7597                         if ( !support.inlineBlockNeedsLayout || defaultDisplay( elem.nodeName ) === "inline" ) {
    7598                                 style.display = "inline-block";
    7599                         } else {
    7600                                 style.zoom = 1;
    7601                         }
     6560                        style.display = "inline-block";
    76026561                }
    76036562        }
     
    76056564        if ( opts.overflow ) {
    76066565                style.overflow = "hidden";
    7607                 if ( !support.shrinkWrapBlocks() ) {
    7608                         anim.always( function() {
    7609                                 style.overflow = opts.overflow[ 0 ];
    7610                                 style.overflowX = opts.overflow[ 1 ];
    7611                                 style.overflowY = opts.overflow[ 2 ];
    7612                         } );
    7613                 }
     6566                anim.always( function() {
     6567                        style.overflow = opts.overflow[ 0 ];
     6568                        style.overflowX = opts.overflow[ 1 ];
     6569                        style.overflowY = opts.overflow[ 2 ];
     6570                } );
    76146571        }
    76156572
     
    76446601                        }
    76456602                } else {
    7646                         dataShow = jQuery._data( elem, "fxshow", {} );
    7647                 }
    7648 
    7649                 // store state if its toggle - enables .stop().toggle() to "reverse"
     6603                        dataShow = dataPriv.access( elem, "fxshow", {} );
     6604                }
     6605
     6606                // Store state if its toggle - enables .stop().toggle() to "reverse"
    76506607                if ( toggle ) {
    76516608                        dataShow.hidden = !hidden;
     
    76606617                anim.done( function() {
    76616618                        var prop;
    7662                         jQuery._removeData( elem, "fxshow" );
     6619
     6620                        dataPriv.remove( elem, "fxshow" );
    76636621                        for ( prop in orig ) {
    76646622                                jQuery.style( elem, prop, orig[ prop ] );
     
    77066664                        delete props[ name ];
    77076665
    7708                         // not quite $.extend, this wont overwrite keys already present.
    7709                         // also - reusing 'index' from above because we have the correct "name"
     6666                        // Not quite $.extend, this won't overwrite existing keys.
     6667                        // Reusing 'index' because we have the correct "name"
    77106668                        for ( index in value ) {
    77116669                                if ( !( index in props ) ) {
     
    77276685                deferred = jQuery.Deferred().always( function() {
    77286686
    7729                         // don't match elem in the :animated selector
     6687                        // Don't match elem in the :animated selector
    77306688                        delete tick.elem;
    77316689                } ),
     
    77786736                                var index = 0,
    77796737
    7780                                         // if we are going to the end, we want to run all the tweens
     6738                                        // If we are going to the end, we want to run all the tweens
    77816739                                        // otherwise we skip this part
    77826740                                        length = gotoEnd ? animation.tweens.length : 0;
     
    77896747                                }
    77906748
    7791                                 // resolve when we played the last frame
    7792                                 // otherwise, reject
     6749                                // Resolve when we played the last frame; otherwise, reject
    77936750                                if ( gotoEnd ) {
    77946751                                        deferred.notifyWith( elem, [ animation, 1, 0 ] );
     
    78376794
    78386795jQuery.Animation = jQuery.extend( Animation, {
    7839 
    78406796        tweeners: {
    78416797                "*": [ function( prop, value ) {
     
    78846840        };
    78856841
    7886         opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
    7887                 opt.duration in jQuery.fx.speeds ?
     6842        opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ?
     6843                opt.duration : opt.duration in jQuery.fx.speeds ?
    78886844                        jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
    78896845
    7890         // normalize opt.queue - true/undefined/null -> "fx"
     6846        // Normalize opt.queue - true/undefined/null -> "fx"
    78916847        if ( opt.queue == null || opt.queue === true ) {
    78926848                opt.queue = "fx";
     
    79126868        fadeTo: function( speed, to, easing, callback ) {
    79136869
    7914                 // show any hidden elements after setting opacity to 0
     6870                // Show any hidden elements after setting opacity to 0
    79156871                return this.filter( isHidden ).css( "opacity", 0 ).show()
    79166872
    7917                         // animate to the value specified
     6873                        // Animate to the value specified
    79186874                        .end().animate( { opacity: to }, speed, easing, callback );
    79196875        },
     
    79276883
    79286884                                // Empty animations, or finishing resolves immediately
    7929                                 if ( empty || jQuery._data( this, "finish" ) ) {
     6885                                if ( empty || dataPriv.get( this, "finish" ) ) {
    79306886                                        anim.stop( true );
    79316887                                }
     
    79576913                                index = type != null && type + "queueHooks",
    79586914                                timers = jQuery.timers,
    7959                                 data = jQuery._data( this );
     6915                                data = dataPriv.get( this );
    79606916
    79616917                        if ( index ) {
     
    79816937                        }
    79826938
    7983                         // start the next in the queue if the last step wasn't forced
    7984                         // timers currently will call their complete callbacks, which will dequeue
    7985                         // but only if they were gotoEnd
     6939                        // Start the next in the queue if the last step wasn't forced.
     6940                        // Timers currently will call their complete callbacks, which
     6941                        // will dequeue but only if they were gotoEnd.
    79866942                        if ( dequeue || !gotoEnd ) {
    79876943                                jQuery.dequeue( this, type );
     
    79956951                return this.each( function() {
    79966952                        var index,
    7997                                 data = jQuery._data( this ),
     6953                                data = dataPriv.get( this ),
    79986954                                queue = data[ type + "queue" ],
    79996955                                hooks = data[ type + "queueHooks" ],
     
    80016957                                length = queue ? queue.length : 0;
    80026958
    8003                         // enable finishing flag on private data
     6959                        // Enable finishing flag on private data
    80046960                        data.finish = true;
    80056961
    8006                         // empty the queue first
     6962                        // Empty the queue first
    80076963                        jQuery.queue( this, type, [] );
    80086964
     
    80116967                        }
    80126968
    8013                         // look for any active animations, and finish them
     6969                        // Look for any active animations, and finish them
    80146970                        for ( index = timers.length; index--; ) {
    80156971                                if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
     
    80196975                        }
    80206976
    8021                         // look for any animations in the old queue and finish them
     6977                        // Look for any animations in the old queue and finish them
    80226978                        for ( index = 0; index < length; index++ ) {
    80236979                                if ( queue[ index ] && queue[ index ].finish ) {
     
    80266982                        }
    80276983
    8028                         // turn off finishing flag
     6984                        // Turn off finishing flag
    80296985                        delete data.finish;
    80306986                } );
     
    80587014jQuery.fx.tick = function() {
    80597015        var timer,
    8060                 timers = jQuery.timers,
    8061                 i = 0;
     7016                i = 0,
     7017                timers = jQuery.timers;
    80627018
    80637019        fxNow = jQuery.now();
     
    80887044
    80897045jQuery.fx.interval = 13;
    8090 
    80917046jQuery.fx.start = function() {
    80927047        if ( !timerId ) {
     
    80977052jQuery.fx.stop = function() {
    80987053        window.clearInterval( timerId );
     7054
    80997055        timerId = null;
    81007056};
     
    81257081
    81267082( function() {
    8127         var a,
    8128                 input = document.createElement( "input" ),
    8129                 div = document.createElement( "div" ),
     7083        var input = document.createElement( "input" ),
    81307084                select = document.createElement( "select" ),
    81317085                opt = select.appendChild( document.createElement( "option" ) );
    81327086
    8133         // Setup
    8134         div = document.createElement( "div" );
    8135         div.setAttribute( "className", "t" );
    8136         div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
    8137         a = div.getElementsByTagName( "a" )[ 0 ];
    8138 
    8139         // Support: Windows Web Apps (WWA)
    8140         // `type` must use .setAttribute for WWA (#14901)
    8141         input.setAttribute( "type", "checkbox" );
    8142         div.appendChild( input );
    8143 
    8144         a = div.getElementsByTagName( "a" )[ 0 ];
    8145 
    8146         // First batch of tests.
    8147         a.style.cssText = "top:1px";
    8148 
    8149         // Test setAttribute on camelCase class.
    8150         // If it works, we need attrFixes when doing get/setAttribute (ie6/7)
    8151         support.getSetAttribute = div.className !== "t";
    8152 
    8153         // Get the style information from getAttribute
    8154         // (IE uses .cssText instead)
    8155         support.style = /top/.test( a.getAttribute( "style" ) );
    8156 
    8157         // Make sure that URLs aren't manipulated
    8158         // (IE normalizes it by default)
    8159         support.hrefNormalized = a.getAttribute( "href" ) === "/a";
    8160 
    8161         // Check the default checkbox/radio value ("" on WebKit; "on" elsewhere)
    8162         support.checkOn = !!input.value;
    8163 
    8164         // Make sure that a selected-by-default option has a working selected property.
    8165         // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
     7087        input.type = "checkbox";
     7088
     7089        // Support: iOS<=5.1, Android<=4.2+
     7090        // Default value for a checkbox should be "on"
     7091        support.checkOn = input.value !== "";
     7092
     7093        // Support: IE<=11+
     7094        // Must access selectedIndex to make default options select
    81667095        support.optSelected = opt.selected;
    81677096
    8168         // Tests for enctype support on a form (#6743)
    8169         support.enctype = !!document.createElement( "form" ).enctype;
    8170 
    8171         // Make sure that the options inside disabled selects aren't marked as disabled
    8172         // (WebKit marks them as disabled)
     7097        // Support: Android<=2.3
     7098        // Options inside disabled selects are incorrectly marked as disabled
    81737099        select.disabled = true;
    81747100        support.optDisabled = !opt.disabled;
    81757101
    8176         // Support: IE8 only
    8177         // Check if we can trust getAttribute("value")
     7102        // Support: IE<=11+
     7103        // An input loses its value after becoming a radio
    81787104        input = document.createElement( "input" );
    8179         input.setAttribute( "value", "" );
    8180         support.input = input.getAttribute( "value" ) === "";
    8181 
    8182         // Check if an input maintains its value after becoming a radio
    81837105        input.value = "t";
    8184         input.setAttribute( "type", "radio" );
     7106        input.type = "radio";
    81857107        support.radioValue = input.value === "t";
    81867108} )();
    81877109
    81887110
    8189 var rreturn = /\r/g,
    8190         rspaces = /[\x20\t\r\n\f]+/g;
    8191 
    8192 jQuery.fn.extend( {
    8193         val: function( value ) {
    8194                 var hooks, ret, isFunction,
    8195                         elem = this[ 0 ];
    8196 
    8197                 if ( !arguments.length ) {
    8198                         if ( elem ) {
    8199                                 hooks = jQuery.valHooks[ elem.type ] ||
    8200                                         jQuery.valHooks[ elem.nodeName.toLowerCase() ];
    8201 
    8202                                 if (
    8203                                         hooks &&
    8204                                         "get" in hooks &&
    8205                                         ( ret = hooks.get( elem, "value" ) ) !== undefined
    8206                                 ) {
    8207                                         return ret;
    8208                                 }
    8209 
    8210                                 ret = elem.value;
    8211 
    8212                                 return typeof ret === "string" ?
    8213 
    8214                                         // handle most common string cases
    8215                                         ret.replace( rreturn, "" ) :
    8216 
    8217                                         // handle cases where value is null/undef or number
    8218                                         ret == null ? "" : ret;
    8219                         }
    8220 
    8221                         return;
    8222                 }
    8223 
    8224                 isFunction = jQuery.isFunction( value );
    8225 
    8226                 return this.each( function( i ) {
    8227                         var val;
    8228 
    8229                         if ( this.nodeType !== 1 ) {
    8230                                 return;
    8231                         }
    8232 
    8233                         if ( isFunction ) {
    8234                                 val = value.call( this, i, jQuery( this ).val() );
    8235                         } else {
    8236                                 val = value;
    8237                         }
    8238 
    8239                         // Treat null/undefined as ""; convert numbers to string
    8240                         if ( val == null ) {
    8241                                 val = "";
    8242                         } else if ( typeof val === "number" ) {
    8243                                 val += "";
    8244                         } else if ( jQuery.isArray( val ) ) {
    8245                                 val = jQuery.map( val, function( value ) {
    8246                                         return value == null ? "" : value + "";
    8247                                 } );
    8248                         }
    8249 
    8250                         hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
    8251 
    8252                         // If set returns undefined, fall back to normal setting
    8253                         if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
    8254                                 this.value = val;
    8255                         }
    8256                 } );
    8257         }
    8258 } );
    8259 
    8260 jQuery.extend( {
    8261         valHooks: {
    8262                 option: {
    8263                         get: function( elem ) {
    8264                                 var val = jQuery.find.attr( elem, "value" );
    8265                                 return val != null ?
    8266                                         val :
    8267 
    8268                                         // Support: IE10-11+
    8269                                         // option.text throws exceptions (#14686, #14858)
    8270                                         // Strip and collapse whitespace
    8271                                         // https://html.spec.whatwg.org/#strip-and-collapse-whitespace
    8272                                         jQuery.trim( jQuery.text( elem ) ).replace( rspaces, " " );
    8273                         }
    8274                 },
    8275                 select: {
    8276                         get: function( elem ) {
    8277                                 var value, option,
    8278                                         options = elem.options,
    8279                                         index = elem.selectedIndex,
    8280                                         one = elem.type === "select-one" || index < 0,
    8281                                         values = one ? null : [],
    8282                                         max = one ? index + 1 : options.length,
    8283                                         i = index < 0 ?
    8284                                                 max :
    8285                                                 one ? index : 0;
    8286 
    8287                                 // Loop through all the selected options
    8288                                 for ( ; i < max; i++ ) {
    8289                                         option = options[ i ];
    8290 
    8291                                         // oldIE doesn't update selected after form reset (#2551)
    8292                                         if ( ( option.selected || i === index ) &&
    8293 
    8294                                                         // Don't return options that are disabled or in a disabled optgroup
    8295                                                         ( support.optDisabled ?
    8296                                                                 !option.disabled :
    8297                                                                 option.getAttribute( "disabled" ) === null ) &&
    8298                                                         ( !option.parentNode.disabled ||
    8299                                                                 !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {
    8300 
    8301                                                 // Get the specific value for the option
    8302                                                 value = jQuery( option ).val();
    8303 
    8304                                                 // We don't need an array for one selects
    8305                                                 if ( one ) {
    8306                                                         return value;
    8307                                                 }
    8308 
    8309                                                 // Multi-Selects return an array
    8310                                                 values.push( value );
    8311                                         }
    8312                                 }
    8313 
    8314                                 return values;
    8315                         },
    8316 
    8317                         set: function( elem, value ) {
    8318                                 var optionSet, option,
    8319                                         options = elem.options,
    8320                                         values = jQuery.makeArray( value ),
    8321                                         i = options.length;
    8322 
    8323                                 while ( i-- ) {
    8324                                         option = options[ i ];
    8325 
    8326                                         if ( jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 ) {
    8327 
    8328                                                 // Support: IE6
    8329                                                 // When new option element is added to select box we need to
    8330                                                 // force reflow of newly added node in order to workaround delay
    8331                                                 // of initialization properties
    8332                                                 try {
    8333                                                         option.selected = optionSet = true;
    8334 
    8335                                                 } catch ( _ ) {
    8336 
    8337                                                         // Will be executed only in IE6
    8338                                                         option.scrollHeight;
    8339                                                 }
    8340 
    8341                                         } else {
    8342                                                 option.selected = false;
    8343                                         }
    8344                                 }
    8345 
    8346                                 // Force browsers to behave consistently when non-matching value is set
    8347                                 if ( !optionSet ) {
    8348                                         elem.selectedIndex = -1;
    8349                                 }
    8350 
    8351                                 return options;
    8352                         }
    8353                 }
    8354         }
    8355 } );
    8356 
    8357 // Radios and checkboxes getter/setter
    8358 jQuery.each( [ "radio", "checkbox" ], function() {
    8359         jQuery.valHooks[ this ] = {
    8360                 set: function( elem, value ) {
    8361                         if ( jQuery.isArray( value ) ) {
    8362                                 return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
    8363                         }
    8364                 }
    8365         };
    8366         if ( !support.checkOn ) {
    8367                 jQuery.valHooks[ this ].get = function( elem ) {
    8368                         return elem.getAttribute( "value" ) === null ? "on" : elem.value;
    8369                 };
    8370         }
    8371 } );
    8372 
    8373 
    8374 
    8375 
    8376 var nodeHook, boolHook,
    8377         attrHandle = jQuery.expr.attrHandle,
    8378         ruseDefault = /^(?:checked|selected)$/i,
    8379         getSetAttribute = support.getSetAttribute,
    8380         getSetInput = support.input;
     7111var boolHook,
     7112        attrHandle = jQuery.expr.attrHandle;
    83817113
    83827114jQuery.fn.extend( {
     
    84127144                        name = name.toLowerCase();
    84137145                        hooks = jQuery.attrHooks[ name ] ||
    8414                                 ( jQuery.expr.match.bool.test( name ) ? boolHook : nodeHook );
     7146                                ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
    84157147                }
    84167148
     
    84457177                                if ( !support.radioValue && value === "radio" &&
    84467178                                        jQuery.nodeName( elem, "input" ) ) {
    8447 
    8448                                         // Setting the type on a radio button after the value resets the value in IE8-9
    8449                                         // Reset value to default in case type is set after value during creation
    84507179                                        var val = elem.value;
    84517180                                        elem.setAttribute( "type", value );
     
    84727201
    84737202                                        // Set corresponding property to false
    8474                                         if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
    8475                                                 elem[ propName ] = false;
    8476 
    8477                                         // Support: IE<9
    8478                                         // Also clear defaultChecked/defaultSelected (if appropriate)
    8479                                         } else {
    8480                                                 elem[ jQuery.camelCase( "default-" + name ) ] =
    8481                                                         elem[ propName ] = false;
    8482                                         }
    8483 
    8484                                 // See #9699 for explanation of this approach (setting first, then removal)
    8485                                 } else {
    8486                                         jQuery.attr( elem, name, "" );
    8487                                 }
    8488 
    8489                                 elem.removeAttribute( getSetAttribute ? name : propName );
     7203                                        elem[ propName ] = false;
     7204                                }
     7205
     7206                                elem.removeAttribute( name );
    84907207                        }
    84917208                }
     
    85007217                        // Remove boolean attributes when set to false
    85017218                        jQuery.removeAttr( elem, name );
    8502                 } else if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
    8503 
    8504                         // IE<8 needs the *property* name
    8505                         elem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name );
    8506 
    85077219                } else {
    8508 
    8509                         // Support: IE<9
    8510                         // Use defaultChecked and defaultSelected for oldIE
    8511                         elem[ jQuery.camelCase( "default-" + name ) ] = elem[ name ] = true;
     7220                        elem.setAttribute( name, name );
    85127221                }
    85137222                return name;
    85147223        }
    85157224};
    8516 
    85177225jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
    85187226        var getter = attrHandle[ name ] || jQuery.find.attr;
    85197227
    8520         if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
    8521                 attrHandle[ name ] = function( elem, name, isXML ) {
    8522                         var ret, handle;
    8523                         if ( !isXML ) {
    8524 
    8525                                 // Avoid an infinite loop by temporarily removing this function from the getter
    8526                                 handle = attrHandle[ name ];
    8527                                 attrHandle[ name ] = ret;
    8528                                 ret = getter( elem, name, isXML ) != null ?
    8529                                         name.toLowerCase() :
    8530                                         null;
    8531                                 attrHandle[ name ] = handle;
    8532                         }
    8533                         return ret;
    8534                 };
    8535         } else {
    8536                 attrHandle[ name ] = function( elem, name, isXML ) {
    8537                         if ( !isXML ) {
    8538                                 return elem[ jQuery.camelCase( "default-" + name ) ] ?
    8539                                         name.toLowerCase() :
    8540                                         null;
    8541                         }
    8542                 };
    8543         }
     7228        attrHandle[ name ] = function( elem, name, isXML ) {
     7229                var ret, handle;
     7230                if ( !isXML ) {
     7231
     7232                        // Avoid an infinite loop by temporarily removing this function from the getter
     7233                        handle = attrHandle[ name ];
     7234                        attrHandle[ name ] = ret;
     7235                        ret = getter( elem, name, isXML ) != null ?
     7236                                name.toLowerCase() :
     7237                                null;
     7238                        attrHandle[ name ] = handle;
     7239                }
     7240                return ret;
     7241        };
    85447242} );
    85457243
    8546 // fix oldIE attroperties
    8547 if ( !getSetInput || !getSetAttribute ) {
    8548         jQuery.attrHooks.value = {
    8549                 set: function( elem, value, name ) {
    8550                         if ( jQuery.nodeName( elem, "input" ) ) {
    8551 
    8552                                 // Does not return so that setAttribute is also used
    8553                                 elem.defaultValue = value;
    8554                         } else {
    8555 
    8556                                 // Use nodeHook if defined (#1954); otherwise setAttribute is fine
    8557                                 return nodeHook && nodeHook.set( elem, value, name );
    8558                         }
    8559                 }
    8560         };
    8561 }
    8562 
    8563 // IE6/7 do not support getting/setting some attributes with get/setAttribute
    8564 if ( !getSetAttribute ) {
    8565 
    8566         // Use this for any attribute in IE6/7
    8567         // This fixes almost every IE6/7 issue
    8568         nodeHook = {
    8569                 set: function( elem, value, name ) {
    8570 
    8571                         // Set the existing or create a new attribute node
    8572                         var ret = elem.getAttributeNode( name );
    8573                         if ( !ret ) {
    8574                                 elem.setAttributeNode(
    8575                                         ( ret = elem.ownerDocument.createAttribute( name ) )
    8576                                 );
    8577                         }
    8578 
    8579                         ret.value = value += "";
    8580 
    8581                         // Break association with cloned elements by also using setAttribute (#9646)
    8582                         if ( name === "value" || value === elem.getAttribute( name ) ) {
    8583                                 return value;
    8584                         }
    8585                 }
    8586         };
    8587 
    8588         // Some attributes are constructed with empty-string values when not defined
    8589         attrHandle.id = attrHandle.name = attrHandle.coords =
    8590                 function( elem, name, isXML ) {
    8591                         var ret;
    8592                         if ( !isXML ) {
    8593                                 return ( ret = elem.getAttributeNode( name ) ) && ret.value !== "" ?
    8594                                         ret.value :
    8595                                         null;
    8596                         }
    8597                 };
    8598 
    8599         // Fixing value retrieval on a button requires this module
    8600         jQuery.valHooks.button = {
    8601                 get: function( elem, name ) {
    8602                         var ret = elem.getAttributeNode( name );
    8603                         if ( ret && ret.specified ) {
    8604                                 return ret.value;
    8605                         }
    8606                 },
    8607                 set: nodeHook.set
    8608         };
    8609 
    8610         // Set contenteditable to false on removals(#10429)
    8611         // Setting to empty string throws an error as an invalid value
    8612         jQuery.attrHooks.contenteditable = {
    8613                 set: function( elem, value, name ) {
    8614                         nodeHook.set( elem, value === "" ? false : value, name );
    8615                 }
    8616         };
    8617 
    8618         // Set width and height to auto instead of 0 on empty string( Bug #8150 )
    8619         // This is for removals
    8620         jQuery.each( [ "width", "height" ], function( i, name ) {
    8621                 jQuery.attrHooks[ name ] = {
    8622                         set: function( elem, value ) {
    8623                                 if ( value === "" ) {
    8624                                         elem.setAttribute( name, "auto" );
    8625                                         return value;
    8626                                 }
    8627                         }
    8628                 };
    8629         } );
    8630 }
    8631 
    8632 if ( !support.style ) {
    8633         jQuery.attrHooks.style = {
    8634                 get: function( elem ) {
    8635 
    8636                         // Return undefined in the case of empty string
    8637                         // Note: IE uppercases css property names, but if we were to .toLowerCase()
    8638                         // .cssText, that would destroy case sensitivity in URL's, like in "background"
    8639                         return elem.style.cssText || undefined;
    8640                 },
    8641                 set: function( elem, value ) {
    8642                         return ( elem.style.cssText = value + "" );
    8643                 }
    8644         };
    8645 }
    8646 
    8647 
    8648 
    8649 
    8650 var rfocusable = /^(?:input|select|textarea|button|object)$/i,
     7244
     7245
     7246
     7247var rfocusable = /^(?:input|select|textarea|button)$/i,
    86517248        rclickable = /^(?:a|area)$/i;
    86527249
     
    86577254
    86587255        removeProp: function( name ) {
    8659                 name = jQuery.propFix[ name ] || name;
    86607256                return this.each( function() {
    8661 
    8662                         // try/catch handles cases where IE balks (such as removing a property on window)
    8663                         try {
    8664                                 this[ name ] = undefined;
    8665                                 delete this[ name ];
    8666                         } catch ( e ) {}
     7257                        delete this[ jQuery.propFix[ name ] || name ];
    86677258                } );
    86687259        }
     
    87287319} );
    87297320
    8730 // Some attributes require a special call on IE
    8731 // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
    8732 if ( !support.hrefNormalized ) {
    8733 
    8734         // href/src property should get the full normalized URL (#10299/#12915)
    8735         jQuery.each( [ "href", "src" ], function( i, name ) {
    8736                 jQuery.propHooks[ name ] = {
    8737                         get: function( elem ) {
    8738                                 return elem.getAttribute( name, 4 );
    8739                         }
    8740                 };
    8741         } );
    8742 }
    8743 
    8744 // Support: Safari, IE9+
     7321// Support: IE <=11 only
    87457322// Accessing the selectedIndex property
    87467323// forces the browser to respect setting selected
     
    87527329                get: function( elem ) {
    87537330                        var parent = elem.parentNode;
    8754 
    8755                         if ( parent ) {
    8756                                 parent.selectedIndex;
    8757 
    8758                                 // Make sure that it also works with optgroups, see #5701
    8759                                 if ( parent.parentNode ) {
    8760                                         parent.parentNode.selectedIndex;
    8761                                 }
     7331                        if ( parent && parent.parentNode ) {
     7332                                parent.parentNode.selectedIndex;
    87627333                        }
    87637334                        return null;
     
    87917362} );
    87927363
    8793 // IE6/7 call enctype encoding
    8794 if ( !support.enctype ) {
    8795         jQuery.propFix.enctype = "encoding";
    8796 }
    8797 
    87987364
    87997365
     
    88027368
    88037369function getClass( elem ) {
    8804         return jQuery.attr( elem, "class" ) || "";
     7370        return elem.getAttribute && elem.getAttribute( "class" ) || "";
    88057371}
    88067372
     
    88327398                                        }
    88337399
    8834                                         // only assign if different to avoid unneeded rendering.
     7400                                        // Only assign if different to avoid unneeded rendering.
    88357401                                        finalValue = jQuery.trim( cur );
    88367402                                        if ( curValue !== finalValue ) {
    8837                                                 jQuery.attr( elem, "class", finalValue );
     7403                                                elem.setAttribute( "class", finalValue );
    88387404                                        }
    88397405                                }
     
    88817447                                        finalValue = jQuery.trim( cur );
    88827448                                        if ( curValue !== finalValue ) {
    8883                                                 jQuery.attr( elem, "class", finalValue );
     7449                                                elem.setAttribute( "class", finalValue );
    88847450                                        }
    88857451                                }
     
    89317497                                if ( className ) {
    89327498
    8933                                         // store className if set
    8934                                         jQuery._data( this, "__className__", className );
    8935                                 }
    8936 
    8937                                 // If the element has a class name or if we're passed "false",
     7499                                        // Store className if set
     7500                                        dataPriv.set( this, "__className__", className );
     7501                                }
     7502
     7503                                // If the element has a class name or if we're passed `false`,
    89387504                                // then remove the whole classname (if there was one, the above saved it).
    89397505                                // Otherwise bring back whatever was previously saved (if anything),
    89407506                                // falling back to the empty string if nothing was stored.
    8941                                 jQuery.attr( this, "class",
    8942                                         className || value === false ?
    8943                                         "" :
    8944                                         jQuery._data( this, "__className__" ) || ""
    8945                                 );
     7507                                if ( this.setAttribute ) {
     7508                                        this.setAttribute( "class",
     7509                                                className || value === false ?
     7510                                                "" :
     7511                                                dataPriv.get( this, "__className__" ) || ""
     7512                                        );
     7513                                }
    89467514                        }
    89477515                } );
     
    89697537
    89707538
     7539var rreturn = /\r/g,
     7540        rspaces = /[\x20\t\r\n\f]+/g;
     7541
     7542jQuery.fn.extend( {
     7543        val: function( value ) {
     7544                var hooks, ret, isFunction,
     7545                        elem = this[ 0 ];
     7546
     7547                if ( !arguments.length ) {
     7548                        if ( elem ) {
     7549                                hooks = jQuery.valHooks[ elem.type ] ||
     7550                                        jQuery.valHooks[ elem.nodeName.toLowerCase() ];
     7551
     7552                                if ( hooks &&
     7553                                        "get" in hooks &&
     7554                                        ( ret = hooks.get( elem, "value" ) ) !== undefined
     7555                                ) {
     7556                                        return ret;
     7557                                }
     7558
     7559                                ret = elem.value;
     7560
     7