Changeset 18630


Ignore:
Timestamp:
10/12/12 22:32:30 (7 years ago)
Author:
rvelices
Message:

feature 2771: upgrade jquery from 1.7.2 to 1.8.2 and jquery.ui from 1.8.16 to 1.9.0
Attention plugins: jquery ui effect script ids change when using combine_script because file names changed ...

Location:
trunk
Files:
27 added
29 deleted
104 edited

Legend:

Unmodified
Added
Removed
  • trunk/admin/themes/default/template/plugins_new.tpl

    r11222 r18630  
    11{combine_script id='jquery.sort' load='footer' path='themes/default/js/plugins/jquery.sort.js'} 
    22 
    3 {footer_script require='jquery.effects.blind,jquery.sort'}{literal} 
     3{footer_script require='jquery.ui.effect-blind,jquery.sort'}{literal} 
    44var sortOrder = 'date'; 
    55var sortPlugins = (function(a, b) { 
  • trunk/admin/themes/default/template/updates_ext.tpl

    r12427 r18630  
    33{combine_css path="admin/themes/default/uploadify.jGrowl.css"} 
    44 
    5 {footer_script require='jquery.effects.blind,jquery.ajaxmanager,jquery.jgrowl'} 
     5{footer_script require='jquery.ui.effect-blind,jquery.ajaxmanager,jquery.jgrowl'} 
    66var pwg_token = '{$PWG_TOKEN}'; 
    77var extType = '{$EXT_TYPE}'; 
  • trunk/include/template.class.php

    r17675 r18630  
    543543    $minw=null; 
    544544    $minh=null; 
    545      
     545 
    546546    if (isset($params['crop'])) 
    547547    { 
     
    937937      'jquery' => 'themes/default/js/jquery.min.js', 
    938938      'jquery.ui' => 'themes/default/js/ui/minified/jquery.ui.core.min.js', 
    939       'jquery.effects' => 'themes/default/js/ui/minified/jquery.effects.core.min.js', 
     939      'jquery.ui.effect' => 'themes/default/js/ui/minified/jquery.ui.effect.min.js', 
    940940    ); 
    941941 
     
    11541154      $required_ids = array('jquery'); 
    11551155 
    1156       if ( strncmp($id, 'jquery.ui.', 10)==0 ) 
     1156      if ( strncmp($id, 'jquery.ui.effect-', 17)==0 ) 
     1157      { 
     1158        $required_ids = array('jquery', 'jquery.ui.effect'); 
     1159 
     1160        if ( empty($script->path) ) 
     1161          $script->path = dirname(self::$known_paths['jquery.ui.effect'])."/$id.min.js"; 
     1162      } 
     1163      elseif ( strncmp($id, 'jquery.ui.', 10)==0 ) 
    11571164      { 
    11581165        if ( !isset(self::$ui_core_dependencies[$id]) ) 
     
    11621169          $script->path = dirname(self::$known_paths['jquery.ui'])."/$id.min.js"; 
    11631170      } 
    1164       elseif ( strncmp($id, 'jquery.effects.', 15)==0 ) 
    1165       { 
    1166         $required_ids = array('jquery', 'jquery.effects'); 
    1167  
    1168         if ( empty($script->path) ) 
    1169           $script->path = dirname(self::$known_paths['jquery.effects'])."/$id.min.js"; 
    1170       } 
    11711171 
    11721172      foreach ($required_ids as $required_id) 
     
    11801180  private function load_known_required_script($id, $load_mode) 
    11811181  { 
    1182     if ( isset(self::$known_paths[$id]) or strncmp($id, 'jquery.ui.', 10)==0 or strncmp($id, 'jquery.effects.', 15)==0 ) 
     1182    if ( isset(self::$known_paths[$id]) or strncmp($id, 'jquery.ui.', 10)==0 ) 
    11831183    { 
    11841184      $this->add($id, $load_mode, array(), null); 
  • trunk/themes/default/js/jquery.js

    r14027 r18630  
    11/*! 
    2  * jQuery JavaScript Library v1.7.2 
     2 * jQuery JavaScript Library v1.8.2 
    33 * http://jquery.com/ 
    4  * 
    5  * Copyright 2011, John Resig 
    6  * Dual licensed under the MIT or GPL Version 2 licenses. 
    7  * http://jquery.org/license 
    84 * 
    95 * Includes Sizzle.js 
    106 * http://sizzlejs.com/ 
    11  * Copyright 2011, The Dojo Foundation 
    12  * Released under the MIT, BSD, and GPL Licenses. 
    137 * 
    14  * Date: Wed Mar 21 12:46:34 2012 -0700 
     8 * Copyright 2012 jQuery Foundation and other contributors 
     9 * Released under the MIT license 
     10 * http://jquery.org/license 
     11 * 
     12 * Date: Thu Sep 20 2012 21:13:05 GMT-0400 (Eastern Daylight Time) 
    1513 */ 
    1614(function( window, undefined ) { 
    17  
    18 // Use the correct document accordingly with window argument (sandbox) 
    19 var document = window.document, 
     15var 
     16        // A central reference to the root jQuery(document) 
     17        rootjQuery, 
     18 
     19        // The deferred used on DOM ready 
     20        readyList, 
     21 
     22        // Use the correct document accordingly with window argument (sandbox) 
     23        document = window.document, 
     24        location = window.location, 
    2025        navigator = window.navigator, 
    21         location = window.location; 
    22 var jQuery = (function() { 
    23  
    24 // Define a local copy of jQuery 
    25 var jQuery = function( selector, context ) { 
     26 
     27        // Map over jQuery in case of overwrite 
     28        _jQuery = window.jQuery, 
     29 
     30        // Map over the $ in case of overwrite 
     31        _$ = window.$, 
     32 
     33        // Save a reference to some core methods 
     34        core_push = Array.prototype.push, 
     35        core_slice = Array.prototype.slice, 
     36        core_indexOf = Array.prototype.indexOf, 
     37        core_toString = Object.prototype.toString, 
     38        core_hasOwn = Object.prototype.hasOwnProperty, 
     39        core_trim = String.prototype.trim, 
     40 
     41        // Define a local copy of jQuery 
     42        jQuery = function( selector, context ) { 
    2643                // The jQuery object is actually just the init constructor 'enhanced' 
    2744                return new jQuery.fn.init( selector, context, rootjQuery ); 
    2845        }, 
    2946 
    30         // Map over jQuery in case of overwrite 
    31         _jQuery = window.jQuery, 
    32  
    33         // Map over the $ in case of overwrite 
    34         _$ = window.$, 
    35  
    36         // A central reference to the root jQuery(document) 
    37         rootjQuery, 
    38  
    39         // A simple way to check for HTML strings or ID strings 
     47        // Used for matching numbers 
     48        core_pnum = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source, 
     49 
     50        // Used for detecting and trimming whitespace 
     51        core_rnotwhite = /\S/, 
     52        core_rspace = /\s+/, 
     53 
     54        // Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE) 
     55        rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, 
     56 
     57        // A simple way to check for HTML strings 
    4058        // Prioritize #id over <tag> to avoid XSS via location.hash (#9521) 
    41         quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/, 
    42  
    43         // Check if a string has a non-whitespace character in it 
    44         rnotwhite = /\S/, 
    45  
    46         // Used for trimming whitespace 
    47         trimLeft = /^\s+/, 
    48         trimRight = /\s+$/, 
     59        rquickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/, 
    4960 
    5061        // Match a standalone tag 
    51         rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/, 
     62        rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/, 
    5263 
    5364        // JSON RegExp 
    5465        rvalidchars = /^[\],:{}\s]*$/, 
    55         rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, 
    56         rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, 
    5766        rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g, 
    58  
    59         // Useragent RegExp 
    60         rwebkit = /(webkit)[ \/]([\w.]+)/, 
    61         ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/, 
    62         rmsie = /(msie) ([\w.]+)/, 
    63         rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/, 
     67        rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g, 
     68        rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d\d*\.|)\d+(?:[eE][\-+]?\d+|)/g, 
    6469 
    6570        // Matches dashed string for camelizing 
    66         rdashAlpha = /-([a-z]|[0-9])/ig, 
    6771        rmsPrefix = /^-ms-/, 
     72        rdashAlpha = /-([\da-z])/gi, 
    6873 
    6974        // Used by jQuery.camelCase as callback to replace() 
     
    7277        }, 
    7378 
    74         // Keep a UserAgent string for use with jQuery.browser 
    75         userAgent = navigator.userAgent, 
    76  
    77         // For matching the engine and version of the browser 
    78         browserMatch, 
    79  
    80         // The deferred used on DOM ready 
    81         readyList, 
    82  
    83         // The ready event handler 
    84         DOMContentLoaded, 
    85  
    86         // Save a reference to some core methods 
    87         toString = Object.prototype.toString, 
    88         hasOwn = Object.prototype.hasOwnProperty, 
    89         push = Array.prototype.push, 
    90         slice = Array.prototype.slice, 
    91         trim = String.prototype.trim, 
    92         indexOf = Array.prototype.indexOf, 
     79        // The ready event handler and self cleanup method 
     80        DOMContentLoaded = function() { 
     81                if ( document.addEventListener ) { 
     82                        document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false ); 
     83                        jQuery.ready(); 
     84                } else if ( document.readyState === "complete" ) { 
     85                        // we're here because readyState === "complete" in oldIE 
     86                        // which is good enough for us to call the dom ready! 
     87                        document.detachEvent( "onreadystatechange", DOMContentLoaded ); 
     88                        jQuery.ready(); 
     89                } 
     90        }, 
    9391 
    9492        // [[Class]] -> type pairs 
     
    10098                var match, elem, ret, doc; 
    10199 
    102                 // Handle $(""), $(null), or $(undefined) 
     100                // Handle $(""), $(null), $(undefined), $(false) 
    103101                if ( !selector ) { 
    104102                        return this; 
     
    112110                } 
    113111 
    114                 // The body element only exists once, optimize finding it 
    115                 if ( selector === "body" && !context && document.body ) { 
    116                         this.context = document; 
    117                         this[0] = document.body; 
    118                         this.selector = selector; 
    119                         this.length = 1; 
    120                         return this; 
    121                 } 
    122  
    123112                // Handle HTML strings 
    124113                if ( typeof selector === "string" ) { 
    125                         // Are we dealing with HTML string or an ID? 
    126114                        if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) { 
    127115                                // Assume that strings that start and end with <> are HTML and skip the regex check 
     
    129117 
    130118                        } else { 
    131                                 match = quickExpr.exec( selector ); 
    132                         } 
    133  
    134                         // Verify a match, and that no context was specified for #id 
     119                                match = rquickExpr.exec( selector ); 
     120                        } 
     121 
     122                        // Match html or make sure no context is specified for #id 
    135123                        if ( match && (match[1] || !context) ) { 
    136124 
     
    138126                                if ( match[1] ) { 
    139127                                        context = context instanceof jQuery ? context[0] : context; 
    140                                         doc = ( context ? context.ownerDocument || context : document ); 
    141  
    142                                         // If a single string is passed in and it's a single tag 
    143                                         // just do a createElement and skip the rest 
    144                                         ret = rsingleTag.exec( selector ); 
    145  
    146                                         if ( ret ) { 
    147                                                 if ( jQuery.isPlainObject( context ) ) { 
    148                                                         selector = [ document.createElement( ret[1] ) ]; 
    149                                                         jQuery.fn.attr.call( selector, context, true ); 
    150  
    151                                                 } else { 
    152                                                         selector = [ doc.createElement( ret[1] ) ]; 
    153                                                 } 
    154  
    155                                         } else { 
    156                                                 ret = jQuery.buildFragment( [ match[1] ], [ doc ] ); 
    157                                                 selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes; 
     128                                        doc = ( context && context.nodeType ? context.ownerDocument || context : document ); 
     129 
     130                                        // scripts is true for back-compat 
     131                                        selector = jQuery.parseHTML( match[1], doc, true ); 
     132                                        if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) { 
     133                                                this.attr.call( selector, context, true ); 
    158134                                        } 
    159135 
    160136                                        return jQuery.merge( this, selector ); 
    161137 
    162                                 // HANDLE: $("#id") 
     138                                // HANDLE: $(#id) 
    163139                                } else { 
    164140                                        elem = document.getElementById( match[2] ); 
     
    211187 
    212188        // The current version of jQuery being used 
    213         jquery: "1.7.2", 
     189        jquery: "1.8.2", 
    214190 
    215191        // The default length of a jQuery object is 0 
     
    222198 
    223199        toArray: function() { 
    224                 return slice.call( this, 0 ); 
     200                return core_slice.call( this ); 
    225201        }, 
    226202 
     
    240216        // (returning the new matched element set) 
    241217        pushStack: function( elems, name, selector ) { 
     218 
    242219                // Build a new jQuery matched element set 
    243                 var ret = this.constructor(); 
    244  
    245                 if ( jQuery.isArray( elems ) ) { 
    246                         push.apply( ret, elems ); 
    247  
    248                 } else { 
    249                         jQuery.merge( ret, elems ); 
    250                 } 
     220                var ret = jQuery.merge( this.constructor(), elems ); 
    251221 
    252222                // Add the old object onto the stack (as a reference) 
     
    273243 
    274244        ready: function( fn ) { 
    275                 // Attach the listeners 
    276                 jQuery.bindReady(); 
    277  
    278245                // Add the callback 
    279                 readyList.add( fn ); 
     246                jQuery.ready.promise().done( fn ); 
    280247 
    281248                return this; 
     
    298265 
    299266        slice: function() { 
    300                 return this.pushStack( slice.apply( this, arguments ), 
    301                         "slice", slice.call(arguments).join(",") ); 
     267                return this.pushStack( core_slice.apply( this, arguments ), 
     268                        "slice", core_slice.call(arguments).join(",") ); 
    302269        }, 
    303270 
     
    314281        // For internal use only. 
    315282        // Behaves like an Array's method, not like a jQuery method. 
    316         push: push, 
     283        push: core_push, 
    317284        sort: [].sort, 
    318285        splice: [].splice 
     
    417384        // Handle when the DOM is ready 
    418385        ready: function( wait ) { 
    419                 // Either a released hold or an DOMready/load event and not yet ready 
    420                 if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) { 
    421                         // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). 
    422                         if ( !document.body ) { 
    423                                 return setTimeout( jQuery.ready, 1 ); 
    424                         } 
    425  
    426                         // Remember that the DOM is ready 
    427                         jQuery.isReady = true; 
    428  
    429                         // If a normal DOM Ready event fired, decrement, and wait if need be 
    430                         if ( wait !== true && --jQuery.readyWait > 0 ) { 
    431                                 return; 
    432                         } 
    433  
    434                         // If there are functions bound, to execute 
    435                         readyList.fireWith( document, [ jQuery ] ); 
    436  
    437                         // Trigger any bound ready events 
    438                         if ( jQuery.fn.trigger ) { 
    439                                 jQuery( document ).trigger( "ready" ).off( "ready" ); 
    440                         } 
    441                 } 
    442         }, 
    443  
    444         bindReady: function() { 
    445                 if ( readyList ) { 
     386 
     387                // Abort if there are pending holds or we're already ready 
     388                if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { 
    446389                        return; 
    447390                } 
    448391 
    449                 readyList = jQuery.Callbacks( "once memory" ); 
    450  
    451                 // Catch cases where $(document).ready() is called after the 
    452                 // browser event has already occurred. 
    453                 if ( document.readyState === "complete" ) { 
    454                         // Handle it asynchronously to allow scripts the opportunity to delay ready 
     392                // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). 
     393                if ( !document.body ) { 
    455394                        return setTimeout( jQuery.ready, 1 ); 
    456395                } 
    457396 
    458                 // Mozilla, Opera and webkit nightlies currently support this event 
    459                 if ( document.addEventListener ) { 
    460                         // Use the handy event callback 
    461                         document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false ); 
    462  
    463                         // A fallback to window.onload, that will always work 
    464                         window.addEventListener( "load", jQuery.ready, false ); 
    465  
    466                 // If IE event model is used 
    467                 } else if ( document.attachEvent ) { 
    468                         // ensure firing before onload, 
    469                         // maybe late but safe also for iframes 
    470                         document.attachEvent( "onreadystatechange", DOMContentLoaded ); 
    471  
    472                         // A fallback to window.onload, that will always work 
    473                         window.attachEvent( "onload", jQuery.ready ); 
    474  
    475                         // If IE and not a frame 
    476                         // continually check to see if the document is ready 
    477                         var toplevel = false; 
    478  
    479                         try { 
    480                                 toplevel = window.frameElement == null; 
    481                         } catch(e) {} 
    482  
    483                         if ( document.documentElement.doScroll && toplevel ) { 
    484                                 doScrollCheck(); 
    485                         } 
     397                // Remember that the DOM is ready 
     398                jQuery.isReady = true; 
     399 
     400                // If a normal DOM Ready event fired, decrement, and wait if need be 
     401                if ( wait !== true && --jQuery.readyWait > 0 ) { 
     402                        return; 
     403                } 
     404 
     405                // If there are functions bound, to execute 
     406                readyList.resolveWith( document, [ jQuery ] ); 
     407 
     408                // Trigger any bound ready events 
     409                if ( jQuery.fn.trigger ) { 
     410                        jQuery( document ).trigger("ready").off("ready"); 
    486411                } 
    487412        }, 
     
    509434                return obj == null ? 
    510435                        String( obj ) : 
    511                         class2type[ toString.call(obj) ] || "object"; 
     436                        class2type[ core_toString.call(obj) ] || "object"; 
    512437        }, 
    513438 
     
    523448                        // Not own constructor property must be Object 
    524449                        if ( obj.constructor && 
    525                                 !hasOwn.call(obj, "constructor") && 
    526                                 !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) { 
     450                                !core_hasOwn.call(obj, "constructor") && 
     451                                !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) { 
    527452                                return false; 
    528453                        } 
     
    538463                for ( key in obj ) {} 
    539464 
    540                 return key === undefined || hasOwn.call( obj, key ); 
     465                return key === undefined || core_hasOwn.call( obj, key ); 
    541466        }, 
    542467 
    543468        isEmptyObject: function( obj ) { 
    544                 for ( var name in obj ) { 
     469                var name; 
     470                for ( name in obj ) { 
    545471                        return false; 
    546472                } 
     
    552478        }, 
    553479 
     480        // data: string of html 
     481        // context (optional): If specified, the fragment will be created in this context, defaults to document 
     482        // scripts (optional): If true, will include scripts passed in the html string 
     483        parseHTML: function( data, context, scripts ) { 
     484                var parsed; 
     485                if ( !data || typeof data !== "string" ) { 
     486                        return null; 
     487                } 
     488                if ( typeof context === "boolean" ) { 
     489                        scripts = context; 
     490                        context = 0; 
     491                } 
     492                context = context || document; 
     493 
     494                // Single tag 
     495                if ( (parsed = rsingleTag.exec( data )) ) { 
     496                        return [ context.createElement( parsed[1] ) ]; 
     497                } 
     498 
     499                parsed = jQuery.buildFragment( [ data ], context, scripts ? null : [] ); 
     500                return jQuery.merge( [], 
     501                        (parsed.cacheable ? jQuery.clone( parsed.fragment ) : parsed.fragment).childNodes ); 
     502        }, 
     503 
    554504        parseJSON: function( data ) { 
    555                 if ( typeof data !== "string" || !data ) { 
     505                if ( !data || typeof data !== "string") { 
    556506                        return null; 
    557507                } 
     
    579529        // Cross-browser xml parsing 
    580530        parseXML: function( data ) { 
    581                 if ( typeof data !== "string" || !data ) { 
     531                var xml, tmp; 
     532                if ( !data || typeof data !== "string" ) { 
    582533                        return null; 
    583534                } 
    584                 var xml, tmp; 
    585535                try { 
    586536                        if ( window.DOMParser ) { // Standard 
     
    607557        // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context 
    608558        globalEval: function( data ) { 
    609                 if ( data && rnotwhite.test( data ) ) { 
     559                if ( data && core_rnotwhite.test( data ) ) { 
    610560                        // We use execScript on Internet Explorer 
    611561                        // We use an anonymous function so that context is window 
     
    624574 
    625575        nodeName: function( elem, name ) { 
    626                 return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase(); 
     576                return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); 
    627577        }, 
    628578 
    629579        // args is for internal usage only 
    630         each: function( object, callback, args ) { 
    631                 var name, i = 0, 
    632                         length = object.length, 
    633                         isObj = length === undefined || jQuery.isFunction( object ); 
     580        each: function( obj, callback, args ) { 
     581                var name, 
     582                        i = 0, 
     583                        length = obj.length, 
     584                        isObj = length === undefined || jQuery.isFunction( obj ); 
    634585 
    635586                if ( args ) { 
    636587                        if ( isObj ) { 
    637                                 for ( name in object ) { 
    638                                         if ( callback.apply( object[ name ], args ) === false ) { 
     588                                for ( name in obj ) { 
     589                                        if ( callback.apply( obj[ name ], args ) === false ) { 
    639590                                                break; 
    640591                                        } 
     
    642593                        } else { 
    643594                                for ( ; i < length; ) { 
    644                                         if ( callback.apply( object[ i++ ], args ) === false ) { 
     595                                        if ( callback.apply( obj[ i++ ], args ) === false ) { 
    645596                                                break; 
    646597                                        } 
     
    651602                } else { 
    652603                        if ( isObj ) { 
    653                                 for ( name in object ) { 
    654                                         if ( callback.call( object[ name ], name, object[ name ] ) === false ) { 
     604                                for ( name in obj ) { 
     605                                        if ( callback.call( obj[ name ], name, obj[ name ] ) === false ) { 
    655606                                                break; 
    656607                                        } 
     
    658609                        } else { 
    659610                                for ( ; i < length; ) { 
    660                                         if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) { 
     611                                        if ( callback.call( obj[ i ], i, obj[ i++ ] ) === false ) { 
    661612                                                break; 
    662613                                        } 
     
    665616                } 
    666617 
    667                 return object; 
     618                return obj; 
    668619        }, 
    669620 
    670621        // Use native String.trim function wherever possible 
    671         trim: trim ? 
     622        trim: core_trim && !core_trim.call("\uFEFF\xA0") ? 
    672623                function( text ) { 
    673624                        return text == null ? 
    674625                                "" : 
    675                                 trim.call( text ); 
     626                                core_trim.call( text ); 
    676627                } : 
    677628 
     
    680631                        return text == null ? 
    681632                                "" : 
    682                                 text.toString().replace( trimLeft, "" ).replace( trimRight, "" ); 
     633                                ( text + "" ).replace( rtrim, "" ); 
    683634                }, 
    684635 
    685636        // results is for internal usage only 
    686         makeArray: function( array, results ) { 
    687                 var ret = results || []; 
    688  
    689                 if ( array != null ) { 
     637        makeArray: function( arr, results ) { 
     638                var type, 
     639                        ret = results || []; 
     640 
     641                if ( arr != null ) { 
    690642                        // The window, strings (and functions) also have 'length' 
    691643                        // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930 
    692                         var type = jQuery.type( array ); 
    693  
    694                         if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) { 
    695                                 push.call( ret, array ); 
     644                        type = jQuery.type( arr ); 
     645 
     646                        if ( arr.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( arr ) ) { 
     647                                core_push.call( ret, arr ); 
    696648                        } else { 
    697                                 jQuery.merge( ret, array ); 
     649                                jQuery.merge( ret, arr ); 
    698650                        } 
    699651                } 
     
    702654        }, 
    703655 
    704         inArray: function( elem, array, i ) { 
     656        inArray: function( elem, arr, i ) { 
    705657                var len; 
    706658 
    707                 if ( array ) { 
    708                         if ( indexOf ) { 
    709                                 return indexOf.call( array, elem, i ); 
    710                         } 
    711  
    712                         len = array.length; 
     659                if ( arr ) { 
     660                        if ( core_indexOf ) { 
     661                                return core_indexOf.call( arr, elem, i ); 
     662                        } 
     663 
     664                        len = arr.length; 
    713665                        i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0; 
    714666 
    715667                        for ( ; i < len; i++ ) { 
    716668                                // Skip accessing in sparse arrays 
    717                                 if ( i in array && array[ i ] === elem ) { 
     669                                if ( i in arr && arr[ i ] === elem ) { 
    718670                                        return i; 
    719671                                } 
     
    725677 
    726678        merge: function( first, second ) { 
    727                 var i = first.length, 
     679                var l = second.length, 
     680                        i = first.length, 
    728681                        j = 0; 
    729682 
    730                 if ( typeof second.length === "number" ) { 
    731                         for ( var l = second.length; j < l; j++ ) { 
     683                if ( typeof l === "number" ) { 
     684                        for ( ; j < l; j++ ) { 
    732685                                first[ i++ ] = second[ j ]; 
    733686                        } 
     
    745698 
    746699        grep: function( elems, callback, inv ) { 
    747                 var ret = [], retVal; 
     700                var retVal, 
     701                        ret = [], 
     702                        i = 0, 
     703                        length = elems.length; 
    748704                inv = !!inv; 
    749705 
    750706                // Go through the array, only saving the items 
    751707                // that pass the validator function 
    752                 for ( var i = 0, length = elems.length; i < length; i++ ) { 
     708                for ( ; i < length; i++ ) { 
    753709                        retVal = !!callback( elems[ i ], i ); 
    754710                        if ( inv !== retVal ) { 
     
    762718        // arg is for internal usage only 
    763719        map: function( elems, callback, arg ) { 
    764                 var value, key, ret = [], 
     720                var value, key, 
     721                        ret = [], 
    765722                        i = 0, 
    766723                        length = elems.length, 
     
    799756        // arguments. 
    800757        proxy: function( fn, context ) { 
     758                var tmp, args, proxy; 
     759 
    801760                if ( typeof context === "string" ) { 
    802                         var tmp = fn[ context ]; 
     761                        tmp = fn[ context ]; 
    803762                        context = fn; 
    804763                        fn = tmp; 
     
    812771 
    813772                // Simulated bind 
    814                 var args = slice.call( arguments, 2 ), 
    815                         proxy = function() { 
    816                                 return fn.apply( context, args.concat( slice.call( arguments ) ) ); 
    817                         }; 
     773                args = core_slice.call( arguments, 2 ); 
     774                proxy = function() { 
     775                        return fn.apply( context, args.concat( core_slice.call( arguments ) ) ); 
     776                }; 
    818777 
    819778                // Set the guid of unique handler to the same of original handler, so it can be removed 
    820                 proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++; 
     779                proxy.guid = fn.guid = fn.guid || jQuery.guid++; 
    821780 
    822781                return proxy; 
    823782        }, 
    824783 
    825         // Mutifunctional method to get and set values to a collection 
     784        // Multifunctional method to get and set values of a collection 
    826785        // The value/s can optionally be executed if it's a function 
    827786        access: function( elems, fn, key, value, chainable, emptyGet, pass ) { 
     
    878837        now: function() { 
    879838                return ( new Date() ).getTime(); 
    880         }, 
    881  
    882         // Use of jQuery.browser is frowned upon. 
    883         // More details: http://docs.jquery.com/Utilities/jQuery.browser 
    884         uaMatch: function( ua ) { 
    885                 ua = ua.toLowerCase(); 
    886  
    887                 var match = rwebkit.exec( ua ) || 
    888                         ropera.exec( ua ) || 
    889                         rmsie.exec( ua ) || 
    890                         ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) || 
    891                         []; 
    892  
    893                 return { browser: match[1] || "", version: match[2] || "0" }; 
    894         }, 
    895  
    896         sub: function() { 
    897                 function jQuerySub( selector, context ) { 
    898                         return new jQuerySub.fn.init( selector, context ); 
    899                 } 
    900                 jQuery.extend( true, jQuerySub, this ); 
    901                 jQuerySub.superclass = this; 
    902                 jQuerySub.fn = jQuerySub.prototype = this(); 
    903                 jQuerySub.fn.constructor = jQuerySub; 
    904                 jQuerySub.sub = this.sub; 
    905                 jQuerySub.fn.init = function init( selector, context ) { 
    906                         if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) { 
    907                                 context = jQuerySub( context ); 
    908                         } 
    909  
    910                         return jQuery.fn.init.call( this, selector, context, rootjQuerySub ); 
    911                 }; 
    912                 jQuerySub.fn.init.prototype = jQuerySub.fn; 
    913                 var rootjQuerySub = jQuerySub(document); 
    914                 return jQuerySub; 
    915         }, 
    916  
    917         browser: {} 
     839        } 
    918840}); 
     841 
     842jQuery.ready.promise = function( obj ) { 
     843        if ( !readyList ) { 
     844 
     845                readyList = jQuery.Deferred(); 
     846 
     847                // Catch cases where $(document).ready() is called after the browser event has already occurred. 
     848                // we once tried to use readyState "interactive" here, but it caused issues like the one 
     849                // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15 
     850                if ( document.readyState === "complete" ) { 
     851                        // Handle it asynchronously to allow scripts the opportunity to delay ready 
     852                        setTimeout( jQuery.ready, 1 ); 
     853 
     854                // Standards-based browsers support DOMContentLoaded 
     855                } else if ( document.addEventListener ) { 
     856                        // Use the handy event callback 
     857                        document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false ); 
     858 
     859                        // A fallback to window.onload, that will always work 
     860                        window.addEventListener( "load", jQuery.ready, false ); 
     861 
     862                // If IE event model is used 
     863                } else { 
     864                        // Ensure firing before onload, maybe late but safe also for iframes 
     865                        document.attachEvent( "onreadystatechange", DOMContentLoaded ); 
     866 
     867                        // A fallback to window.onload, that will always work 
     868                        window.attachEvent( "onload", jQuery.ready ); 
     869 
     870                        // If IE and not a frame 
     871                        // continually check to see if the document is ready 
     872                        var top = false; 
     873 
     874                        try { 
     875                                top = window.frameElement == null && document.documentElement; 
     876                        } catch(e) {} 
     877 
     878                        if ( top && top.doScroll ) { 
     879                                (function doScrollCheck() { 
     880                                        if ( !jQuery.isReady ) { 
     881 
     882                                                try { 
     883                                                        // Use the trick by Diego Perini 
     884                                                        // http://javascript.nwbox.com/IEContentLoaded/ 
     885                                                        top.doScroll("left"); 
     886                                                } catch(e) { 
     887                                                        return setTimeout( doScrollCheck, 50 ); 
     888                                                } 
     889 
     890                                                // and execute any waiting functions 
     891                                                jQuery.ready(); 
     892                                        } 
     893                                })(); 
     894                        } 
     895                } 
     896        } 
     897        return readyList.promise( obj ); 
     898}; 
    919899 
    920900// Populate the class2type map 
     
    923903}); 
    924904 
    925 browserMatch = jQuery.uaMatch( userAgent ); 
    926 if ( browserMatch.browser ) { 
    927         jQuery.browser[ browserMatch.browser ] = true; 
    928         jQuery.browser.version = browserMatch.version; 
    929 } 
    930  
    931 // Deprecated, use jQuery.browser.webkit instead 
    932 if ( jQuery.browser.webkit ) { 
    933         jQuery.browser.safari = true; 
    934 } 
    935  
    936 // IE doesn't match non-breaking spaces with \s 
    937 if ( rnotwhite.test( "\xA0" ) ) { 
    938         trimLeft = /^[\s\xA0]+/; 
    939         trimRight = /[\s\xA0]+$/; 
    940 } 
    941  
    942905// All jQuery objects should point back to these 
    943906rootjQuery = jQuery(document); 
    944  
    945 // Cleanup functions for the document ready method 
    946 if ( document.addEventListener ) { 
    947         DOMContentLoaded = function() { 
    948                 document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false ); 
    949                 jQuery.ready(); 
    950         }; 
    951  
    952 } else if ( document.attachEvent ) { 
    953         DOMContentLoaded = function() { 
    954                 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). 
    955                 if ( document.readyState === "complete" ) { 
    956                         document.detachEvent( "onreadystatechange", DOMContentLoaded ); 
    957                         jQuery.ready(); 
    958                 } 
    959         }; 
    960 } 
    961  
    962 // The DOM ready check for Internet Explorer 
    963 function doScrollCheck() { 
    964         if ( jQuery.isReady ) { 
    965                 return; 
    966         } 
    967  
    968         try { 
    969                 // If IE is used, use the trick by Diego Perini 
    970                 // http://javascript.nwbox.com/IEContentLoaded/ 
    971                 document.documentElement.doScroll("left"); 
    972         } catch(e) { 
    973                 setTimeout( doScrollCheck, 1 ); 
    974                 return; 
    975         } 
    976  
    977         // and execute any waiting functions 
    978         jQuery.ready(); 
    979 } 
    980  
    981 return jQuery; 
    982  
    983 })(); 
    984  
    985  
    986 // String to Object flags format cache 
    987 var flagsCache = {}; 
    988  
    989 // Convert String-formatted flags into Object-formatted ones and store in cache 
    990 function createFlags( flags ) { 
    991         var object = flagsCache[ flags ] = {}, 
    992                 i, length; 
    993         flags = flags.split( /\s+/ ); 
    994         for ( i = 0, length = flags.length; i < length; i++ ) { 
    995                 object[ flags[i] ] = true; 
    996         } 
     907// String to Object options format cache 
     908var optionsCache = {}; 
     909 
     910// Convert String-formatted options into Object-formatted ones and store in cache 
     911function createOptions( options ) { 
     912        var object = optionsCache[ options ] = {}; 
     913        jQuery.each( options.split( core_rspace ), function( _, flag ) { 
     914                object[ flag ] = true; 
     915        }); 
    997916        return object; 
    998917} 
     
    1001920 * Create a callback list using the following parameters: 
    1002921 * 
    1003  *      flags:  an optional list of space-separated flags that will change how 
    1004  *                      the callback list behaves 
     922 *      options: an optional list of space-separated options that will change how 
     923 *                      the callback list behaves or a more traditional option object 
    1005924 * 
    1006925 * By default a callback list will act like an event callback list and can be 
    1007926 * "fired" multiple times. 
    1008927 * 
    1009  * Possible flags: 
     928 * Possible options: 
    1010929 * 
    1011930 *      once:                   will ensure the callback list can only be fired once (like a Deferred) 
     
    1020939 * 
    1021940 */ 
    1022 jQuery.Callbacks = function( flags ) { 
    1023  
    1024         // Convert flags from String-formatted to Object-formatted 
     941jQuery.Callbacks = function( options ) { 
     942 
     943        // Convert options from String-formatted to Object-formatted if needed 
    1025944        // (we check in cache first) 
    1026         flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {}; 
    1027  
    1028         var // Actual callback list 
    1029                 list = [], 
    1030                 // Stack of fire calls for repeatable lists 
    1031                 stack = [], 
    1032                 // Last fire value (for non-forgettable lists) 
     945        options = typeof options === "string" ? 
     946                ( optionsCache[ options ] || createOptions( options ) ) : 
     947                jQuery.extend( {}, options ); 
     948 
     949        var // Last fire value (for non-forgettable lists) 
    1033950                memory, 
    1034951                // Flag to know if list was already fired 
     
    1042959                // Index of currently firing callback (modified by remove if needed) 
    1043960                firingIndex, 
    1044                 // Add one or several callbacks to the list 
    1045                 add = function( args ) { 
    1046                         var i, 
    1047                                 length, 
    1048                                 elem, 
    1049                                 type, 
    1050                                 actual; 
    1051                         for ( i = 0, length = args.length; i < length; i++ ) { 
    1052                                 elem = args[ i ]; 
    1053                                 type = jQuery.type( elem ); 
    1054                                 if ( type === "array" ) { 
    1055                                         // Inspect recursively 
    1056                                         add( elem ); 
    1057                                 } else if ( type === "function" ) { 
    1058                                         // Add if not in unique mode and callback is not in 
    1059                                         if ( !flags.unique || !self.has( elem ) ) { 
    1060                                                 list.push( elem ); 
    1061                                         } 
    1062                                 } 
    1063                         } 
    1064                 }, 
     961                // Actual callback list 
     962                list = [], 
     963                // Stack of fire calls for repeatable lists 
     964                stack = !options.once && [], 
    1065965                // Fire callbacks 
    1066                 fire = function( context, args ) { 
    1067                         args = args || []; 
    1068                         memory = !flags.memory || [ context, args ]; 
     966                fire = function( data ) { 
     967                        memory = options.memory && data; 
    1069968                        fired = true; 
    1070                         firing = true; 
    1071969                        firingIndex = firingStart || 0; 
    1072970                        firingStart = 0; 
    1073971                        firingLength = list.length; 
     972                        firing = true; 
    1074973                        for ( ; list && firingIndex < firingLength; firingIndex++ ) { 
    1075                                 if ( list[ firingIndex ].apply( context, args ) === false && flags.stopOnFalse ) { 
    1076                                         memory = true; // Mark as halted 
     974                                if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) { 
     975                                        memory = false; // To prevent further calls using add 
    1077976                                        break; 
    1078977                                } 
     
    1080979                        firing = false; 
    1081980                        if ( list ) { 
    1082                                 if ( !flags.once ) { 
    1083                                         if ( stack && stack.length ) { 
    1084                                                 memory = stack.shift(); 
    1085                                                 self.fireWith( memory[ 0 ], memory[ 1 ] ); 
     981                                if ( stack ) { 
     982                                        if ( stack.length ) { 
     983                                                fire( stack.shift() ); 
    1086984                                        } 
    1087                                 } else if ( memory === true ) { 
     985                                } else if ( memory ) { 
     986                                        list = []; 
     987                                } else { 
    1088988                                        self.disable(); 
    1089                                 } else { 
    1090                                         list = []; 
    1091989                                } 
    1092990                        } 
     
    1097995                        add: function() { 
    1098996                                if ( list ) { 
    1099                                         var length = list.length; 
    1100                                         add( arguments ); 
     997                                        // First, we save the current length 
     998                                        var start = list.length; 
     999                                        (function add( args ) { 
     1000                                                jQuery.each( args, function( _, arg ) { 
     1001                                                        var type = jQuery.type( arg ); 
     1002                                                        if ( type === "function" && ( !options.unique || !self.has( arg ) ) ) { 
     1003                                                                list.push( arg ); 
     1004                                                        } else if ( arg && arg.length && type !== "string" ) { 
     1005                                                                // Inspect recursively 
     1006                                                                add( arg ); 
     1007                                                        } 
     1008                                                }); 
     1009                                        })( arguments ); 
    11011010                                        // Do we need to add the callbacks to the 
    11021011                                        // current firing batch? 
     
    11041013                                                firingLength = list.length; 
    11051014                                        // With memory, if we're not firing then 
    1106                                         // we should call right away, unless previous 
    1107                                         // firing was halted (stopOnFalse) 
    1108                                         } else if ( memory && memory !== true ) { 
    1109                                                 firingStart = length; 
    1110                                                 fire( memory[ 0 ], memory[ 1 ] ); 
     1015                                        // we should call right away 
     1016                                        } else if ( memory ) { 
     1017                                                firingStart = start; 
     1018                                                fire( memory ); 
    11111019                                        } 
    11121020                                } 
     
    11161024                        remove: function() { 
    11171025                                if ( list ) { 
    1118                                         var args = arguments, 
    1119                                                 argIndex = 0, 
    1120                                                 argLength = args.length; 
    1121                                         for ( ; argIndex < argLength ; argIndex++ ) { 
    1122                                                 for ( var i = 0; i < list.length; i++ ) { 
    1123                                                         if ( args[ argIndex ] === list[ i ] ) { 
    1124                                                                 // Handle firingIndex and firingLength 
    1125                                                                 if ( firing ) { 
    1126                                                                         if ( i <= firingLength ) { 
    1127                                                                                 firingLength--; 
    1128                                                                                 if ( i <= firingIndex ) { 
    1129                                                                                         firingIndex--; 
    1130                                                                                 } 
    1131                                                                         } 
     1026                                        jQuery.each( arguments, function( _, arg ) { 
     1027                                                var index; 
     1028                                                while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { 
     1029                                                        list.splice( index, 1 ); 
     1030                                                        // Handle firing indexes 
     1031                                                        if ( firing ) { 
     1032                                                                if ( index <= firingLength ) { 
     1033                                                                        firingLength--; 
    11321034                                                                } 
    1133                                                                 // Remove the element 
    1134                                                                 list.splice( i--, 1 ); 
    1135                                                                 // If we have some unicity property then 
    1136                                                                 // we only need to do this once 
    1137                                                                 if ( flags.unique ) { 
    1138                                                                         break; 
     1035                                                                if ( index <= firingIndex ) { 
     1036                                                                        firingIndex--; 
    11391037                                                                } 
    11401038                                                        } 
    11411039                                                } 
    1142                                         } 
     1040                                        }); 
    11431041                                } 
    11441042                                return this; 
     
    11461044                        // Control if a given callback is in the list 
    11471045                        has: function( fn ) { 
    1148                                 if ( list ) { 
    1149                                         var i = 0, 
    1150                                                 length = list.length; 
    1151                                         for ( ; i < length; i++ ) { 
    1152                                                 if ( fn === list[ i ] ) { 
    1153                                                         return true; 
    1154                                                 } 
    1155                                         } 
    1156                                 } 
    1157                                 return false; 
     1046                                return jQuery.inArray( fn, list ) > -1; 
    11581047                        }, 
    11591048                        // Remove all callbacks from the list 
     
    11741063                        lock: function() { 
    11751064                                stack = undefined; 
    1176                                 if ( !memory || memory === true ) { 
     1065                                if ( !memory ) { 
    11771066                                        self.disable(); 
    11781067                                } 
     
    11851074                        // Call all callbacks with the given context and arguments 
    11861075                        fireWith: function( context, args ) { 
    1187                                 if ( stack ) { 
     1076                                args = args || []; 
     1077                                args = [ context, args.slice ? args.slice() : args ]; 
     1078                                if ( list && ( !fired || stack ) ) { 
    11881079                                        if ( firing ) { 
    1189                                                 if ( !flags.once ) { 
    1190                                                         stack.push( [ context, args ] ); 
    1191                                                 } 
    1192                                         } else if ( !( flags.once && memory ) ) { 
    1193                                                 fire( context, args ); 
     1080                                                stack.push( args ); 
     1081                                        } else { 
     1082                                                fire( args ); 
    11941083                                        } 
    11951084                                } 
     
    12091098        return self; 
    12101099}; 
    1211  
    1212  
    1213  
    1214  
    1215 var // Static reference to slice 
    1216         sliceDeferred = [].slice; 
    1217  
    12181100jQuery.extend({ 
    12191101 
    12201102        Deferred: function( func ) { 
    1221                 var doneList = jQuery.Callbacks( "once memory" ), 
    1222                         failList = jQuery.Callbacks( "once memory" ), 
    1223                         progressList = jQuery.Callbacks( "memory" ), 
     1103                var tuples = [ 
     1104                                // action, add listener, listener list, final state 
     1105                                [ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ], 
     1106                                [ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ], 
     1107                                [ "notify", "progress", jQuery.Callbacks("memory") ] 
     1108                        ], 
    12241109                        state = "pending", 
    1225                         lists = { 
    1226                                 resolve: doneList, 
    1227                                 reject: failList, 
    1228                                 notify: progressList 
    1229                         }, 
    12301110                        promise = { 
    1231                                 done: doneList.add, 
    1232                                 fail: failList.add, 
    1233                                 progress: progressList.add, 
    1234  
    12351111                                state: function() { 
    12361112                                        return state; 
    12371113                                }, 
    1238  
    1239                                 // Deprecated 
    1240                                 isResolved: doneList.fired, 
    1241                                 isRejected: failList.fired, 
    1242  
    1243                                 then: function( doneCallbacks, failCallbacks, progressCallbacks ) { 
    1244                                         deferred.done( doneCallbacks ).fail( failCallbacks ).progress( progressCallbacks ); 
     1114                                always: function() { 
     1115                                        deferred.done( arguments ).fail( arguments ); 
    12451116                                        return this; 
    12461117                                }, 
    1247                                 always: function() { 
    1248                                         deferred.done.apply( deferred, arguments ).fail.apply( deferred, arguments ); 
    1249                                         return this; 
    1250                                 }, 
    1251                                 pipe: function( fnDone, fnFail, fnProgress ) { 
     1118                                then: function( /* fnDone, fnFail, fnProgress */ ) { 
     1119                                        var fns = arguments; 
    12521120                                        return jQuery.Deferred(function( newDefer ) { 
    1253                                                 jQuery.each( { 
    1254                                                         done: [ fnDone, "resolve" ], 
    1255                                                         fail: [ fnFail, "reject" ], 
    1256                                                         progress: [ fnProgress, "notify" ] 
    1257                                                 }, function( handler, data ) { 
    1258                                                         var fn = data[ 0 ], 
    1259                                                                 action = data[ 1 ], 
    1260                                                                 returned; 
    1261                                                         if ( jQuery.isFunction( fn ) ) { 
    1262                                                                 deferred[ handler ](function() { 
    1263                                                                         returned = fn.apply( this, arguments ); 
     1121                                                jQuery.each( tuples, function( i, tuple ) { 
     1122                                                        var action = tuple[ 0 ], 
     1123                                                                fn = fns[ i ]; 
     1124                                                        // deferred[ done | fail | progress ] for forwarding actions to newDefer 
     1125                                                        deferred[ tuple[1] ]( jQuery.isFunction( fn ) ? 
     1126                                                                function() { 
     1127                                                                        var returned = fn.apply( this, arguments ); 
    12641128                                                                        if ( returned && jQuery.isFunction( returned.promise ) ) { 
    1265                                                                                 returned.promise().then( newDefer.resolve, newDefer.reject, newDefer.notify ); 
     1129                                                                                returned.promise() 
     1130                                                                                        .done( newDefer.resolve ) 
     1131                                                                                        .fail( newDefer.reject ) 
     1132                                                                                        .progress( newDefer.notify ); 
    12661133                                                                        } else { 
    12671134                                                                                newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] ); 
    12681135                                                                        } 
    1269                                                                 }); 
    1270                                                         } else { 
    1271                                                                 deferred[ handler ]( newDefer[ action ] ); 
    1272                                                         } 
     1136                                                                } : 
     1137                                                                newDefer[ action ] 
     1138                                                        ); 
    12731139                                                }); 
     1140                                                fns = null; 
    12741141                                        }).promise(); 
    12751142                                }, 
     
    12771144                                // If obj is provided, the promise aspect is added to the object 
    12781145                                promise: function( obj ) { 
    1279                                         if ( obj == null ) { 
    1280                                                 obj = promise; 
    1281                                         } else { 
    1282                                                 for ( var key in promise ) { 
    1283                                                         obj[ key ] = promise[ key ]; 
    1284                                                 } 
    1285                                         } 
    1286                                         return obj; 
     1146                                        return obj != null ? jQuery.extend( obj, promise ) : promise; 
    12871147                                } 
    12881148                        }, 
    1289                         deferred = promise.promise({}), 
    1290                         key; 
    1291  
    1292                 for ( key in lists ) { 
    1293                         deferred[ key ] = lists[ key ].fire; 
    1294                         deferred[ key + "With" ] = lists[ key ].fireWith; 
    1295                 } 
    1296  
    1297                 // Handle state 
    1298                 deferred.done( function() { 
    1299                         state = "resolved"; 
    1300                 }, failList.disable, progressList.lock ).fail( function() { 
    1301                         state = "rejected"; 
    1302                 }, doneList.disable, progressList.lock ); 
     1149                        deferred = {}; 
     1150 
     1151                // Keep pipe for back-compat 
     1152                promise.pipe = promise.then; 
     1153 
     1154                // Add list-specific methods 
     1155                jQuery.each( tuples, function( i, tuple ) { 
     1156                        var list = tuple[ 2 ], 
     1157                                stateString = tuple[ 3 ]; 
     1158 
     1159                        // promise[ done | fail | progress ] = list.add 
     1160                        promise[ tuple[1] ] = list.add; 
     1161 
     1162                        // Handle state 
     1163                        if ( stateString ) { 
     1164                                list.add(function() { 
     1165                                        // state = [ resolved | rejected ] 
     1166                                        state = stateString; 
     1167 
     1168                                // [ reject_list | resolve_list ].disable; progress_list.lock 
     1169                                }, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock ); 
     1170                        } 
     1171 
     1172                        // deferred[ resolve | reject | notify ] = list.fire 
     1173                        deferred[ tuple[0] ] = list.fire; 
     1174                        deferred[ tuple[0] + "With" ] = list.fireWith; 
     1175                }); 
     1176 
     1177                // Make the deferred a promise 
     1178                promise.promise( deferred ); 
    13031179 
    13041180                // Call given func if any 
     
    13121188 
    13131189        // Deferred helper 
    1314         when: function( firstParam ) { 
    1315                 var args = sliceDeferred.call( arguments, 0 ), 
    1316                         i = 0, 
    1317                         length = args.length, 
    1318                         pValues = new Array( length ), 
    1319                         count = length, 
    1320                         pCount = length, 
    1321                         deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ? 
    1322                                 firstParam : 
    1323                                 jQuery.Deferred(), 
    1324                         promise = deferred.promise(); 
    1325                 function resolveFunc( i ) { 
    1326                         return function( value ) { 
    1327                                 args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value; 
    1328                                 if ( !( --count ) ) { 
    1329                                         deferred.resolveWith( deferred, args ); 
    1330                                 } 
    1331                         }; 
    1332                 } 
    1333                 function progressFunc( i ) { 
    1334                         return function( value ) { 
    1335                                 pValues[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value; 
    1336                                 deferred.notifyWith( promise, pValues ); 
    1337                         }; 
    1338                 } 
     1190        when: function( subordinate /* , ..., subordinateN */ ) { 
     1191                var i = 0, 
     1192                        resolveValues = core_slice.call( arguments ), 
     1193                        length = resolveValues.length, 
     1194 
     1195                        // the count of uncompleted subordinates 
     1196                        remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0, 
     1197 
     1198                        // the master Deferred. If resolveValues consist of only a single Deferred, just use that. 
     1199                        deferred = remaining === 1 ? subordinate : jQuery.Deferred(), 
     1200 
     1201                        // Update function for both resolve and progress values 
     1202                        updateFunc = function( i, contexts, values ) { 
     1203                                return function( value ) { 
     1204                                        contexts[ i ] = this; 
     1205                                        values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value; 
     1206                                        if( values === progressValues ) { 
     1207                                                deferred.notifyWith( contexts, values ); 
     1208                                        } else if ( !( --remaining ) ) { 
     1209                                                deferred.resolveWith( contexts, values ); 
     1210                                        } 
     1211                                }; 
     1212                        }, 
     1213 
     1214                        progressValues, progressContexts, resolveContexts; 
     1215 
     1216                // add listeners to Deferred subordinates; treat others as resolved 
    13391217                if ( length > 1 ) { 
     1218                        progressValues = new Array( length ); 
     1219                        progressContexts = new Array( length ); 
     1220                        resolveContexts = new Array( length ); 
    13401221                        for ( ; i < length; i++ ) { 
    1341                                 if ( args[ i ] && args[ i ].promise && jQuery.isFunction( args[ i ].promise ) ) { 
    1342                                         args[ i ].promise().then( resolveFunc(i), deferred.reject, progressFunc(i) ); 
     1222                                if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) { 
     1223                                        resolveValues[ i ].promise() 
     1224                                                .done( updateFunc( i, resolveContexts, resolveValues ) ) 
     1225                                                .fail( deferred.reject ) 
     1226                                                .progress( updateFunc( i, progressContexts, progressValues ) ); 
    13431227                                } else { 
    1344                                         --count; 
    1345                                 } 
    1346                         } 
    1347                         if ( !count ) { 
    1348                                 deferred.resolveWith( deferred, args ); 
    1349                         } 
    1350                 } else if ( deferred !== firstParam ) { 
    1351                         deferred.resolveWith( deferred, length ? [ firstParam ] : [] ); 
    1352                 } 
    1353                 return promise; 
     1228                                        --remaining; 
     1229                                } 
     1230                        } 
     1231                } 
     1232 
     1233                // if we're not waiting on anything, resolve the master 
     1234                if ( !remaining ) { 
     1235                        deferred.resolveWith( resolveContexts, resolveValues ); 
     1236                } 
     1237 
     1238                return deferred.promise(); 
    13541239        } 
    13551240}); 
    1356  
    1357  
    1358  
    1359  
    13601241jQuery.support = (function() { 
    13611242 
     
    13671248                input, 
    13681249                fragment, 
    1369                 tds, 
    1370                 events, 
    13711250                eventName, 
    13721251                i, 
    13731252                isSupported, 
    1374                 div = document.createElement( "div" ), 
    1375                 documentElement = document.documentElement; 
     1253                clickFn, 
     1254                div = document.createElement("div"); 
    13761255 
    13771256        // Preliminary tests 
    1378         div.setAttribute("className", "t"); 
    1379         div.innerHTML = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>"; 
    1380  
    1381         all = div.getElementsByTagName( "*" ); 
    1382         a = div.getElementsByTagName( "a" )[ 0 ]; 
     1257        div.setAttribute( "className", "t" ); 
     1258        div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"; 
     1259 
     1260        all = div.getElementsByTagName("*"); 
     1261        a = div.getElementsByTagName("a")[ 0 ]; 
     1262        a.style.cssText = "top:1px;float:left;opacity:.5"; 
    13831263 
    13841264        // Can't get basic test support 
    1385         if ( !all || !all.length || !a ) { 
     1265        if ( !all || !all.length ) { 
    13861266                return {}; 
    13871267        } 
    13881268 
    13891269        // First batch of supports tests 
    1390         select = document.createElement( "select" ); 
     1270        select = document.createElement("select"); 
    13911271        opt = select.appendChild( document.createElement("option") ); 
    1392         input = div.getElementsByTagName( "input" )[ 0 ]; 
     1272        input = div.getElementsByTagName("input")[ 0 ]; 
    13931273 
    13941274        support = { 
     
    14151295                // (IE uses filter instead) 
    14161296                // Use a regex to work around a WebKit issue. See #5145 
    1417                 opacity: /^0.55/.test( a.style.opacity ), 
     1297                opacity: /^0.5/.test( a.style.opacity ), 
    14181298 
    14191299                // Verify style float existence 
     
    14391319                // Where outerHTML is undefined, this still works 
    14401320                html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>", 
     1321 
     1322                // jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode 
     1323                boxModel: ( document.compatMode === "CSS1Compat" ), 
    14411324 
    14421325                // Will be defined later 
     
    14491332                shrinkWrapBlocks: false, 
    14501333                reliableMarginRight: true, 
    1451                 pixelMargin: true 
     1334                boxSizingReliable: true, 
     1335                pixelPosition: false 
    14521336        }; 
    1453  
    1454         // jQuery.boxModel DEPRECATED in 1.3, use jQuery.support.boxModel instead 
    1455         jQuery.boxModel = support.boxModel = (document.compatMode === "CSS1Compat"); 
    14561337 
    14571338        // Make sure checked status is properly cloned 
     
    14731354 
    14741355        if ( !div.addEventListener && div.attachEvent && div.fireEvent ) { 
    1475                 div.attachEvent( "onclick", function() { 
     1356                div.attachEvent( "onclick", clickFn = function() { 
    14761357                        // Cloning a node shouldn't copy over any 
    14771358                        // bound event handlers (IE does this) 
    14781359                        support.noCloneEvent = false; 
    14791360                }); 
    1480                 div.cloneNode( true ).fireEvent( "onclick" ); 
     1361                div.cloneNode( true ).fireEvent("onclick"); 
     1362                div.detachEvent( "onclick", clickFn ); 
    14811363        } 
    14821364 
     
    14851367        input = document.createElement("input"); 
    14861368        input.value = "t"; 
    1487         input.setAttribute("type", "radio"); 
     1369        input.setAttribute( "type", "radio" ); 
    14881370        support.radioValue = input.value === "t"; 
    14891371 
    1490         input.setAttribute("checked", "checked"); 
     1372        input.setAttribute( "checked", "checked" ); 
    14911373 
    14921374        // #11217 - WebKit loses check when the name is after the checked attribute 
     
    15151397        if ( div.attachEvent ) { 
    15161398                for ( i in { 
    1517                         submit: 1, 
    1518                         change: 1, 
    1519                         focusin: 1 
     1399                        submit: true, 
     1400                        change: true, 
     1401                        focusin: true 
    15201402                }) { 
    15211403                        eventName = "on" + i; 
     
    15291411        } 
    15301412 
    1531         fragment.removeChild( div ); 
    1532  
    1533         // Null elements to avoid leaks in IE 
    1534         fragment = select = opt = div = input = null; 
    1535  
    15361413        // Run tests that need a body at doc ready 
    15371414        jQuery(function() { 
    1538                 var container, outer, inner, table, td, offsetSupport, 
    1539                         marginDiv, conMarginTop, style, html, positionTopLeftWidthHeight, 
    1540                         paddingMarginBorderVisibility, paddingMarginBorder, 
     1415                var container, div, tds, marginDiv, 
     1416                        divReset = "padding:0;margin:0;border:0;display:block;overflow:hidden;", 
    15411417                        body = document.getElementsByTagName("body")[0]; 
    15421418 
     
    15461422                } 
    15471423 
    1548                 conMarginTop = 1; 
    1549                 paddingMarginBorder = "padding:0;margin:0;border:"; 
    1550                 positionTopLeftWidthHeight = "position:absolute;top:0;left:0;width:1px;height:1px;"; 
    1551                 paddingMarginBorderVisibility = paddingMarginBorder + "0;visibility:hidden;"; 
    1552                 style = "style='" + positionTopLeftWidthHeight + paddingMarginBorder + "5px solid #000;"; 
    1553                 html = "<div " + style + "display:block;'><div style='" + paddingMarginBorder + "0;display:block;overflow:hidden;'></div></div>" + 
    1554                         "<table " + style + "' cellpadding='0' cellspacing='0'>" + 
    1555                         "<tr><td></td></tr></table>"; 
    1556  
    15571424                container = document.createElement("div"); 
    1558                 container.style.cssText = paddingMarginBorderVisibility + "width:0;height:0;position:static;top:0;margin-top:" + conMarginTop + "px"; 
     1425                container.style.cssText = "visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px"; 
    15591426                body.insertBefore( container, body.firstChild ); 
    15601427 
     
    15701437                // hidden; don safety goggles and see bug #4512 for more information). 
    15711438                // (only IE 8 fails this test) 
    1572                 div.innerHTML = "<table><tr><td style='" + paddingMarginBorder + "0;display:none'></td><td>t</td></tr></table>"; 
    1573                 tds = div.getElementsByTagName( "td" ); 
     1439                div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>"; 
     1440                tds = div.getElementsByTagName("td"); 
     1441                tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none"; 
    15741442                isSupported = ( tds[ 0 ].offsetHeight === 0 ); 
    15751443 
     
    15811449                support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 ); 
    15821450 
    1583                 // Check if div with explicit width and no margin-right incorrectly 
    1584                 // gets computed margin-right based on width of container. For more 
    1585                 // info see bug #3333 
    1586                 // Fails in WebKit before Feb 2011 nightlies 
    1587                 // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right 
     1451                // Check box-sizing and margin behavior 
     1452                div.innerHTML = ""; 
     1453                div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;"; 
     1454                support.boxSizing = ( div.offsetWidth === 4 ); 
     1455                support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 ); 
     1456 
     1457                // NOTE: To any future maintainer, we've window.getComputedStyle 
     1458                // because jsdom on node.js will break without it. 
    15881459                if ( window.getComputedStyle ) { 
    1589                         div.innerHTML = ""; 
    1590                         marginDiv = document.createElement( "div" ); 
    1591                         marginDiv.style.width = "0"; 
    1592                         marginDiv.style.marginRight = "0"; 
    1593                         div.style.width = "2px"; 
     1460                        support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%"; 
     1461                        support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px"; 
     1462 
     1463                        // Check if div with explicit width and no margin-right incorrectly 
     1464                        // gets computed margin-right based on width of container. For more 
     1465                        // info see bug #3333 
     1466                        // Fails in WebKit before Feb 2011 nightlies 
     1467                        // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right 
     1468                        marginDiv = document.createElement("div"); 
     1469                        marginDiv.style.cssText = div.style.cssText = divReset; 
     1470                        marginDiv.style.marginRight = marginDiv.style.width = "0"; 
     1471                        div.style.width = "1px"; 
    15941472                        div.appendChild( marginDiv ); 
    15951473                        support.reliableMarginRight = 
    1596                                 ( parseInt( ( window.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0; 
     1474                                !parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight ); 
    15971475                } 
    15981476 
     
    16031481                        // (IE < 8 does this) 
    16041482                        div.innerHTML = ""; 
    1605                         div.style.width = div.style.padding = "1px"; 
    1606                         div.style.border = 0; 
    1607                         div.style.overflow = "hidden"; 
    1608                         div.style.display = "inline"; 
    1609                         div.style.zoom = 1; 
     1483                        div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1"; 
    16101484                        support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 ); 
    16111485 
     
    16141488                        div.style.display = "block"; 
    16151489                        div.style.overflow = "visible"; 
    1616                         div.innerHTML = "<div style='width:5px;'></div>"; 
     1490                        div.innerHTML = "<div></div>"; 
     1491                        div.firstChild.style.width = "5px"; 
    16171492                        support.shrinkWrapBlocks = ( div.offsetWidth !== 3 ); 
    1618                 } 
    1619  
    1620                 div.style.cssText = positionTopLeftWidthHeight + paddingMarginBorderVisibility; 
    1621                 div.innerHTML = html; 
    1622  
    1623                 outer = div.firstChild; 
    1624                 inner = outer.firstChild; 
    1625                 td = outer.nextSibling.firstChild.firstChild; 
    1626  
    1627                 offsetSupport = { 
    1628                         doesNotAddBorder: ( inner.offsetTop !== 5 ), 
    1629                         doesAddBorderForTableAndCells: ( td.offsetTop === 5 ) 
    1630                 }; 
    1631  
    1632                 inner.style.position = "fixed"; 
    1633                 inner.style.top = "20px"; 
    1634  
    1635                 // safari subtracts parent border width here which is 5px 
    1636                 offsetSupport.fixedPosition = ( inner.offsetTop === 20 || inner.offsetTop === 15 ); 
    1637                 inner.style.position = inner.style.top = ""; 
    1638  
    1639                 outer.style.overflow = "hidden"; 
    1640                 outer.style.position = "relative"; 
    1641  
    1642                 offsetSupport.subtractsBorderForOverflowNotVisible = ( inner.offsetTop === -5 ); 
    1643                 offsetSupport.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== conMarginTop ); 
    1644  
    1645                 if ( window.getComputedStyle ) { 
    1646                         div.style.marginTop = "1%"; 
    1647                         support.pixelMargin = ( window.getComputedStyle( div, null ) || { marginTop: 0 } ).marginTop !== "1%"; 
    1648                 } 
    1649  
    1650                 if ( typeof container.style.zoom !== "undefined" ) { 
     1493 
    16511494                        container.style.zoom = 1; 
    16521495                } 
    16531496 
     1497                // Null elements to avoid leaks in IE 
    16541498                body.removeChild( container ); 
    1655                 marginDiv = div = container = null; 
    1656  
    1657                 jQuery.extend( support, offsetSupport ); 
     1499                container = div = tds = marginDiv = null; 
    16581500        }); 
     1501 
     1502        // Null elements to avoid leaks in IE 
     1503        fragment.removeChild( div ); 
     1504        all = a = select = opt = input = fragment = div = null; 
    16591505 
    16601506        return support; 
    16611507})(); 
    1662  
    1663  
    1664  
    1665  
    1666 var rbrace = /^(?:\{.*\}|\[.*\])$/, 
     1508var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/, 
    16671509        rmultiDash = /([A-Z])/g; 
    16681510 
     
    16701512        cache: {}, 
    16711513 
    1672         // Please use with caution 
     1514        deletedIds: [], 
     1515 
     1516        // Remove at next major release (1.9/2.0) 
    16731517        uuid: 0, 
    16741518 
     
    16961540                } 
    16971541 
    1698                 var privateCache, thisCache, ret, 
     1542                var thisCache, ret, 
    16991543                        internalKey = jQuery.expando, 
    17001544                        getByName = typeof name === "string", 
     
    17101554                        // Only defining an ID for JS objects if its cache already exists allows 
    17111555                        // the code to shortcut on the same path as a DOM node with no cache 
    1712                         id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey, 
    1713                         isEvents = name === "events"; 
     1556                        id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey; 
    17141557 
    17151558                // Avoid doing any more work than we need to when trying to get data on an 
    17161559                // object that has no data at all 
    1717                 if ( (!id || !cache[id] || (!isEvents && !pvt && !cache[id].data)) && getByName && data === undefined ) { 
     1560                if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) { 
    17181561                        return; 
    17191562                } 
     
    17231566                        // ends up in the global cache 
    17241567                        if ( isNode ) { 
    1725                                 elem[ internalKey ] = id = ++jQuery.uuid; 
     1568                                elem[ internalKey ] = id = jQuery.deletedIds.pop() || jQuery.guid++; 
    17261569                        } else { 
    17271570                                id = internalKey; 
     
    17491592                } 
    17501593 
    1751                 privateCache = thisCache = cache[ id ]; 
     1594                thisCache = cache[ id ]; 
    17521595 
    17531596                // jQuery data() is stored in a separate object inside the object's internal data 
     
    17661609                } 
    17671610 
    1768                 // Users should not attempt to inspect the internal events object using jQuery.data, 
    1769                 // it is undocumented and subject to change. But does anyone listen? No. 
    1770                 if ( isEvents && !thisCache[ name ] ) { 
    1771                         return privateCache.events; 
    1772                 } 
    1773  
    17741611                // Check for both converted-to-camel and non-converted data property names 
    17751612                // If a data property was specified 
     
    17991636                var thisCache, i, l, 
    18001637 
    1801                         // Reference to internal data cache key 
    1802                         internalKey = jQuery.expando, 
    1803  
    18041638                        isNode = elem.nodeType, 
    18051639 
    18061640                        // See jQuery.data for more information 
    18071641                        cache = isNode ? jQuery.cache : elem, 
    1808  
    1809                         // See jQuery.data for more information 
    1810                         id = isNode ? elem[ internalKey ] : internalKey; 
     1642                        id = isNode ? elem[ jQuery.expando ] : jQuery.expando; 
    18111643 
    18121644                // If there is already no cache entry for this object, there is no 
     
    18351667                                                        name = [ name ]; 
    18361668                                                } else { 
    1837                                                         name = name.split( " " ); 
     1669                                                        name = name.split(" "); 
    18381670                                                } 
    18391671                                        } 
     
    18581690                        // Don't destroy the parent cache unless the internal data object 
    18591691                        // had been the only thing left in it 
    1860                         if ( !isEmptyDataObject(cache[ id ]) ) { 
     1692                        if ( !isEmptyDataObject( cache[ id ] ) ) { 
    18611693                                return; 
    18621694                        } 
    18631695                } 
    18641696 
    1865                 // Browsers that fail expando deletion also refuse to delete expandos on 
    1866                 // the window, but it will allow it on all other JS objects; other browsers 
    1867                 // don't care 
    1868                 // Ensure that `cache` is not a window object #10080 
    1869                 if ( jQuery.support.deleteExpando || !cache.setInterval ) { 
     1697                // Destroy the cache 
     1698                if ( isNode ) { 
     1699                        jQuery.cleanData( [ elem ], true ); 
     1700 
     1701                // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080) 
     1702                } else if ( jQuery.support.deleteExpando || cache != cache.window ) { 
    18701703                        delete cache[ id ]; 
     1704 
     1705                // When all else fails, null 
    18711706                } else { 
    18721707                        cache[ id ] = null; 
    1873                 } 
    1874  
    1875                 // We destroyed the cache and need to eliminate the expando on the node to avoid 
    1876                 // false lookups in the cache for entries that no longer exist 
    1877                 if ( isNode ) { 
    1878                         // IE does not allow us to delete expando properties from nodes, 
    1879                         // nor does it have a removeAttribute function on Document nodes; 
    1880                         // we must handle all of these cases 
    1881                         if ( jQuery.support.deleteExpando ) { 
    1882                                 delete elem[ internalKey ]; 
    1883                         } else if ( elem.removeAttribute ) { 
    1884                                 elem.removeAttribute( internalKey ); 
    1885                         } else { 
    1886                                 elem[ internalKey ] = null; 
    1887                         } 
    18881708                } 
    18891709        }, 
     
    18961716        // A method for determining if a DOM node can handle the data expando 
    18971717        acceptData: function( elem ) { 
    1898                 if ( elem.nodeName ) { 
    1899                         var match = jQuery.noData[ elem.nodeName.toLowerCase() ]; 
    1900  
    1901                         if ( match ) { 
    1902                                 return !(match === true || elem.getAttribute("classid") !== match); 
    1903                         } 
    1904                 } 
    1905  
    1906                 return true; 
     1718                var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ]; 
     1719 
     1720                // nodes accept data unless otherwise specified; rejection can be conditional 
     1721                return !noData || noData !== true && elem.getAttribute("classid") === noData; 
    19071722        } 
    19081723}); 
     
    19251740                                                name = attr[i].name; 
    19261741 
    1927                                                 if ( name.indexOf( "data-" ) === 0 ) { 
     1742                                                if ( !name.indexOf( "data-" ) ) { 
    19281743                                                        name = jQuery.camelCase( name.substring(5) ); 
    19291744 
     
    19971812                                data === "false" ? false : 
    19981813                                data === "null" ? null : 
    1999                                 jQuery.isNumeric( data ) ? +data : 
    2000                                         rbrace.test( data ) ? jQuery.parseJSON( data ) : 
     1814                                // Only convert to a number if it doesn't change the string 
     1815                                +data + "" === data ? +data : 
     1816                                rbrace.test( data ) ? jQuery.parseJSON( data ) : 
    20011817                                        data; 
    20021818                        } catch( e ) {} 
     
    20151831// checks a cache object for emptiness 
    20161832function isEmptyDataObject( obj ) { 
    2017         for ( var name in obj ) { 
     1833        var name; 
     1834        for ( name in obj ) { 
    20181835 
    20191836                // if the public data object is empty, the private is still empty 
     
    20281845        return true; 
    20291846} 
    2030  
    2031  
    2032  
    2033  
    2034 function handleQueueMarkDefer( elem, type, src ) { 
    2035         var deferDataKey = type + "defer", 
    2036                 queueDataKey = type + "queue", 
    2037                 markDataKey = type + "mark", 
    2038                 defer = jQuery._data( elem, deferDataKey ); 
    2039         if ( defer && 
    2040                 ( src === "queue" || !jQuery._data(elem, queueDataKey) ) && 
    2041                 ( src === "mark" || !jQuery._data(elem, markDataKey) ) ) { 
    2042                 // Give room for hard-coded callbacks to fire first 
    2043                 // and eventually mark/queue something else on the element 
    2044                 setTimeout( function() { 
    2045                         if ( !jQuery._data( elem, queueDataKey ) && 
    2046                                 !jQuery._data( elem, markDataKey ) ) { 
    2047                                 jQuery.removeData( elem, deferDataKey, true ); 
    2048                                 defer.fire(); 
    2049                         } 
    2050                 }, 0 ); 
    2051         } 
    2052 } 
    2053  
    20541847jQuery.extend({ 
    2055  
    2056         _mark: function( elem, type ) { 
    2057                 if ( elem ) { 
    2058                         type = ( type || "fx" ) + "mark"; 
    2059                         jQuery._data( elem, type, (jQuery._data( elem, type ) || 0) + 1 ); 
    2060                 } 
    2061         }, 
    2062  
    2063         _unmark: function( force, elem, type ) { 
    2064                 if ( force !== true ) { 
    2065                         type = elem; 
    2066                         elem = force; 
    2067                         force = false; 
    2068                 } 
    2069                 if ( elem ) { 
    2070                         type = type || "fx"; 
    2071                         var key = type + "mark", 
    2072                                 count = force ? 0 : ( (jQuery._data( elem, key ) || 1) - 1 ); 
    2073                         if ( count ) { 
    2074                                 jQuery._data( elem, key, count ); 
    2075                         } else { 
    2076                                 jQuery.removeData( elem, key, true ); 
    2077                                 handleQueueMarkDefer( elem, type, "mark" ); 
    2078                         } 
    2079                 } 
    2080         }, 
    2081  
    20821848        queue: function( elem, type, data ) { 
    2083                 var q; 
     1849                var queue; 
     1850 
    20841851                if ( elem ) { 
    20851852                        type = ( type || "fx" ) + "queue"; 
    2086                         q = jQuery._data( elem, type ); 
     1853                        queue = jQuery._data( elem, type ); 
    20871854 
    20881855                        // Speed up dequeue by getting out quickly if this is just a lookup 
    20891856                        if ( data ) { 
    2090                                 if ( !q || jQuery.isArray(data) ) { 
    2091                                         q = jQuery._data( elem, type, jQuery.makeArray(data) ); 
     1857                                if ( !queue || jQuery.isArray(data) ) { 
     1858                                        queue = jQuery._data( elem, type, jQuery.makeArray(data) ); 
    20921859                                } else { 
    2093                                         q.push( data ); 
    2094                                 } 
    2095                         } 
    2096                         return q || []; 
     1860                                        queue.push( data ); 
     1861                                } 
     1862                        } 
     1863                        return queue || []; 
    20971864                } 
    20981865        }, 
     
    21021869 
    21031870                var queue = jQuery.queue( elem, type ), 
     1871                        startLength = queue.length, 
    21041872                        fn = queue.shift(), 
    2105                         hooks = {}; 
     1873                        hooks = jQuery._queueHooks( elem, type ), 
     1874                        next = function() { 
     1875                                jQuery.dequeue( elem, type ); 
     1876                        }; 
    21061877 
    21071878                // If the fx queue is dequeued, always remove the progress sentinel 
    21081879                if ( fn === "inprogress" ) { 
    21091880                        fn = queue.shift(); 
     1881                        startLength--; 
    21101882                } 
    21111883 
    21121884                if ( fn ) { 
     1885 
    21131886                        // Add a progress sentinel to prevent the fx queue from being 
    21141887                        // automatically dequeued 
     
    21171890                        } 
    21181891 
    2119                         jQuery._data( elem, type + ".run", hooks ); 
    2120                         fn.call( elem, function() { 
    2121                                 jQuery.dequeue( elem, type ); 
    2122                         }, hooks ); 
    2123                 } 
    2124  
    2125                 if ( !queue.length ) { 
    2126                         jQuery.removeData( elem, type + "queue " + type + ".run", true ); 
    2127                         handleQueueMarkDefer( elem, type, "queue" ); 
    2128                 } 
     1892                        // clear up the last queue stop function 
     1893                        delete hooks.stop; 
     1894                        fn.call( elem, next, hooks ); 
     1895                } 
     1896 
     1897                if ( !startLength && hooks ) { 
     1898                        hooks.empty.fire(); 
     1899                } 
     1900        }, 
     1901 
     1902        // not intended for public consumption - generates a queueHooks object, or returns the current one 
     1903        _queueHooks: function( elem, type ) { 
     1904                var key = type + "queueHooks"; 
     1905                return jQuery._data( elem, key ) || jQuery._data( elem, key, { 
     1906                        empty: jQuery.Callbacks("once memory").add(function() { 
     1907                                jQuery.removeData( elem, type + "queue", true ); 
     1908                                jQuery.removeData( elem, key, true ); 
     1909                        }) 
     1910                }); 
    21291911        } 
    21301912}); 
     
    21481930                        this.each(function() { 
    21491931                                var queue = jQuery.queue( this, type, data ); 
     1932 
     1933                                // ensure a hooks for this queue 
     1934                                jQuery._queueHooks( this, type ); 
    21501935 
    21511936                                if ( type === "fx" && queue[0] !== "inprogress" ) { 
     
    21771962        // Get a promise resolved when queues of a certain type 
    21781963        // are emptied (fx is the type by default) 
    2179         promise: function( type, object ) { 
     1964        promise: function( type, obj ) { 
     1965                var tmp, 
     1966                        count = 1, 
     1967                        defer = jQuery.Deferred(), 
     1968                        elements = this, 
     1969                        i = this.length, 
     1970                        resolve = function() { 
     1971                                if ( !( --count ) ) { 
     1972                                        defer.resolveWith( elements, [ elements ] ); 
     1973                                } 
     1974                        }; 
     1975 
    21801976                if ( typeof type !== "string" ) { 
    2181                         object = type; 
     1977                        obj = type; 
    21821978                        type = undefined; 
    21831979                } 
    21841980                type = type || "fx"; 
    2185                 var defer = jQuery.Deferred(), 
    2186                         elements = this, 
    2187                         i = elements.length, 
    2188                         count = 1, 
    2189                         deferDataKey = type + "defer", 
    2190                         queueDataKey = type + "queue", 
    2191                         markDataKey = type + "mark", 
    2192                         tmp; 
    2193                 function resolve() { 
    2194                         if ( !( --count ) ) { 
    2195                                 defer.resolveWith( elements, [ elements ] ); 
    2196                         } 
    2197                 } 
     1981 
    21981982                while( i-- ) { 
    2199                         if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) || 
    2200                                         ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) || 
    2201                                                 jQuery.data( elements[ i ], markDataKey, undefined, true ) ) && 
    2202                                         jQuery.data( elements[ i ], deferDataKey, jQuery.Callbacks( "once memory" ), true ) )) { 
     1983                        tmp = jQuery._data( elements[ i ], type + "queueHooks" ); 
     1984                        if ( tmp && tmp.empty ) { 
    22031985                                count++; 
    2204                                 tmp.add( resolve ); 
     1986                                tmp.empty.add( resolve ); 
    22051987                        } 
    22061988                } 
    22071989                resolve(); 
    2208                 return defer.promise( object ); 
     1990                return defer.promise( obj ); 
    22091991        } 
    22101992}); 
    2211  
    2212  
    2213  
    2214  
    2215 var rclass = /[\n\t\r]/g, 
    2216         rspace = /\s+/, 
     1993var nodeHook, boolHook, fixSpecified, 
     1994        rclass = /[\t\r\n]/g, 
    22171995        rreturn = /\r/g, 
    22181996        rtype = /^(?:button|input)$/i, 
    22191997        rfocusable = /^(?:button|input|object|select|textarea)$/i, 
    2220         rclickable = /^a(?:rea)?$/i, 
     1998        rclickable = /^a(?:rea|)$/i, 
    22211999        rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i, 
    2222         getSetAttribute = jQuery.support.getSetAttribute, 
    2223         nodeHook, boolHook, fixSpecified; 
     2000        getSetAttribute = jQuery.support.getSetAttribute; 
    22242001 
    22252002jQuery.fn.extend({ 
     
    22602037 
    22612038                if ( value && typeof value === "string" ) { 
    2262                         classNames = value.split( rspace ); 
     2039                        classNames = value.split( core_rspace ); 
    22632040 
    22642041                        for ( i = 0, l = this.length; i < l; i++ ) { 
     
    22732050 
    22742051                                                for ( c = 0, cl = classNames.length; c < cl; c++ ) { 
    2275                                                         if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) { 
     2052                                                        if ( setClass.indexOf( " " + classNames[ c ] + " " ) < 0 ) { 
    22762053                                                                setClass += classNames[ c ] + " "; 
    22772054                                                        } 
     
    22872064 
    22882065        removeClass: function( value ) { 
    2289                 var classNames, i, l, elem, className, c, cl; 
     2066                var removes, className, elem, c, cl, i, l; 
    22902067 
    22912068                if ( jQuery.isFunction( value ) ) { 
     
    22942071                        }); 
    22952072                } 
    2296  
    22972073                if ( (value && typeof value === "string") || value === undefined ) { 
    2298                         classNames = ( value || "" ).split( rspace ); 
     2074                        removes = ( value || "" ).split( core_rspace ); 
    22992075 
    23002076                        for ( i = 0, l = this.length; i < l; i++ ) { 
    23012077                                elem = this[ i ]; 
    2302  
    23032078                                if ( elem.nodeType === 1 && elem.className ) { 
    2304                                         if ( value ) { 
    2305                                                 className = (" " + elem.className + " ").replace( rclass, " " ); 
    2306                                                 for ( c = 0, cl = classNames.length; c < cl; c++ ) { 
    2307                                                         className = className.replace(" " + classNames[ c ] + " ", " "); 
     2079 
     2080                                        className = (" " + elem.className + " ").replace( rclass, " " ); 
     2081 
     2082                                        // loop over each item in the removal list 
     2083                                        for ( c = 0, cl = removes.length; c < cl; c++ ) { 
     2084                                                // Remove until there is nothing to remove, 
     2085                                                while ( className.indexOf(" " + removes[ c ] + " ") >= 0 ) { 
     2086                                                        className = className.replace( " " + removes[ c ] + " " , " " ); 
    23082087                                                } 
    2309                                                 elem.className = jQuery.trim( className ); 
    2310  
    2311                                         } else { 
    2312                                                 elem.className = ""; 
    23132088                                        } 
     2089                                        elem.className = value ? jQuery.trim( className ) : ""; 
    23142090                                } 
    23152091                        } 
     
    23362112                                        self = jQuery( this ), 
    23372113                                        state = stateVal, 
    2338                                         classNames = value.split( rspace ); 
     2114                                        classNames = value.split( core_rspace ); 
    23392115 
    23402116                                while ( (className = classNames[ i++ ]) ) { 
    2341                                         // check each className given, space seperated list 
     2117                                        // check each className given, space separated list 
    23422118                                        state = isBool ? state : !self.hasClass( className ); 
    23432119                                        self[ state ? "addClass" : "removeClass" ]( className ); 
     
    23612137                        l = this.length; 
    23622138                for ( ; i < l; i++ ) { 
    2363                         if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) { 
     2139                        if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) { 
    23642140                                return true; 
    23652141                        } 
     
    23962172 
    23972173                return this.each(function( i ) { 
    2398                         var self = jQuery(this), val; 
     2174                        var val, 
     2175                                self = jQuery(this); 
    23992176 
    24002177                        if ( this.nodeType !== 1 ) { 
     
    24982275        }, 
    24992276 
    2500         attrFn: { 
    2501                 val: true, 
    2502                 css: true, 
    2503                 html: true, 
    2504                 text: true, 
    2505                 data: true, 
    2506                 width: true, 
    2507                 height: true, 
    2508                 offset: true 
    2509         }, 
     2277        // Unused in 1.8, left in so attrFn-stabbers won't die; remove in 1.9 
     2278        attrFn: {}, 
    25102279 
    25112280        attr: function( elem, name, value, pass ) { 
     
    25182287                } 
    25192288 
    2520                 if ( pass && name in jQuery.attrFn ) { 
     2289                if ( pass && jQuery.isFunction( jQuery.fn[ name ] ) ) { 
    25212290                        return jQuery( elem )[ name ]( value ); 
    25222291                } 
     
    25462315 
    25472316                        } else { 
    2548                                 elem.setAttribute( name, "" + value ); 
     2317                                elem.setAttribute( name, value + "" ); 
    25492318                                return value; 
    25502319                        } 
     
    25652334 
    25662335        removeAttr: function( elem, value ) { 
    2567                 var propName, attrNames, name, l, isBool, 
     2336                var propName, attrNames, name, isBool, 
    25682337                        i = 0; 
    25692338 
    25702339                if ( value && elem.nodeType === 1 ) { 
    2571                         attrNames = value.toLowerCase().split( rspace ); 
    2572                         l = attrNames.length; 
    2573  
    2574                         for ( ; i < l; i++ ) { 
     2340 
     2341                        attrNames = value.split( core_rspace ); 
     2342 
     2343                        for ( ; i < attrNames.length; i++ ) { 
    25752344                                name = attrNames[ i ]; 
    25762345 
     
    27022471}); 
    27032472 
    2704 // Add the tabIndex propHook to attrHooks for back-compat (different case is intentional) 
    2705 jQuery.attrHooks.tabindex = jQuery.propHooks.tabIndex; 
    2706  
    27072473// Hook for boolean attributes 
    27082474boolHook = { 
     
    27512517                        var ret; 
    27522518                        ret = elem.getAttributeNode( name ); 
    2753                         return ret && ( fixSpecified[ name ] ? ret.nodeValue !== "" : ret.specified ) ? 
    2754                                 ret.nodeValue : 
     2519                        return ret && ( fixSpecified[ name ] ? ret.value !== "" : ret.specified ) ? 
     2520                                ret.value : 
    27552521                                undefined; 
    27562522                }, 
     
    27622528                                elem.setAttributeNode( ret ); 
    27632529                        } 
    2764                         return ( ret.nodeValue = value + "" ); 
     2530                        return ( ret.value = value + "" ); 
    27652531                } 
    27662532        }; 
    2767  
    2768         // Apply the nodeHook to tabindex 
    2769         jQuery.attrHooks.tabindex.set = nodeHook.set; 
    27702533 
    27712534        // Set width and height to auto instead of 0 on empty string( Bug #8150 ) 
     
    28162579                }, 
    28172580                set: function( elem, value ) { 
    2818                         return ( elem.style.cssText = "" + value ); 
     2581                        return ( elem.style.cssText = value + "" ); 
    28192582                } 
    28202583        }; 
     
    28662629        }); 
    28672630}); 
    2868  
    2869  
    2870  
    2871  
    28722631var rformElems = /^(?:textarea|input|select)$/i, 
    2873         rtypenamespace = /^([^\.]*)?(?:\.(.+))?$/, 
    2874         rhoverHack = /(?:^|\s)hover(\.\S+)?\b/, 
     2632        rtypenamespace = /^([^\.]*|)(?:\.(.+)|)$/, 
     2633        rhoverHack = /(?:^|\s)hover(\.\S+|)\b/, 
    28752634        rkeyEvent = /^key/, 
    28762635        rmouseEvent = /^(?:mouse|contextmenu)|click/, 
    28772636        rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, 
    2878         rquickIs = /^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/, 
    2879         quickParse = function( selector ) { 
    2880                 var quick = rquickIs.exec( selector ); 
    2881                 if ( quick ) { 
    2882                         //   0  1    2   3 
    2883                         // [ _, tag, id, class ] 
    2884                         quick[1] = ( quick[1] || "" ).toLowerCase(); 
    2885                         quick[3] = quick[3] && new RegExp( "(?:^|\\s)" + quick[3] + "(?:\\s|$)" ); 
    2886                 } 
    2887                 return quick; 
    2888         }, 
    2889         quickIs = function( elem, m ) { 
    2890                 var attrs = elem.attributes || {}; 
    2891                 return ( 
    2892                         (!m[1] || elem.nodeName.toLowerCase() === m[1]) && 
    2893                         (!m[2] || (attrs.id || {}).value === m[2]) && 
    2894                         (!m[3] || m[3].test( (attrs[ "class" ] || {}).value )) 
    2895                 ); 
    2896         }, 
    28972637        hoverHack = function( events ) { 
    28982638                return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" ); 
     
    29092649                var elemData, eventHandle, events, 
    29102650                        t, tns, type, namespaces, handleObj, 
    2911                         handleObjIn, quick, handlers, special; 
     2651                        handleObjIn, handlers, special; 
    29122652 
    29132653                // Don't attach events to noData or text/comment nodes (allow plain objects tho) 
     
    29722712                                guid: handler.guid, 
    29732713                                selector: selector, 
    2974                                 quick: selector && quickParse( selector ), 
     2714                                needsContext: selector && jQuery.expr.match.needsContext.test( selector ), 
    29752715                                namespace: namespaces.join(".") 
    29762716                        }, handleObjIn ); 
     
    30222762        remove: function( elem, types, handler, selector, mappedTypes ) { 
    30232763 
    3024                 var elemData = jQuery.hasData( elem ) && jQuery._data( elem ), 
    3025                         t, tns, type, origType, namespaces, origCount, 
    3026                         j, events, special, handle, eventType, handleObj; 
     2764                var t, tns, type, origType, namespaces, origCount, 
     2765                        j, events, special, eventType, handleObj, 
     2766                        elemData = jQuery.hasData( elem ) && jQuery._data( elem ); 
    30272767 
    30282768                if ( !elemData || !(events = elemData.events) ) { 
     
    30492789                        eventType = events[ type ] || []; 
    30502790                        origCount = eventType.length; 
    3051                         namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.)?") + "(\\.|$)") : null; 
     2791                        namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.|)") + "(\\.|$)") : null; 
    30522792 
    30532793                        // Remove matching events 
     
    30732813                        // (avoids potential for endless recursion during removal of special event handlers) 
    30742814                        if ( eventType.length === 0 && origCount !== eventType.length ) { 
    3075                                 if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) { 
     2815                                if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) { 
    30762816                                        jQuery.removeEvent( elem, type, elemData.handle ); 
    30772817                                } 
     
    30832823                // Remove the expando if it's no longer used 
    30842824                if ( jQuery.isEmptyObject( events ) ) { 
    3085                         handle = elemData.handle; 
    3086                         if ( handle ) { 
    3087                                 handle.elem = null; 
    3088                         } 
     2825                        delete elemData.handle; 
    30892826 
    30902827                        // removeData also checks for emptiness and clears the expando if empty 
    30912828                        // so use it instead of delete 
    3092                         jQuery.removeData( elem, [ "events", "handle" ], true ); 
     2829                        jQuery.removeData( elem, "events", true ); 
    30932830                } 
    30942831        }, 
     
    31092846 
    31102847                // Event object or event type 
    3111                 var type = event.type || event, 
    3112                         namespaces = [], 
    3113                         cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType; 
     2848                var cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType, 
     2849                        type = event.type || event, 
     2850                        namespaces = []; 
    31142851 
    31152852                // focus/blur morphs to focusin/out; ensure we're not firing them right now 
     
    31492886                event.exclusive = exclusive; 
    31502887                event.namespace = namespaces.join( "." ); 
    3151                 event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)") : null; 
     2888                event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null; 
    31522889                ontype = type.indexOf( ":" ) < 0 ? "on" + type : ""; 
    31532890 
     
    31882925                        bubbleType = special.delegateType || type; 
    31892926                        cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode; 
    3190                         old = null; 
    3191                         for ( ; cur; cur = cur.parentNode ) { 
     2927                        for ( old = elem; cur; cur = cur.parentNode ) { 
    31922928                                eventPath.push([ cur, bubbleType ]); 
    31932929                                old = cur; 
     
    31952931 
    31962932                        // Only add window if we got to document (e.g., not plain obj or detached DOM) 
    3197                         if ( old && old === elem.ownerDocument ) { 
     2933                        if ( old === (elem.ownerDocument || document) ) { 
    31982934                                eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]); 
    31992935                        } 
     
    32122948                        // Note that this is a bare JS function and not a jQuery handler 
    32132949                        handle = ontype && cur[ ontype ]; 
    3214                         if ( handle && jQuery.acceptData( cur ) && handle.apply( cur, data ) === false ) { 
     2950                        if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === false ) { 
    32152951                                event.preventDefault(); 
    32162952                        } 
     
    32572993                event = jQuery.event.fix( event || window.event ); 
    32582994 
    3259                 var handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []), 
     2995                var i, j, cur, ret, selMatch, matched, matches, handleObj, sel, related, 
     2996                        handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []), 
    32602997                        delegateCount = handlers.delegateCount, 
    3261                         args = [].slice.call( arguments, 0 ), 
     2998                        args = core_slice.call( arguments ), 
    32622999                        run_all = !event.exclusive && !event.namespace, 
    32633000                        special = jQuery.event.special[ event.type ] || {}, 
    3264                         handlerQueue = [], 
    3265                         i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related; 
     3001                        handlerQueue = []; 
    32663002 
    32673003                // Use the fix-ed jQuery.Event rather than the (read-only) native event 
     
    32783014                if ( delegateCount && !(event.button && event.type === "click") ) { 
    32793015 
    3280                         // Pregenerate a single jQuery object for reuse with .is() 
    3281                         jqcur = jQuery(this); 
    3282                         jqcur.context = this.ownerDocument || this; 
    3283  
    32843016                        for ( cur = event.target; cur != this; cur = cur.parentNode || this ) { 
    32853017 
    3286                                 // Don't process events on disabled elements (#6911, #8165) 
    3287                                 if ( cur.disabled !== true ) { 
     3018                                // Don't process clicks (ONLY) on disabled elements (#6911, #8165, #11382, #11764) 
     3019                                if ( cur.disabled !== true || event.type !== "click" ) { 
    32883020                                        selMatch = {}; 
    32893021                                        matches = []; 
    3290                                         jqcur[0] = cur; 
    32913022                                        for ( i = 0; i < delegateCount; i++ ) { 
    32923023                                                handleObj = handlers[ i ]; 
     
    32943025 
    32953026                                                if ( selMatch[ sel ] === undefined ) { 
    3296                                                         selMatch[ sel ] = ( 
    3297                                                                 handleObj.quick ? quickIs( cur, handleObj.quick ) : jqcur.is( sel ) 
    3298                                                         ); 
     3027                                                        selMatch[ sel ] = handleObj.needsContext ? 
     3028                                                                jQuery( sel, this ).index( cur ) >= 0 : 
     3029                                                                jQuery.find( sel, this, null, [ cur ] ).length; 
    32993030                                                } 
    33003031                                                if ( selMatch[ sel ] ) { 
     
    34303161                } 
    34313162 
    3432                 // For mouse/key events; add metaKey if it's not there (#3368, IE6/7/8) 
    3433                 if ( event.metaKey === undefined ) { 
    3434                         event.metaKey = event.ctrlKey; 
    3435                 } 
     3163                // For mouse/key events, metaKey==false if it's undefined (#3368, #11328; IE6/7/8) 
     3164                event.metaKey = !!event.metaKey; 
    34363165 
    34373166                return fixHook.filter? fixHook.filter( event, originalEvent ) : event; 
     
    34393168 
    34403169        special: { 
    3441                 ready: { 
    3442                         // Make sure the ready event is setup 
    3443                         setup: jQuery.bindReady 
    3444                 }, 
    3445  
    34463170                load: { 
    34473171                        // Prevent triggered image.load events from bubbling to window.load 
     
    35063230        } : 
    35073231        function( elem, type, handle ) { 
     3232                var name = "on" + type; 
     3233 
    35083234                if ( elem.detachEvent ) { 
    3509                         elem.detachEvent( "on" + type, handle ); 
     3235 
     3236                        // #8545, #7054, preventing memory leaks for custom events in IE6-8 – 
     3237                        // detachEvent needed property on element, by name of that event, to properly expose it to GC 
     3238                        if ( typeof elem[ name ] === "undefined" ) { 
     3239                                elem[ name ] = null; 
     3240                        } 
     3241 
     3242                        elem.detachEvent( name, handle ); 
    35103243                } 
    35113244        }; 
     
    36043337 
    36053338                handle: function( event ) { 
    3606                         var target = this, 
     3339                        var ret, 
     3340                                target = this, 
    36073341                                related = event.relatedTarget, 
    36083342                                handleObj = event.handleObj, 
    3609                                 selector = handleObj.selector, 
    3610                                 ret; 
     3343                                selector = handleObj.selector; 
    36113344 
    36123345                        // For mousenter/leave call the handler if related is outside the target. 
     
    36373370                                var elem = e.target, 
    36383371                                        form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined; 
    3639                                 if ( form && !form._submit_attached ) { 
     3372                                if ( form && !jQuery._data( form, "_submit_attached" ) ) { 
    36403373                                        jQuery.event.add( form, "submit._submit", function( event ) { 
    36413374                                                event._submit_bubble = true; 
    36423375                                        }); 
    3643                                         form._submit_attached = true; 
     3376                                        jQuery._data( form, "_submit_attached", true ); 
    36443377                                } 
    36453378                        }); 
    36463379                        // return undefined since we don't need an event listener 
    36473380                }, 
    3648                  
     3381 
    36493382                postDispatch: function( event ) { 
    36503383                        // If form was submitted by the user, bubble the event up the tree 
     
    36893422                                                if ( this._just_changed && !event.isTrigger ) { 
    36903423                                                        this._just_changed = false; 
    3691                                                         jQuery.event.simulate( "change", this, event, true ); 
    36923424                                                } 
     3425                                                // Allow triggered, simulated change events (#11500) 
     3426                                                jQuery.event.simulate( "change", this, event, true ); 
    36933427                                        }); 
    36943428                                } 
     
    36993433                                var elem = e.target; 
    37003434 
    3701                                 if ( rformElems.test( elem.nodeName ) && !elem._change_attached ) { 
     3435                                if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "_change_attached" ) ) { 
    37023436                                        jQuery.event.add( elem, "change._change", function( event ) { 
    37033437                                                if ( this.parentNode && !event.isSimulated && !event.isTrigger ) { 
     
    37053439                                                } 
    37063440                                        }); 
    3707                                         elem._change_attached = true; 
     3441                                        jQuery._data( elem, "_change_attached", true ); 
    37083442                                } 
    37093443                        }); 
     
    37223456                        jQuery.event.remove( this, "._change" ); 
    37233457 
    3724                         return rformElems.test( this.nodeName ); 
     3458                        return !rformElems.test( this.nodeName ); 
    37253459                } 
    37263460        }; 
     
    38113545        }, 
    38123546        off: function( types, selector, fn ) { 
     3547                var handleObj, type; 
    38133548                if ( types && types.preventDefault && types.handleObj ) { 
    38143549                        // ( event )  dispatched jQuery.Event 
    3815                         var handleObj = types.handleObj; 
     3550                        handleObj = types.handleObj; 
    38163551                        jQuery( types.delegateTarget ).off( 
    38173552                                handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, 
     
    38233558                if ( typeof types === "object" ) { 
    38243559                        // ( types-object [, selector] ) 
    3825                         for ( var type in types ) { 
     3560                        for ( type in types ) { 
    38263561                                this.off( type, selector, types[ type ] ); 
    38273562                        } 
     
    38623597        undelegate: function( selector, types, fn ) { 
    38633598                // ( namespace ) or ( selector, types [, fn] ) 
    3864                 return arguments.length == 1? this.off( selector, "**" ) : this.off( types, selector, fn ); 
     3599                return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn ); 
    38653600        }, 
    38663601 
     
    39233658        }; 
    39243659 
    3925         if ( jQuery.attrFn ) { 
    3926                 jQuery.attrFn[ name ] = true; 
    3927         } 
    3928  
    39293660        if ( rkeyEvent.test( name ) ) { 
    39303661                jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks; 
     
    39353666        } 
    39363667}); 
    3937  
    3938  
    3939  
    39403668/*! 
    39413669 * Sizzle CSS Selector Engine 
    3942  *  Copyright 2011, The Dojo Foundation 
    3943  *  Released under the MIT, BSD, and GPL Licenses. 
    3944  *  More information: http://sizzlejs.com/ 
     3670 * Copyright 2012 jQuery Foundation and other contributors 
     3671 * Released under the MIT license 
     3672 * http://sizzlejs.com/ 
    39453673 */ 
    3946 (function(){ 
    3947  
    3948 var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g, 
    3949         expando = "sizcache" + (Math.random() + '').replace('.', ''), 
     3674(function( window, undefined ) { 
     3675 
     3676var cachedruns, 
     3677        assertGetIdNotName, 
     3678        Expr, 
     3679        getText, 
     3680        isXML, 
     3681        contains, 
     3682        compile, 
     3683        sortOrder, 
     3684        hasDuplicate, 
     3685        outermostContext, 
     3686 
     3687        baseHasDuplicate = true, 
     3688        strundefined = "undefined", 
     3689 
     3690        expando = ( "sizcache" + Math.random() ).replace( ".", "" ), 
     3691 
     3692        Token = String, 
     3693        document = window.document, 
     3694        docElem = document.documentElement, 
     3695        dirruns = 0, 
    39503696        done = 0, 
    3951         toString = Object.prototype.toString, 
    3952         hasDuplicate = false, 
    3953         baseHasDuplicate = true, 
    3954         rBackslash = /\\/g, 
    3955         rReturn = /\r\n/g, 
    3956         rNonWord = /\W/; 
    3957  
    3958 // Here we check if the JavaScript engine is using some sort of 
    3959 // optimization where it does not always call our comparision 
    3960 // function. If that is the case, discard the hasDuplicate value. 
    3961 //   Thus far that includes Google Chrome. 
    3962 [0, 0].sort(function() { 
    3963         baseHasDuplicate = false; 
    3964         return 0; 
    3965 }); 
    3966  
    3967 var Sizzle = function( selector, context, results, seed ) { 
     3697        pop = [].pop, 
     3698        push = [].push, 
     3699        slice = [].slice, 
     3700        // Use a stripped-down indexOf if a native one is unavailable 
     3701        indexOf = [].indexOf || function( elem ) { 
     3702                var i = 0, 
     3703                        len = this.length; 
     3704                for ( ; i < len; i++ ) { 
     3705                        if ( this[i] === elem ) { 
     3706                                return i; 
     3707                        } 
     3708                } 
     3709                return -1; 
     3710        }, 
     3711 
     3712        // Augment a function for special use by Sizzle 
     3713        markFunction = function( fn, value ) { 
     3714                fn[ expando ] = value == null || value; 
     3715                return fn; 
     3716        }, 
     3717 
     3718        createCache = function() { 
     3719                var cache = {}, 
     3720                        keys = []; 
     3721 
     3722                return markFunction(function( key, value ) { 
     3723                        // Only keep the most recent entries 
     3724                        if ( keys.push( key ) > Expr.cacheLength ) { 
     3725                                delete cache[ keys.shift() ]; 
     3726                        } 
     3727 
     3728                        return (cache[ key ] = value); 
     3729                }, cache ); 
     3730        }, 
     3731 
     3732        classCache = createCache(), 
     3733        tokenCache = createCache(), 
     3734        compilerCache = createCache(), 
     3735 
     3736        // Regex 
     3737 
     3738        // Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace 
     3739        whitespace = "[\\x20\\t\\r\\n\\f]", 
     3740        // http://www.w3.org/TR/css3-syntax/#characters 
     3741        characterEncoding = "(?:\\\\.|[-\\w]|[^\\x00-\\xa0])+", 
     3742 
     3743        // Loosely modeled on CSS identifier characters 
     3744        // An unquoted value should be a CSS identifier (http://www.w3.org/TR/css3-selectors/#attribute-selectors) 
     3745        // Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier 
     3746        identifier = characterEncoding.replace( "w", "w#" ), 
     3747 
     3748        // Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors 
     3749        operators = "([*^$|!~]?=)", 
     3750        attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace + 
     3751                "*(?:" + operators + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]", 
     3752 
     3753        // Prefer arguments not in parens/brackets, 
     3754        //   then attribute selectors and non-pseudos (denoted by :), 
     3755        //   then anything else 
     3756        // These preferences are here to reduce the number of selectors 
     3757        //   needing tokenize in the PSEUDO preFilter 
     3758        pseudos = ":(" + characterEncoding + ")(?:\\((?:(['\"])((?:\\\\.|[^\\\\])*?)\\2|([^()[\\]]*|(?:(?:" + attributes + ")|[^:]|\\\\.)*|.*))\\)|)", 
     3759 
     3760        // For matchExpr.POS and matchExpr.needsContext 
     3761        pos = ":(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + 
     3762                "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", 
     3763 
     3764        // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter 
     3765        rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ), 
     3766 
     3767        rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), 
     3768        rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ), 
     3769        rpseudo = new RegExp( pseudos ), 
     3770 
     3771        // Easily-parseable/retrievable ID or TAG or CLASS selectors 
     3772        rquickExpr = /^(?:#([\w\-]+)|(\w+)|\.([\w\-]+))$/, 
     3773 
     3774        rnot = /^:not/, 
     3775        rsibling = /[\x20\t\r\n\f]*[+~]/, 
     3776        rendsWithNot = /:not\($/, 
     3777 
     3778        rheader = /h\d/i, 
     3779        rinputs = /input|select|textarea|button/i, 
     3780 
     3781        rbackslash = /\\(?!\\)/g, 
     3782 
     3783        matchExpr = { 
     3784                "ID": new RegExp( "^#(" + characterEncoding + ")" ), 
     3785                "CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ), 
     3786                "NAME": new RegExp( "^\\[name=['\"]?(" + characterEncoding + ")['\"]?\\]" ), 
     3787                "TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ), 
     3788                "ATTR": new RegExp( "^" + attributes ), 
     3789                "PSEUDO": new RegExp( "^" + pseudos ), 
     3790                "POS": new RegExp( pos, "i" ), 
     3791                "CHILD": new RegExp( "^:(only|nth|first|last)-child(?:\\(" + whitespace + 
     3792                        "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + 
     3793                        "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), 
     3794                // For use in libraries implementing .is() 
     3795                "needsContext": new RegExp( "^" + whitespace + "*[>+~]|" + pos, "i" ) 
     3796        }, 
     3797 
     3798        // Support 
     3799 
     3800        // Used for testing something on an element 
     3801        assert = function( fn ) { 
     3802                var div = document.createElement("div"); 
     3803 
     3804                try { 
     3805                        return fn( div ); 
     3806                } catch (e) { 
     3807                        return false; 
     3808                } finally { 
     3809                        // release memory in IE 
     3810                        div = null; 
     3811                } 
     3812        }, 
     3813 
     3814        // Check if getElementsByTagName("*") returns only elements 
     3815        assertTagNameNoComments = assert(function( div ) { 
     3816                div.appendChild( document.createComment("") ); 
     3817                return !div.getElementsByTagName("*").length; 
     3818        }), 
     3819 
     3820        // Check if getAttribute returns normalized href attributes 
     3821        assertHrefNotNormalized = assert(function( div ) { 
     3822                div.innerHTML = "<a href='#'></a>"; 
     3823                return div.firstChild && typeof div.firstChild.getAttribute !== strundefined && 
     3824                        div.firstChild.getAttribute("href") === "#"; 
     3825        }), 
     3826 
     3827        // Check if attributes should be retrieved by attribute nodes 
     3828        assertAttributes = assert(function( div ) { 
     3829                div.innerHTML = "<select></select>"; 
     3830                var type = typeof div.lastChild.getAttribute("multiple"); 
     3831                // IE8 returns a string for some attributes even when not present 
     3832                return type !== "boolean" && type !== "string"; 
     3833        }), 
     3834 
     3835        // Check if getElementsByClassName can be trusted 
     3836        assertUsableClassName = assert(function( div ) { 
     3837                // Opera can't find a second classname (in 9.6) 
     3838                div.innerHTML = "<div class='hidden e'></div><div class='hidden'></div>"; 
     3839                if ( !div.getElementsByClassName || !div.getElementsByClassName("e").length ) { 
     3840                        return false; 
     3841                } 
     3842 
     3843                // Safari 3.2 caches class attributes and doesn't catch changes 
     3844                div.lastChild.className = "e"; 
     3845                return div.getElementsByClassName("e").length === 2; 
     3846        }), 
     3847 
     3848        // Check if getElementById returns elements by name 
     3849        // Check if getElementsByName privileges form controls or returns elements by ID 
     3850        assertUsableName = assert(function( div ) { 
     3851                // Inject content 
     3852                div.id = expando + 0; 
     3853                div.innerHTML = "<a name='" + expando + "'></a><div name='" + expando + "'></div>"; 
     3854                docElem.insertBefore( div, docElem.firstChild ); 
     3855 
     3856                // Test 
     3857                var pass = document.getElementsByName && 
     3858                        // buggy browsers will return fewer than the correct 2 
     3859                        document.getElementsByName( expando ).length === 2 + 
     3860                        // buggy browsers will return more than the correct 0 
     3861                        document.getElementsByName( expando + 0 ).length; 
     3862                assertGetIdNotName = !document.getElementById( expando ); 
     3863 
     3864                // Cleanup 
     3865                docElem.removeChild( div ); 
     3866 
     3867                return pass; 
     3868        }); 
     3869 
     3870// If slice is not available, provide a backup 
     3871try { 
     3872        slice.call( docElem.childNodes, 0 )[0].nodeType; 
     3873} catch ( e ) { 
     3874        slice = function( i ) { 
     3875                var elem, 
     3876                        results = []; 
     3877                for ( ; (elem = this[i]); i++ ) { 
     3878                        results.push( elem ); 
     3879                } 
     3880                return results; 
     3881        }; 
     3882} 
     3883 
     3884function Sizzle( selector, context, results, seed ) { 
    39683885        results = results || []; 
    39693886        context = context || document; 
    3970  
    3971         var origContext = context; 
    3972  
    3973         if ( context.nodeType !== 1 && context.nodeType !== 9 ) { 
    3974                 return []; 
    3975         } 
     3887        var match, elem, xml, m, 
     3888                nodeType = context.nodeType; 
    39763889 
    39773890        if ( !selector || typeof selector !== "string" ) { 
     
    39793892        } 
    39803893 
    3981         var m, set, checkSet, extra, ret, cur, pop, i, 
    3982                 prune = true, 
    3983                 contextXML = Sizzle.isXML( context ), 
    3984                 parts = [], 
    3985                 soFar = selector; 
    3986  
    3987         // Reset the position of the chunker regexp (start from head) 
    3988         do { 
    3989                 chunker.exec( "" ); 
    3990                 m = chunker.exec( soFar ); 
    3991  
    3992                 if ( m ) { 
    3993                         soFar = m[3]; 
    3994  
    3995                         parts.push( m[1] ); 
    3996  
    3997                         if ( m[2] ) { 
    3998                                 extra = m[3]; 
    3999                                 break; 
    4000                         } 
    4001                 } 
    4002         } while ( m ); 
    4003  
    4004         if ( parts.length > 1 && origPOS.exec( selector ) ) { 
    4005  
    4006                 if ( parts.length === 2 && Expr.relative[ parts[0] ] ) { 
    4007                         set = posProcess( parts[0] + parts[1], context, seed ); 
    4008  
    4009                 } else { 
    4010                         set = Expr.relative[ parts[0] ] ? 
    4011                                 [ context ] : 
    4012                                 Sizzle( parts.shift(), context ); 
    4013  
    4014                         while ( parts.length ) { 
    4015                                 selector = parts.shift(); 
    4016  
    4017                                 if ( Expr.relative[ selector ] ) { 
    4018                                         selector += parts.shift(); 
    4019                                 } 
    4020  
    4021                                 set = posProcess( selector, set, seed ); 
    4022                         } 
    4023                 } 
    4024  
     3894        if ( nodeType !== 1 && nodeType !== 9 ) { 
     3895                return []; 
     3896        } 
     3897 
     3898        xml = isXML( context ); 
     3899 
     3900        if ( !xml && !seed ) { 
     3901                if ( (match = rquickExpr.exec( selector )) ) { 
     3902                        // Speed-up: Sizzle("#ID") 
     3903                        if ( (m = match[1]) ) { 
     3904                                if ( nodeType === 9 ) { 
     3905                                        elem = context.getElementById( m ); 
     3906                                        // Check parentNode to catch when Blackberry 4.6 returns 
     3907                                        // nodes that are no longer in the document #6963 
     3908                                        if ( elem && elem.parentNode ) { 
     3909                                                // Handle the case where IE, Opera, and Webkit return items 
     3910                                                // by name instead of ID 
     3911                                                if ( elem.id === m ) { 
     3912                                                        results.push( elem ); 
     3913                                                        return results; 
     3914                                                } 
     3915                                        } else { 
     3916                                                return results; 
     3917                                        } 
     3918                                } else { 
     3919                                        // Context is not a document 
     3920                                        if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) && 
     3921                                                contains( context, elem ) && elem.id === m ) { 
     3922                                                results.push( elem ); 
     3923                                                return results; 
     3924                                        } 
     3925                                } 
     3926 
     3927                        // Speed-up: Sizzle("TAG") 
     3928                        } else if ( match[2] ) { 
     3929                                push.apply( results, slice.call(context.getElementsByTagName( selector ), 0) ); 
     3930                                return results; 
     3931 
     3932                        // Speed-up: Sizzle(".CLASS") 
     3933                        } else if ( (m = match[3]) && assertUsableClassName && context.getElementsByClassName ) { 
     3934                                push.apply( results, slice.call(context.getElementsByClassName( m ), 0) ); 
     3935                                return results; 
     3936                        } 
     3937                } 
     3938        } 
     3939 
     3940        // All others 
     3941        return select( selector.replace( rtrim, "$1" ), context, results, seed, xml ); 
     3942} 
     3943 
     3944Sizzle.matches = function( expr, elements ) { 
     3945        return Sizzle( expr, null, null, elements ); 
     3946}; 
     3947 
     3948Sizzle.matchesSelector = function( elem, expr ) { 
     3949        return Sizzle( expr, null, null, [ elem ] ).length > 0; 
     3950}; 
     3951 
     3952// Returns a function to use in pseudos for input types 
     3953function createInputPseudo( type ) { 
     3954        return function( elem ) { 
     3955                var name = elem.nodeName.toLowerCase(); 
     3956                return name === "input" && elem.type === type; 
     3957        }; 
     3958} 
     3959 
     3960// Returns a function to use in pseudos for buttons 
     3961function createButtonPseudo( type ) { 
     3962        return function( elem ) { 
     3963                var name = elem.nodeName.toLowerCase(); 
     3964                return (name === "input" || name === "button") && elem.type === type; 
     3965        }; 
     3966} 
     3967 
     3968// Returns a function to use in pseudos for positionals 
     3969function createPositionalPseudo( fn ) { 
     3970        return markFunction(function( argument ) { 
     3971                argument = +argument; 
     3972                return markFunction(function( seed, matches ) { 
     3973                        var j, 
     3974                                matchIndexes = fn( [], seed.length, argument ), 
     3975                                i = matchIndexes.length; 
     3976 
     3977                        // Match elements found at the specified indexes 
     3978                        while ( i-- ) { 
     3979                                if ( seed[ (j = matchIndexes[i]) ] ) { 
     3980                                        seed[j] = !(matches[j] = seed[j]); 
     3981                                } 
     3982                        } 
     3983                }); 
     3984        }); 
     3985} 
     3986 
     3987/** 
     3988 * Utility function for retrieving the text value of an array of DOM nodes 
     3989 * @param {Array|Element} elem 
     3990 */ 
     3991getText = Sizzle.getText = function( elem ) { 
     3992        var node, 
     3993                ret = "", 
     3994                i = 0, 
     3995                nodeType = elem.nodeType; 
     3996 
     3997        if ( nodeType ) { 
     3998                if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { 
     3999                        // Use textContent for elements 
     4000                        // innerText usage removed for consistency of new lines (see #11153) 
     4001                        if ( typeof elem.textContent === "string" ) { 
     4002                                return elem.textContent; 
     4003                        } else { 
     4004                                // Traverse its children 
     4005                                for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { 
     4006                                        ret += getText( elem ); 
     4007                                } 
     4008                        } 
     4009                } else if ( nodeType === 3 || nodeType === 4 ) { 
     4010                        return elem.nodeValue; 
     4011                } 
     4012                // Do not include comment or processing instruction nodes 
    40254013        } else { 
    4026                 // Take a shortcut and set the context if the root selector is an ID 
    4027                 // (but not if it'll be faster if the inner selector is an ID) 
    4028                 if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML && 
    4029                                 Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) { 
    4030  
    4031                         ret = Sizzle.find( parts.shift(), context, contextXML ); 
    4032                         context = ret.expr ? 
    4033                                 Sizzle.filter( ret.expr, ret.set )[0] : 
    4034                                 ret.set[0]; 
    4035                 } 
    4036  
    4037                 if ( context ) { 
    4038                         ret = seed ? 
    4039                                 { expr: parts.pop(), set: makeArray(seed) } : 
    4040                                 Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML ); 
    4041  
    4042                         set = ret.expr ? 
    4043                                 Sizzle.filter( ret.expr, ret.set ) : 
    4044                                 ret.set; 
    4045  
    4046                         if ( parts.length > 0 ) { 
    4047                                 checkSet = makeArray( set ); 
    4048  
    4049                         } else { 
    4050                                 prune = false; 
    4051                         } 
    4052  
    4053                         while ( parts.length ) { 
    4054                                 cur = parts.pop(); 
    4055                                 pop = cur; 
    4056  
    4057                                 if ( !Expr.relative[ cur ] ) { 
    4058                                         cur = ""; 
    4059                                 } else { 
    4060                                         pop = parts.pop(); 
    4061                                 } 
    4062  
    4063                                 if ( pop == null ) { 
    4064                                         pop = context; 
    4065                                 } 
    4066  
    4067                                 Expr.relative[ cur ]( checkSet, pop, contextXML ); 
    4068                         } 
    4069  
    4070                 } else { 
    4071                         checkSet = parts = []; 
    4072                 } 
    4073         } 
    4074  
    4075         if ( !checkSet ) { 
    4076                 checkSet = set; 
    4077         } 
    4078  
    4079         if ( !checkSet ) { 
    4080                 Sizzle.error( cur || selector ); 
    4081         } 
    4082  
    4083         if ( toString.call(checkSet) === "[object Array]" ) { 
    4084                 if ( !prune ) { 
    4085                         results.push.apply( results, checkSet ); 
    4086  
    4087                 } else if ( context && context.nodeType === 1 ) { 
    4088                         for ( i = 0; checkSet[i] != null; i++ ) { 
    4089                                 if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) { 
    4090                                         results.push( set[i] ); 
    4091                                 } 
    4092                         } 
    4093  
    4094                 } else { 
    4095                         for ( i = 0; checkSet[i] != null; i++ ) { 
    4096                                 if ( checkSet[i] && checkSet[i].nodeType === 1 ) { 
    4097                                         results.push( set[i] ); 
    4098                                 } 
    4099                         } 
    4100                 } 
    4101  
    4102         } else { 
    4103                 makeArray( checkSet, results ); 
    4104         } 
    4105  
    4106         if ( extra ) { 
    4107                 Sizzle( extra, origContext, results, seed ); 
    4108                 Sizzle.uniqueSort( results ); 
    4109         } 
    4110  
    4111         return results; 
     4014 
     4015                // If no nodeType, this is expected to be an array 
     4016                for ( ; (node = elem[i]); i++ ) { 
     4017                        // Do not traverse comment nodes 
     4018                        ret += getText( node ); 
     4019                } 
     4020        } 
     4021        return ret; 
    41124022}; 
    41134023 
    4114 Sizzle.uniqueSort = function( results ) { 
    4115         if ( sortOrder ) { 
    4116                 hasDuplicate = baseHasDuplicate; 
    4117                 results.sort( sortOrder ); 
    4118  
    4119                 if ( hasDuplicate ) { 
    4120                         for ( var i = 1; i < results.length; i++ ) { 
    4121                                 if ( results[i] === results[ i - 1 ] ) { 
    4122                                         results.splice( i--, 1 ); 
    4123                                 } 
    4124                         } 
    4125                 } 
    4126         } 
    4127  
    4128         return results; 
     4024isXML = Sizzle.isXML = function( elem ) { 
     4025        // documentElement is verified for cases where it doesn't yet exist 
     4026        // (such as loading iframes in IE - #4833) 
     4027        var documentElement = elem && (elem.ownerDocument || elem).documentElement; 
     4028        return documentElement ? documentElement.nodeName !== "HTML" : false; 
    41294029}; 
    41304030 
    4131 Sizzle.matches = function( expr, set ) { 
    4132         return Sizzle( expr, null, null, set ); 
     4031// Element contains another 
     4032contains = Sizzle.contains = docElem.contains ? 
     4033        function( a, b ) { 
     4034                var adown = a.nodeType === 9 ? a.documentElement : a, 
     4035                        bup = b && b.parentNode; 
     4036                return a === bup || !!( bup && bup.nodeType === 1 && adown.contains && adown.contains(bup) ); 
     4037        } : 
     4038        docElem.compareDocumentPosition ? 
     4039        function( a, b ) { 
     4040                return b && !!( a.compareDocumentPosition( b ) & 16 ); 
     4041        } : 
     4042        function( a, b ) { 
     4043                while ( (b = b.parentNode) ) { 
     4044                        if ( b === a ) { 
     4045                                return true; 
     4046                        } 
     4047                } 
     4048                return false; 
     4049        }; 
     4050 
     4051Sizzle.attr = function( elem, name ) { 
     4052        var val, 
     4053                xml = isXML( elem ); 
     4054 
     4055        if ( !xml ) { 
     4056                name = name.toLowerCase(); 
     4057        } 
     4058        if ( (val = Expr.attrHandle[ name ]) ) { 
     4059                return val( elem ); 
     4060        } 
     4061        if ( xml || assertAttributes ) { 
     4062                return elem.getAttribute( name ); 
     4063        } 
     4064        val = elem.getAttributeNode( name ); 
     4065        return val ? 
     4066                typeof elem[ name ] === "boolean" ? 
     4067                        elem[ name ] ? name : null : 
     4068                        val.specified ? val.value : null : 
     4069                null; 
    41334070}; 
    41344071 
    4135 Sizzle.matchesSelector = function( node, expr ) { 
    4136         return Sizzle( expr, null, null, [node] ).length > 0; 
    4137 }; 
    4138  
    4139 Sizzle.find = function( expr, context, isXML ) { 
    4140         var set, i, len, match, type, left; 
    4141  
    4142         if ( !expr ) { 
    4143                 return []; 
    4144         } 
    4145  
    4146         for ( i = 0, len = Expr.order.length; i < len; i++ ) { 
    4147                 type = Expr.order[i]; 
    4148  
    4149                 if ( (match = Expr.leftMatch[ type ].exec( expr )) ) { 
    4150                         left = match[1]; 
    4151                         match.splice( 1, 1 ); 
    4152  
    4153                         if ( left.substr( left.length - 1 ) !== "\\" ) { 
    4154                                 match[1] = (match[1] || "").replace( rBackslash, "" ); 
    4155                                 set = Expr.find[ type ]( match, context, isXML ); 
    4156  
    4157                                 if ( set != null ) { 
    4158                                         expr = expr.replace( Expr.match[ type ], "" ); 
    4159                                         break; 
    4160                                 } 
    4161                         } 
    4162                 } 
    4163         } 
    4164  
    4165         if ( !set ) { 
    4166                 set = typeof context.getElementsByTagName !== "undefined" ? 
    4167                         context.getElementsByTagName( "*" ) : 
    4168                         []; 
    4169         } 
    4170  
    4171         return { set: set, expr: expr }; 
    4172 }; 
    4173  
    4174 Sizzle.filter = function( expr, set, inplace, not ) { 
    4175         var match, anyFound, 
    4176                 type, found, item, filter, left, 
    4177                 i, pass, 
    4178                 old = expr, 
    4179                 result = [], 
    4180                 curLoop = set, 
    4181                 isXMLFilter = set && set[0] && Sizzle.isXML( set[0] ); 
    4182  
    4183         while ( expr && set.length ) { 
    4184                 for ( type in Expr.filter ) { 
    4185                         if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) { 
    4186                                 filter = Expr.filter[ type ]; 
    4187                                 left = match[1]; 
    4188  
    4189                                 anyFound = false; 
    4190  
    4191                                 match.splice(1,1); 
    4192  
    4193                                 if ( left.substr( left.length - 1 ) === "\\" ) { 
    4194                                         continue; 
    4195                                 } 
    4196  
    4197                                 if ( curLoop === result ) { 
    4198                                         result = []; 
    4199                                 } 
    4200  
    4201                                 if ( Expr.preFilter[ type ] ) { 
    4202                                         match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter ); 
    4203  
    4204                                         if ( !match ) { 
    4205                                                 anyFound = found = true; 
    4206  
    4207                                         } else if ( match === true ) { 
    4208                                                 continue; 
     4072Expr = Sizzle.selectors = { 
     4073 
     4074        // Can be adjusted by the user 
     4075        cacheLength: 50, 
     4076 
     4077        createPseudo: markFunction, 
     4078 
     4079        match: matchExpr, 
     4080 
     4081        // IE6/7 return a modified href 
     4082        attrHandle: assertHrefNotNormalized ? 
     4083                {} : 
     4084                { 
     4085                        "href": function( elem ) { 
     4086                                return elem.getAttribute( "href", 2 ); 
     4087                        }, 
     4088                        "type": function( elem ) { 
     4089                                return elem.getAttribute("type"); 
     4090                        } 
     4091                }, 
     4092 
     4093        find: { 
     4094                "ID": assertGetIdNotName ? 
     4095                        function( id, context, xml ) { 
     4096                                if ( typeof context.getElementById !== strundefined && !xml ) { 
     4097                                        var m = context.getElementById( id ); 
     4098                                        // Check parentNode to catch when Blackberry 4.6 returns 
     4099                                        // nodes that are no longer in the document #6963 
     4100                                        return m && m.parentNode ? [m] : []; 
     4101                                } 
     4102                        } : 
     4103                        function( id, context, xml ) { 
     4104                                if ( typeof context.getElementById !== strundefined && !xml ) { 
     4105                                        var m = context.getElementById( id ); 
     4106 
     4107                                        return m ? 
     4108                                                m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ? 
     4109                                                        [m] : 
     4110                                                        undefined : 
     4111                                                []; 
     4112                                } 
     4113                        }, 
     4114 
     4115                "TAG": assertTagNameNoComments ? 
     4116                        function( tag, context ) { 
     4117                                if ( typeof context.getElementsByTagName !== strundefined ) { 
     4118                                        return context.getElementsByTagName( tag ); 
     4119                                } 
     4120                        } : 
     4121                        function( tag, context ) { 
     4122                                var results = context.getElementsByTagName( tag ); 
     4123 
     4124                                // Filter out possible comments 
     4125                                if ( tag === "*" ) { 
     4126                                        var elem, 
     4127                                                tmp = [], 
     4128                                                i = 0; 
     4129 
     4130                                        for ( ; (elem = results[i]); i++ ) { 
     4131                                                if ( elem.nodeType === 1 ) { 
     4132                                                        tmp.push( elem ); 
     4133                                                } 
    42094134                                        } 
    4210                                 } 
    4211  
    4212                                 if ( match ) { 
    4213                                         for ( i = 0; (item = curLoop[i]) != null; i++ ) { 
    4214                                                 if ( item ) { 
    4215                                                         found = filter( item, match, i, curLoop ); 
    4216                                                         pass = not ^ found; 
    4217  
    4218                                                         if ( inplace && found != null ) { 
    4219                                                                 if ( pass ) { 
    4220                                                                         anyFound = true; 
    4221  
    4222                                                                 } else { 
    4223                                                                         curLoop[i] = false; 
     4135 
     4136                                        return tmp; 
     4137                                } 
     4138                                return results; 
     4139                        }, 
     4140 
     4141                "NAME": assertUsableName && function( tag, context ) { 
     4142                        if ( typeof context.getElementsByName !== strundefined ) { 
     4143                                return context.getElementsByName( name ); 
     4144                        } 
     4145                }, 
     4146 
     4147                "CLASS": assertUsableClassName && function( className, context, xml ) { 
     4148                        if ( typeof context.getElementsByClassName !== strundefined && !xml ) { 
     4149                                return context.getElementsByClassName( className ); 
     4150                        } 
     4151                } 
     4152        }, 
     4153 
     4154        relative: { 
     4155                ">": { dir: "parentNode", first: true }, 
     4156                " ": { dir: "parentNode" }, 
     4157                "+": { dir: "previousSibling", first: true }, 
     4158                "~": { dir: "previousSibling" } 
     4159        }, 
     4160 
     4161        preFilter: { 
     4162                "ATTR": function( match ) { 
     4163                        match[1] = match[1].replace( rbackslash, "" ); 
     4164 
     4165                        // Move the given value to match[3] whether quoted or unquoted 
     4166                        match[3] = ( match[4] || match[5] || "" ).replace( rbackslash, "" ); 
     4167 
     4168                        if ( match[2] === "~=" ) { 
     4169                                match[3] = " " + match[3] + " "; 
     4170                        } 
     4171 
     4172                        return match.slice( 0, 4 ); 
     4173                }, 
     4174 
     4175                "CHILD": function( match ) { 
     4176                        /* matches from matchExpr["CHILD"] 
     4177                                1 type (only|nth|...) 
     4178                                2 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 
     4179                                3 xn-component of xn+y argument ([+-]?\d*n|) 
     4180                                4 sign of xn-component 
     4181                                5 x of xn-component 
     4182                                6 sign of y-component 
     4183                                7 y of y-component 
     4184                        */ 
     4185                        match[1] = match[1].toLowerCase(); 
     4186 
     4187                        if ( match[1] === "nth" ) { 
     4188                                // nth-child requires argument 
     4189                                if ( !match[2] ) { 
     4190                                        Sizzle.error( match[0] ); 
     4191                                } 
     4192 
     4193                                // numeric x and y parameters for Expr.filter.CHILD 
     4194                                // remember that false/true cast respectively to 0/1 
     4195                                match[3] = +( match[3] ? match[4] + (match[5] || 1) : 2 * ( match[2] === "even" || match[2] === "odd" ) ); 
     4196                                match[4] = +( ( match[6] + match[7] ) || match[2] === "odd" ); 
     4197 
     4198                        // other types prohibit arguments 
     4199                        } else if ( match[2] ) { 
     4200                                Sizzle.error( match[0] ); 
     4201                        } 
     4202 
     4203                        return match; 
     4204                }, 
     4205 
     4206                "PSEUDO": function( match ) { 
     4207                        var unquoted, excess; 
     4208                        if ( matchExpr["CHILD"].test( match[0] ) ) { 
     4209                                return null; 
     4210                        } 
     4211 
     4212                        if ( match[3] ) { 
     4213                                match[2] = match[3]; 
     4214                        } else if ( (unquoted = match[4]) ) { 
     4215                                // Only check arguments that contain a pseudo 
     4216                                if ( rpseudo.test(unquoted) && 
     4217                                        // Get excess from tokenize (recursively) 
     4218                                        (excess = tokenize( unquoted, true )) && 
     4219                                        // advance to the next closing parenthesis 
     4220                                        (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) { 
     4221 
     4222                                        // excess is a negative index 
     4223                                        unquoted = unquoted.slice( 0, excess ); 
     4224                                        match[0] = match[0].slice( 0, excess ); 
     4225                                } 
     4226                                match[2] = unquoted; 
     4227                        } 
     4228 
     4229                        // Return only captures needed by the pseudo filter method (type and argument) 
     4230                        return match.slice( 0, 3 ); 
     4231                } 
     4232        }, 
     4233 
     4234        filter: { 
     4235                "ID": assertGetIdNotName ? 
     4236                        function( id ) { 
     4237                                id = id.replace( rbackslash, "" ); 
     4238                                return function( elem ) { 
     4239                                        return elem.getAttribute("id") === id; 
     4240                                }; 
     4241                        } : 
     4242                        function( id ) { 
     4243                                id = id.replace( rbackslash, "" ); 
     4244                                return function( elem ) { 
     4245                                        var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id"); 
     4246                                        return node && node.value === id; 
     4247                                }; 
     4248                        }, 
     4249 
     4250                "TAG": function( nodeName ) { 
     4251                        if ( nodeName === "*" ) { 
     4252                                return function() { return true; }; 
     4253                        } 
     4254                        nodeName = nodeName.replace( rbackslash, "" ).toLowerCase(); 
     4255 
     4256                        return function( elem ) { 
     4257                                return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; 
     4258                        }; 
     4259                }, 
     4260 
     4261                "CLASS": function( className ) { 
     4262                        var pattern = classCache[ expando ][ className ]; 
     4263                        if ( !pattern ) { 
     4264                                pattern = classCache( className, new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)") ); 
     4265                        } 
     4266                        return function( elem ) { 
     4267                                return pattern.test( elem.className || (typeof elem.getAttribute !== strundefined && elem.getAttribute("class")) || "" ); 
     4268                        }; 
     4269                }, 
     4270 
     4271                "ATTR": function( name, operator, check ) { 
     4272                        return function( elem, context ) { 
     4273                                var result = Sizzle.attr( elem, name ); 
     4274 
     4275                                if ( result == null ) { 
     4276                                        return operator === "!="; 
     4277                                } 
     4278                                if ( !operator ) { 
     4279                                        return true; 
     4280                                } 
     4281 
     4282                                result += ""; 
     4283 
     4284                                return operator === "=" ? result === check : 
     4285                                        operator === "!=" ? result !== check : 
     4286                                        operator === "^=" ? check && result.indexOf( check ) === 0 : 
     4287                                        operator === "*=" ? check && result.indexOf( check ) > -1 : 
     4288                                        operator === "$=" ? check && result.substr( result.length - check.length ) === check : 
     4289                                        operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 : 
     4290                                        operator === "|=" ? result === check || result.substr( 0, check.length + 1 ) === check + "-" : 
     4291                                        false; 
     4292                        }; 
     4293                }, 
     4294 
     4295                "CHILD": function( type, argument, first, last ) { 
     4296 
     4297                        if ( type === "nth" ) { 
     4298                                return function( elem ) { 
     4299                                        var node, diff, 
     4300                                                parent = elem.parentNode; 
     4301 
     4302                                        if ( first === 1 && last === 0 ) { 
     4303                                                return true; 
     4304                                        } 
     4305 
     4306                                        if ( parent ) { 
     4307                                                diff = 0; 
     4308                                                for ( node = parent.firstChild; node; node = node.nextSibling ) { 
     4309                                                        if ( node.nodeType === 1 ) { 
     4310                                                                diff++; 
     4311                                                                if ( elem === node ) { 
     4312                                                                        break; 
    42244313                                                                } 
    4225  
    4226                                                         } else if ( pass ) { 
    4227                                                                 result.push( item ); 
    4228                                                                 anyFound = true; 
    42294314                                                        } 
    42304315                                                } 
    42314316                                        } 
    4232                                 } 
    4233  
    4234                                 if ( found !== undefined ) { 
    4235                                         if ( !inplace ) { 
    4236                                                 curLoop = result; 
     4317 
     4318                                        // Incorporate the offset (or cast to NaN), then check against cycle size 
     4319                                        diff -= last; 
     4320                                        return diff === first || ( diff % first === 0 && diff / first >= 0 ); 
     4321                                }; 
     4322                        } 
     4323 
     4324                        return function( elem ) { 
     4325                                var node = elem; 
     4326 
     4327                                switch ( type ) { 
     4328                                        case "only": 
     4329                                        case "first": 
     4330                                                while ( (node = node.previousSibling) ) { 
     4331                                                        if ( node.nodeType === 1 ) { 
     4332                                                                return false; 
     4333                                                        } 
     4334                                                } 
     4335 
     4336                                                if ( type === "first" ) { 
     4337                                                        return true; 
     4338                                                } 
     4339 
     4340                                                node = elem; 
     4341 
     4342                                                /* falls through */ 
     4343                                        case "last": 
     4344                                                while ( (node = node.nextSibling) ) { 
     4345                                                        if ( node.nodeType === 1 ) { 
     4346                                                                return false; 
     4347                                                        } 
     4348                                                } 
     4349 
     4350                                                return true; 
     4351                                } 
     4352                        }; 
     4353                }, 
     4354 
     4355                "PSEUDO": function( pseudo, argument ) { 
     4356                        // pseudo-class names are case-insensitive 
     4357                        // http://www.w3.org/TR/selectors/#pseudo-classes 
     4358                        // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters 
     4359                        // Remember that setFilters inherits from pseudos 
     4360                        var args, 
     4361                                fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || 
     4362                                        Sizzle.error( "unsupported pseudo: " + pseudo ); 
     4363 
     4364                        // The user may use createPseudo to indicate that 
     4365                        // arguments are needed to create the filter function 
     4366                        // just as Sizzle does 
     4367                        if ( fn[ expando ] ) { 
     4368                                return fn( argument ); 
     4369                        } 
     4370 
     4371                        // But maintain support for old signatures 
     4372                        if ( fn.length > 1 ) { 
     4373                                args = [ pseudo, pseudo, "", argument ]; 
     4374                                return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? 
     4375                                        markFunction(function( seed, matches ) { 
     4376                                                var idx, 
     4377                                                        matched = fn( seed, argument ), 
     4378                                                        i = matched.length; 
     4379                                                while ( i-- ) { 
     4380                                                        idx = indexOf.call( seed, matched[i] ); 
     4381                                                        seed[ idx ] = !( matches[ idx ] = matched[i] ); 
     4382                                                } 
     4383                                        }) : 
     4384                                        function( elem ) { 
     4385                                                return fn( elem, 0, args ); 
     4386                                        }; 
     4387                        } 
     4388 
     4389                        return fn; 
     4390                } 
     4391        }, 
     4392 
     4393        pseudos: { 
     4394                "not": markFunction(function( selector ) { 
     4395                        // Trim the selector passed to compile 
     4396                        // to avoid treating leading and trailing 
     4397                        // spaces as combinators 
     4398                        var input = [], 
     4399                                results = [], 
     4400                                matcher = compile( selector.replace( rtrim, "$1" ) ); 
     4401 
     4402                        return matcher[ expando ] ? 
     4403                                markFunction(function( seed, matches, context, xml ) { 
     4404                                        var elem, 
     4405                                                unmatched = matcher( seed, null, xml, [] ), 
     4406                                                i = seed.length; 
     4407 
     4408                                        // Match elements unmatched by `matcher` 
     4409                                        while ( i-- ) { 
     4410                                                if ( (elem = unmatched[i]) ) { 
     4411                                                        seed[i] = !(matches[i] = elem); 
     4412                                                } 
    42374413                                        } 
    4238  
    4239                                         expr = expr.replace( Expr.match[ type ], "" ); 
    4240  
    4241                                         if ( !anyFound ) { 
    4242                                                 return []; 
    4243                                         } 
    4244  
    4245                                         break; 
    4246                                 } 
    4247                         } 
    4248                 } 
    4249  
    4250                 // Improper expression 
    4251                 if ( expr === old ) { 
    4252                         if ( anyFound == null ) { 
    4253                                 Sizzle.error( expr ); 
    4254  
    4255                         } else { 
    4256                                 break; 
    4257                         } 
    4258                 } 
    4259  
    4260                 old = expr; 
    4261         } 
    4262  
    4263         return curLoop; 
    4264 }; 
    4265  
    4266 Sizzle.error = function( msg ) { 
    4267         throw new Error( "Syntax error, unrecognized expression: " + msg ); 
    4268 }; 
    4269  
    4270 /** 
    4271  * Utility function for retreiving the text value of an array of DOM nodes 
    4272  * @param {Array|Element} elem 
    4273  */ 
    4274 var getText = Sizzle.getText = function( elem ) { 
    4275     var i, node, 
    4276                 nodeType = elem.nodeType, 
    4277                 ret = ""; 
    4278  
    4279         if ( nodeType ) { 
    4280                 if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { 
    4281                         // Use textContent || innerText for elements 
    4282                         if ( typeof elem.textContent === 'string' ) { 
    4283                                 return elem.textContent; 
    4284                         } else if ( typeof elem.innerText === 'string' ) { 
    4285                                 // Replace IE's carriage returns 
    4286                                 return elem.innerText.replace( rReturn, '' ); 
    4287                         } else { 
    4288                                 // Traverse it's children 
    4289                                 for ( elem = elem.firstChild; elem; elem = elem.nextSibling) { 
    4290                                         ret += getText( elem ); 
    4291                                 } 
    4292                         } 
    4293                 } else if ( nodeType === 3 || nodeType === 4 ) { 
    4294                         return elem.nodeValue; 
    4295                 } 
    4296         } else { 
    4297  
    4298                 // If no nodeType, this is expected to be an array 
    4299                 for ( i = 0; (node = elem[i]); i++ ) { 
    4300                         // Do not traverse comment nodes 
    4301                         if ( node.nodeType !== 8 ) { 
    4302                                 ret += getText( node ); 
    4303                         } 
    4304                 } 
    4305         } 
    4306         return ret; 
    4307 }; 
    4308  
    4309 var Expr = Sizzle.selectors = { 
    4310         order: [ "ID", "NAME", "TAG" ], 
    4311  
    4312         match: { 
    4313                 ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/, 
    4314                 CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/, 
    4315                 NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/, 
    4316                 ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/, 
    4317                 TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/, 
    4318                 CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/, 
    4319                 POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/, 
    4320                 PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/ 
    4321         }, 
    4322  
    4323         leftMatch: {}, 
    4324  
    4325         attrMap: { 
    4326                 "class": "className", 
    4327                 "for": "htmlFor" 
    4328         }, 
    4329  
    4330         attrHandle: { 
    4331                 href: function( elem ) { 
    4332                         return elem.getAttribute( "href" ); 
     4414                                }) : 
     4415                                function( elem, context, xml ) { 
     4416                                        input[0] = elem; 
     4417                                        matcher( input, null, xml, results ); 
     4418                                        return !results.pop(); 
     4419                                }; 
     4420                }), 
     4421 
     4422                "has": markFunction(function( selector ) { 
     4423                        return function( elem ) { 
     4424                                return Sizzle( selector, elem ).length > 0; 
     4425                        }; 
     4426                }), 
     4427 
     4428                "contains": markFunction(function( text ) { 
     4429                        return function( elem ) { 
     4430                                return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1; 
     4431                        }; 
     4432                }), 
     4433 
     4434                "enabled": function( elem ) { 
     4435                        return elem.disabled === false; 
    43334436                }, 
    4334                 type: function( elem ) { 
    4335                         return elem.getAttribute( "type" ); 
    4336                 } 
    4337         }, 
    4338  
    4339         relative: { 
    4340                 "+": function(checkSet, part){ 
    4341                         var isPartStr = typeof part === "string", 
    4342                                 isTag = isPartStr && !rNonWord.test( part ), 
    4343                                 isPartStrNotTag = isPartStr && !isTag; 
    4344  
    4345                         if ( isTag ) { 
    4346                                 part = part.toLowerCase(); 
    4347                         } 
    4348  
    4349                         for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) { 
    4350                                 if ( (elem = checkSet[i]) ) { 
    4351                                         while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {} 
    4352  
    4353                                         checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ? 
    4354                                                 elem || false : 
    4355                                                 elem === part; 
    4356                                 } 
    4357                         } 
    4358  
    4359                         if ( isPartStrNotTag ) { 
    4360                                 Sizzle.filter( part, checkSet, true ); 
    4361                         } 
    4362                 }, 
    4363  
    4364                 ">": function( checkSet, part ) { 
    4365                         var elem, 
    4366                                 isPartStr = typeof part === "string", 
    4367                                 i = 0, 
    4368                                 l = checkSet.length; 
    4369  
    4370                         if ( isPartStr && !rNonWord.test( part ) ) { 
    4371                                 part = part.toLowerCase(); 
    4372  
    4373                                 for ( ; i < l; i++ ) { 
    4374                                         elem = checkSet[i]; 
    4375  
    4376                                         if ( elem ) { 
    4377                                                 var parent = elem.parentNode; 
    4378                                                 checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false; 
    4379                                         } 
    4380                                 } 
    4381  
    4382                         } else { 
    4383                                 for ( ; i < l; i++ ) { 
    4384                                         elem = checkSet[i]; 
    4385  
    4386                                         if ( elem ) { 
    4387                                                 checkSet[i] = isPartStr ? 
    4388                                                         elem.parentNode : 
    4389                                                         elem.parentNode === part; 
    4390                                         } 
    4391                                 } 
    4392  
    4393                                 if ( isPartStr ) { 
    4394                                         Sizzle.filter( part, checkSet, true ); 
    4395                                 } 
    4396                         } 
    4397                 }, 
    4398  
    4399                 "": function(checkSet, part, isXML){ 
    4400                         var nodeCheck, 
    4401                                 doneName = done++, 
    4402                                 checkFn = dirCheck; 
    4403  
    4404                         if ( typeof part === "string" && !rNonWord.test( part ) ) { 
    4405                                 part = part.toLowerCase(); 
    4406                                 nodeCheck = part; 
    4407                                 checkFn = dirNodeCheck; 
    4408                         } 
    4409  
    4410                         checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML ); 
    4411                 }, 
    4412  
    4413                 "~": function( checkSet, part, isXML ) { 
    4414                         var nodeCheck, 
    4415                                 doneName = done++, 
    4416                                 checkFn = dirCheck; 
    4417  
    4418                         if ( typeof part === "string" && !rNonWord.test( part ) ) { 
    4419                                 part = part.toLowerCase(); 
    4420                                 nodeCheck = part; 
    4421                                 checkFn = dirNodeCheck; 
    4422                         } 
    4423  
    4424                         checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML ); 
    4425                 } 
    4426         }, 
    4427  
    4428         find: { 
    4429                 ID: function( match, context, isXML ) { 
    4430                         if ( typeof context.getElementById !== "undefined" && !isXML ) { 
    4431                                 var m = context.getElementById(match[1]); 
    4432                                 // Check parentNode to catch when Blackberry 4.6 returns 
    4433                                 // nodes that are no longer in the document #6963 
    4434                                 return m && m.parentNode ? [m] : []; 
    4435                         } 
    4436                 }, 
    4437  
    4438                 NAME: function( match, context ) { 
    4439                         if ( typeof context.getElementsByName !== "undefined" ) { 
    4440                                 var ret = [], 
    4441                                         results = context.getElementsByName( match[1] ); 
    4442  
    4443                                 for ( var i = 0, l = results.length; i < l; i++ ) { 
    4444                                         if ( results[i].getAttribute("name") === match[1] ) { 
    4445                                                 ret.push( results[i] ); 
    4446                                         } 
    4447                                 } 
    4448  
    4449                                 return ret.length === 0 ? null : ret; 
    4450                         } 
    4451                 }, 
    4452  
    4453                 TAG: function( match, context ) { 
    4454                         if ( typeof context.getElementsByTagName !== "undefined" ) { 
    4455                                 return context.getElementsByTagName( match[1] ); 
    4456                         } 
    4457                 } 
    4458         }, 
    4459         preFilter: { 
    4460                 CLASS: function( match, curLoop, inplace, result, not, isXML ) { 
    4461                         match = " " + match[1].replace( rBackslash, "" ) + " "; 
    4462  
    4463                         if ( isXML ) { 
    4464                                 return match; 
    4465                         } 
    4466  
    4467                         for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) { 
    4468                                 if ( elem ) { 
    4469                                         if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) { 
    4470                                                 if ( !inplace ) { 
    4471                                                         result.push( elem ); 
    4472                                                 } 
    4473  
    4474                                         } else if ( inplace ) { 
    4475                                                 curLoop[i] = false; 
    4476                                         } 
    4477                                 } 
    4478                         } 
    4479  
    4480                         return false; 
    4481                 }, 
    4482  
    4483                 ID: function( match ) { 
    4484                         return match[1].replace( rBackslash, "" ); 
    4485                 }, 
    4486  
    4487                 TAG: function( match, curLoop ) { 
    4488                         return match[1].replace( rBackslash, "" ).toLowerCase(); 
    4489                 }, 
    4490  
    4491                 CHILD: function( match ) { 
    4492                         if ( match[1] === "nth" ) { 
    4493                                 if ( !match[2] ) { 
    4494                                         Sizzle.error( match[0] ); 
    4495                                 } 
    4496  
    4497                                 match[2] = match[2].replace(/^\+|\s*/g, ''); 
    4498  
    4499                                 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6' 
    4500                                 var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec( 
    4501                                         match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" || 
    4502                                         !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]); 
    4503  
    4504                                 // calculate the numbers (first)n+(last) including if they are negative 
    4505                                 match[2] = (test[1] + (test[2] || 1)) - 0; 
    4506                                 match[3] = test[3] - 0; 
    4507                         } 
    4508                         else if ( match[2] ) { 
    4509                                 Sizzle.error( match[0] ); 
    4510                         } 
    4511  
    4512                         // TODO: Move to normal caching system 
    4513                         match[0] = done++; 
    4514  
    4515                         return match; 
    4516                 }, 
    4517  
    4518                 ATTR: function( match, curLoop, inplace, result, not, isXML ) { 
    4519                         var name = match[1] = match[1].replace( rBackslash, "" ); 
    4520  
    4521                         if ( !isXML && Expr.attrMap[name] ) { 
    4522                                 match[1] = Expr.attrMap[name]; 
    4523                         } 
    4524  
    4525                         // Handle if an un-quoted value was used 
    4526                         match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" ); 
    4527  
    4528                         if ( match[2] === "~=" ) { 
    4529                                 match[4] = " " + match[4] + " "; 
    4530                         } 
    4531  
    4532                         return match; 
    4533                 }, 
    4534  
    4535                 PSEUDO: function( match, curLoop, inplace, result, not ) { 
    4536                         if ( match[1] === "not" ) { 
    4537                                 // If we're dealing with a complex expression, or a simple one 
    4538                                 if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) { 
    4539                                         match[3] = Sizzle(match[3], null, null, curLoop); 
    4540  
    4541                                 } else { 
    4542                                         var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not); 
    4543  
    4544                                         if ( !inplace ) { 
    4545                                                 result.push.apply( result, ret ); 
    4546                                         } 
    4547  
    4548                                         return false; 
    4549                                 } 
    4550  
    4551                         } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) { 
    4552                                 return true; 
    4553                         } 
    4554  
    4555                         return match; 
    4556                 }, 
    4557  
    4558                 POS: function( match ) { 
    4559                         match.unshift( true ); 
    4560  
    4561                         return match; 
    4562                 } 
    4563         }, 
    4564  
    4565         filters: { 
    4566                 enabled: function( elem ) { 
    4567                         return elem.disabled === false && elem.type !== "hidden"; 
    4568                 }, 
    4569  
    4570                 disabled: function( elem ) { 
     4437 
     4438                "disabled": function( elem ) { 
    45714439                        return elem.disabled === true; 
    45724440                }, 
    45734441 
    4574                 checked: function( elem ) { 
    4575                         return elem.checked === true; 
     4442                "checked": function( elem ) { 
     4443                        // In CSS3, :checked should return both checked and selected elements 
     4444                        // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked 
     4445                        var nodeName = elem.nodeName.toLowerCase(); 
     4446                        return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected); 
    45764447                }, 
    45774448 
    4578                 selected: function( elem ) { 
     4449                "selected": function( elem ) { 
    45794450                        // Accessing this property makes selected-by-default 
    45804451                        // options in Safari work properly 
     
    45864457                }, 
    45874458 
    4588                 parent: function( elem ) { 
    4589                         return !!elem.firstChild; 
     4459                "parent": function( elem ) { 
     4460                        return !Expr.pseudos["empty"]( elem ); 
    45904461                }, 
    45914462 
    4592                 empty: function( elem ) { 
    4593                         return !elem.firstChild; 
     4463                "empty": function( elem ) { 
     4464                        // http://www.w3.org/TR/selectors/#empty-pseudo 
     4465                        // :empty is only affected by element nodes and content nodes(including text(3), cdata(4)), 
     4466                        //   not comment, processing instructions, or others 
     4467                        // Thanks to Diego Perini for the nodeName shortcut 
     4468                        //   Greater than "@" means alpha characters (specifically not starting with "#" or "?") 
     4469                        var nodeType; 
     4470                        elem = elem.firstChild; 
     4471                        while ( elem ) { 
     4472                                if ( elem.nodeName > "@" || (nodeType = elem.nodeType) === 3 || nodeType === 4 ) { 
     4473                                        return false; 
     4474                                } 
     4475                                elem = elem.nextSibling; 
     4476                        } 
     4477                        return true; 
    45944478                }, 
    45954479 
    4596                 has: function( elem, i, match ) { 
    4597                         return !!Sizzle( match[3], elem ).length; 
     4480                "header": function( elem ) { 
     4481                        return rheader.test( elem.nodeName ); 
    45984482                }, 
    45994483 
    4600                 header: function( elem ) { 
    4601                         return (/h\d/i).test( elem.nodeName ); 
    4602                 }, 
    4603  
    4604                 text: function( elem ) { 
    4605                         var attr = elem.getAttribute( "type" ), type = elem.type; 
     4484                "text": function( elem ) { 
     4485                        var type, attr; 
    46064486                        // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc) 
    46074487                        // use getAttribute instead to test this case 
    4608                         return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null ); 
     4488                        return elem.nodeName.toLowerCase() === "input" && 
     4489                                (type = elem.type) === "text" && 
     4490                                ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === type ); 
    46094491                }, 
    46104492 
    4611                 radio: function( elem ) { 
    4612                         return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type; 
     4493                // Input types 
     4494                "radio": createInputPseudo("radio"), 
     4495                "checkbox": createInputPseudo("checkbox"), 
     4496                "file": createInputPseudo("file"), 
     4497                "password": createInputPseudo("password"), 
     4498                "image": createInputPseudo("image"), 
     4499 
     4500                "submit": createButtonPseudo("submit"), 
     4501                "reset": createButtonPseudo("reset"), 
     4502 
     4503                "button": function( elem ) { 
     4504                        var name = elem.nodeName.toLowerCase(); 
     4505                        return name === "input" && elem.type === "button" || name === "button"; 
    46134506                }, 
    46144507 
    4615                 checkbox: function( elem ) { 
    4616                         return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type; 
     4508                "input": function( elem ) { 
     4509                        return rinputs.test( elem.nodeName ); 
    46174510                }, 
    46184511 
    4619                 file: function( elem ) { 
    4620                         return elem.nodeName.toLowerCase() === "input" && "file" === elem.type; 
     4512                "focus": function( elem ) { 
     4513                        var doc = elem.ownerDocument; 
     4514                        return elem === doc.activeElement && (!doc.hasFocus || doc.hasFocus()) && !!(elem.type || elem.href); 
    46214515                }, 
    46224516 
    4623                 password: function( elem ) { 
    4624                         return elem.nodeName.toLowerCase() === "input" && "password" === elem.type; 
     4517                "active": function( elem ) { 
     4518                        return elem === elem.ownerDocument.activeElement; 
    46254519                }, 
    46264520 
    4627                 submit: function( elem ) { 
    4628                         var name = elem.nodeName.toLowerCase(); 
    4629                         return (name === "input" || name === "button") && "submit" === elem.type; 
    4630                 }, 
    4631  
    4632                 image: function( elem ) { 
    4633                         return elem.nodeName.toLowerCase() === "input" && "image" === elem.type; 
    4634                 }, 
    4635  
    4636                 reset: function( elem ) { 
    4637                         var name = elem.nodeName.toLowerCase(); 
    4638                         return (name === "input" || name === "button") && "reset" === elem.type; 
    4639                 }, 
    4640  
    4641                 button: function( elem ) { 
    4642                         var name = elem.nodeName.toLowerCase(); 
    4643                         return name === "input" && "button" === elem.type || name === "button"; 
    4644                 }, 
    4645  
    4646                 input: function( elem ) { 
    4647                         return (/input|select|textarea|button/i).test( elem.nodeName ); 
    4648                 }, 
    4649  
    4650                 focus: function( elem ) { 
    4651                         return elem === elem.ownerDocument.activeElement; 
    4652                 } 
    4653         }, 
    4654         setFilters: { 
    4655                 first: function( elem, i ) { 
    4656                         return i === 0; 
    4657                 }, 
    4658  
    4659                 last: function( elem, i, match, array ) { 
    4660                         return i === array.length - 1; 
    4661                 }, 
    4662  
    4663                 even: function( elem, i ) { 
    4664                         return i % 2 === 0; 
    4665                 }, 
    4666  
    4667                 odd: function( elem, i ) { 
    4668                         return i % 2 === 1; 
    4669                 }, 
    4670  
    4671                 lt: function( elem, i, match ) { 
    4672                         return i < match[3] - 0; 
    4673                 }, 
    4674  
    4675                 gt: function( elem, i, match ) { 
    4676                         return i > match[3] - 0; 
    4677                 }, 
    4678  
    4679                 nth: function( elem, i, match ) { 
    4680                         return match[3] - 0 === i; 
    4681                 }, 
    4682  
    4683                 eq: function( elem, i, match ) { 
    4684                         return match[3] - 0 === i; 
    4685                 } 
    4686         }, 
    4687         filter: { 
    4688                 PSEUDO: function( elem, match, i, array ) { 
    4689                         var name = match[1], 
    4690                                 filter = Expr.filters[ name ]; 
    4691  
    4692                         if ( filter ) { 
    4693                                 return filter( elem, i, match, array ); 
    4694  
    4695                         } else if ( name === "contains" ) { 
    4696                                 return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0; 
    4697  
    4698                         } else if ( name === "not" ) { 
    4699                                 var not = match[3]; 
    4700  
    4701                                 for ( var j = 0, l = not.length; j < l; j++ ) { 
    4702                                         if ( not[j] === elem ) { 
    4703                                                 return false; 
    4704                                         } 
    4705                                 } 
    4706  
    4707                                 return true; 
    4708  
    4709                         } else { 
    4710                                 Sizzle.error( name ); 
    4711                         } 
    4712                 }, 
    4713  
    4714                 CHILD: function( elem, match ) { 
    4715                         var first, last, 
    4716                                 doneName, parent, cache, 
    4717                                 count, diff, 
    4718                                 type = match[1], 
    4719                                 node = elem; 
    4720  
    4721                         switch ( type ) { 
    4722                                 case "only": 
    4723                                 case "first": 
    4724                                         while ( (node = node.previousSibling) ) { 
    4725                                                 if ( node.nodeType === 1 ) { 
    4726                                                         return false; 
    4727                                                 } 
    4728                                         } 
    4729  
    4730                                         if ( type === "first" ) { 
    4731                                                 return true; 
    4732                                         } 
    4733  
    4734                                         node = elem; 
    4735  
    4736                                         /* falls through */ 
    4737                                 case "last": 
    4738                                         while ( (node = node.nextSibling) ) { 
    4739                                                 if ( node.nodeType === 1 ) { 
    4740                                                         return false; 
    4741                                                 } 
    4742                                         } 
    4743  
    4744                                         return true; 
    4745  
    4746                                 case "nth": 
    4747                                         first = match[2]; 
    4748                                         last = match[3]; 
    4749  
    4750                                         if ( first === 1 && last === 0 ) { 
    4751                                                 return true; 
    4752                                         } 
    4753  
    4754                                         doneName = match[0]; 
    4755                                         parent = elem.parentNode; 
    4756  
    4757                                         if ( parent && (parent[ expando ] !== doneName || !elem.nodeIndex) ) { 
    4758                                                 count = 0; 
    4759  
    4760                                                 for ( node = parent.firstChild; node; node = node.nextSibling ) { 
    4761                                                         if ( node.nodeType === 1 ) { 
    4762                                                                 node.nodeIndex = ++count; 
    4763                                                         } 
    4764                                                 } 
    4765  
    4766                                                 parent[ expando ] = doneName; 
    4767                                         } 
    4768  
    4769                                         diff = elem.nodeIndex - last; 
    4770  
    4771                                         if ( first === 0 ) { 
    4772                                                 return diff === 0; 
    4773  
    4774                                         } else { 
    4775                                                 return ( diff % first === 0 && diff / first >= 0 ); 
    4776                                         } 
    4777                         } 
    4778                 }, 
    4779  
    4780                 ID: function( elem, match ) { 
    4781                         return elem.nodeType === 1 && elem.getAttribute("id") === match; 
    4782                 }, 
    4783  
    4784                 TAG: function( elem, match ) { 
    4785                         return (match === "*" && elem.nodeType === 1) || !!elem.nodeName && elem.nodeName.toLowerCase() === match; 
    4786                 }, 
    4787  
    4788                 CLASS: function( elem, match ) { 
    4789                         return (" " + (elem.className || elem.getAttribute("class")) + " ") 
    4790                                 .indexOf( match ) > -1; 
    4791                 }, 
    4792  
    4793                 ATTR: function( elem, match ) { 
    4794                         var name = match[1], 
    4795                                 result = Sizzle.attr ? 
    4796                                         Sizzle.attr( elem, name ) : 
    4797                                         Expr.attrHandle[ name ] ? 
    4798                                         Expr.attrHandle[ name ]( elem ) : 
    4799                                         elem[ name ] != null ? 
    4800                                                 elem[ name ] : 
    4801                                                 elem.getAttribute( name ), 
    4802                                 value = result + "", 
    4803                                 type = match[2], 
    4804                                 check = match[4]; 
    4805  
    4806                         return result == null ? 
    4807                                 type === "!=" : 
    4808                                 !type && Sizzle.attr ? 
    4809                                 result != null : 
    4810                                 type === "=" ? 
    4811                                 value === check : 
    4812                                 type === "*=" ? 
    4813                                 value.indexOf(check) >= 0 : 
    4814                                 type === "~=" ? 
    4815                                 (" " + value + " ").indexOf(check) >= 0 : 
    4816                                 !check ? 
    4817                                 value && result !== false : 
    4818                                 type === "!=" ? 
    4819                                 value !== check : 
    4820                                 type === "^=" ? 
    4821                                 value.indexOf(check) === 0 : 
    4822                                 type === "$=" ? 
    4823                                 value.substr(value.length - check.length) === check : 
    4824                                 type === "|=" ? 
    4825                                 value === check || value.substr(0, check.length + 1) === check + "-" : 
    4826                                 false; 
    4827                 }, 
    4828  
    4829                 POS: function( elem, match, i, array ) { 
    4830                         var name = match[2], 
    4831                                 filter = Expr.setFilters[ name ]; 
    4832  
    4833                         if ( filter ) { 
    4834                                 return filter( elem, i, match, array ); 
    4835                         } 
    4836                 } 
     4521                // Positional types 
     4522                "first": createPositionalPseudo(function( matchIndexes, length, argument ) { 
     4523                        return [ 0 ]; 
     4524                }), 
     4525 
     4526                "last": createPositionalPseudo(function( matchIndexes, length, argument ) { 
     4527                        return [ length - 1 ]; 
     4528                }), 
     4529 
     4530                "eq": createPositionalPseudo(function( matchIndexes, length, argument ) { 
     4531                        return [ argument < 0 ? argument + length : argument ]; 
     4532                }), 
     4533 
     4534                "even": createPositionalPseudo(function( matchIndexes, length, argument ) { 
     4535                        for ( var i = 0; i < length; i += 2 ) { 
     4536                                matchIndexes.push( i ); 
     4537                        } 
     4538                        return matchIndexes; 
     4539                }), 
     4540 
     4541                "odd": createPositionalPseudo(function( matchIndexes, length, argument ) { 
     4542                        for ( var i = 1; i < length; i += 2 ) { 
     4543                                matchIndexes.push( i ); 
     4544                        } 
     4545                        return matchIndexes; 
     4546                }), 
     4547 
     4548                "lt": createPositionalPseudo(function( matchIndexes, length, argument ) { 
     4549                        for ( var i = argument < 0 ? argument + length : argument; --i >= 0; ) { 
     4550                                matchIndexes.push( i ); 
     4551                        } 
     4552                        return matchIndexes; 
     4553                }), 
     4554 
     4555                "gt": createPositionalPseudo(function( matchIndexes, length, argument ) { 
     4556                        for ( var i = argument < 0 ? argument + length : argument; ++i < length; ) { 
     4557                                matchIndexes.push( i ); 
     4558                        } 
     4559                        return matchIndexes; 
     4560                }) 
    48374561        } 
    48384562}; 
    48394563 
    4840 var origPOS = Expr.match.POS, 
    4841         fescape = function(all, num){ 
    4842                 return "\\" + (num - 0 + 1); 
    4843         }; 
    4844  
    4845 for ( var type in Expr.match ) { 
    4846         Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) ); 
    4847         Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) ); 
     4564function siblingCheck( a, b, ret ) { 
     4565        if ( a === b ) { 
     4566                return ret; 
     4567        } 
     4568 
     4569        var cur = a.nextSibling; 
     4570 
     4571        while ( cur ) { 
     4572                if ( cur === b ) { 
     4573                        return -1; 
     4574                } 
     4575 
     4576                cur = cur.nextSibling; 
     4577        } 
     4578 
     4579        return 1; 
    48484580} 
    4849 // Expose origPOS 
    4850 // "global" as in regardless of relation to brackets/parens 
    4851 Expr.match.globalPOS = origPOS; 
    4852  
    4853 var makeArray = function( array, results ) { 
    4854         array = Array.prototype.slice.call( array, 0 ); 
    4855  
    4856         if ( results ) { 
    4857                 results.push.apply( results, array ); 
    4858                 return results; 
    4859         } 
    4860  
    4861         return array; 
    4862 }; 
    4863  
    4864 // Perform a simple check to determine if the browser is capable of 
    4865 // converting a NodeList to an array using builtin methods. 
    4866 // Also verifies that the returned array holds DOM nodes 
    4867 // (which is not the case in the Blackberry browser) 
    4868 try { 
    4869         Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType; 
    4870  
    4871 // Provide a fallback method if it does not work 
    4872 } catch( e ) { 
    4873         makeArray = function( array, results ) { 
    4874                 var i = 0, 
    4875                         ret = results || []; 
    4876  
    4877                 if ( toString.call(array) === "[object Array]" ) { 
    4878                         Array.prototype.push.apply( ret, array ); 
    4879  
    4880                 } else { 
    4881                         if ( typeof array.length === "number" ) { 
    4882                                 for ( var l = array.length; i < l; i++ ) { 
    4883                                         ret.push( array[i] ); 
    4884                                 } 
    4885  
    4886                         } else { 
    4887                                 for ( ; array[i]; i++ ) { 
    4888                                         ret.push( array[i] ); 
    4889                                 } 
    4890                         } 
    4891                 } 
    4892  
    4893                 return ret; 
    4894         }; 
    4895 } 
    4896  
    4897 var sortOrder, siblingCheck; 
    4898  
    4899 if ( document.documentElement.compareDocumentPosition ) { 
    4900         sortOrder = function( a, b ) { 
     4581 
     4582sortOrder = docElem.compareDocumentPosition ? 
     4583        function( a, b ) { 
    49014584                if ( a === b ) { 
    49024585                        hasDuplicate = true; 
     
    49044587                } 
    49054588 
    4906                 if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) { 
    4907                         return a.compareDocumentPosition ? -1 : 1; 
    4908                 } 
    4909  
    4910                 return a.compareDocumentPosition(b) & 4 ? -1 : 1; 
    4911         }; 
    4912  
    4913 } else { 
    4914         sortOrder = function( a, b ) { 
     4589                return ( !a.compareDocumentPosition || !b.compareDocumentPosition ? 
     4590                        a.compareDocumentPosition : 
     4591                        a.compareDocumentPosition(b) & 4 
     4592                ) ? -1 : 1; 
     4593        } : 
     4594        function( a, b ) { 
    49154595                // The nodes are identical, we can exit early 
    49164596                if ( a === b ) { 
     
    49724652        }; 
    49734653 
    4974         siblingCheck = function( a, b, ret ) { 
    4975                 if ( a === b ) { 
    4976                         return ret; 
    4977                 } 
    4978  
    4979                 var cur = a.nextSibling; 
    4980  
    4981                 while ( cur ) { 
    4982                         if ( cur === b ) { 
    4983                                 return -1; 
    4984                         } 
    4985  
    4986                         cur = cur.nextSibling; 
    4987                 } 
    4988  
    4989                 return 1; 
    4990         }; 
     4654// Always assume the presence of duplicates if sort doesn't 
     4655// pass them to our comparison function (as in Google Chrome). 
     4656[0, 0].sort( sortOrder ); 
     4657baseHasDuplicate = !hasDuplicate; 
     4658 
     4659// Document sorting and removing duplicates 
     4660Sizzle.uniqueSort = function( results ) { 
     4661        var elem, 
     4662        &n