zoukankan      html  css  js  c++  java

  • jquery1.3b1.js jquery 1.3版

    在jQuery小组一直在努力工作的新版本的jQuery图书馆和它准备一些深入的测试！ jQuery 1.3没有准备好用于生产，但我们需要帮助，剔除任何错误可能已经snuck通过。

    下载

    一份jQuery 1.3b1可以在这里找到：

         * http://code.jquery.com/jquery-1.3b1.js

    请不要使用minified或包装版本的jQuery时，测试-它使查找漏洞困难。
     


    The jQuery team has been working hard on the new release of the jQuery library and it’s ready for some in-depth testing! jQuery 1.3 is not ready for production use yet but we need help to weed out any bugs that might’ve snuck through.

    Download

    A copy of jQuery 1.3b1 can be found here:

    Please don’t use minified or packed versions of jQuery when testing - it makes locating bugs difficult.




    code:

    1. (function(){
    2. /*
    3.  * jQuery 1.3b1 - New Wave Javascript
    4.  *
    5.  * Copyright (c) 2008 John Resig (jquery.com)
    6.  * Dual licensed under the MIT (MIT-LICENSE.txt)
    7.  * and GPL (GPL-LICENSE.txt) licenses.
    8.  *
    9.  * $Date: 2008-12-22 12:31:22 -0500 (Mon, 22 Dec 2008) $
    10.  * $Rev: 5993 $
    11.  */
    13. // Map over jQuery in case of overwrite
    14. var _jQuery = window.jQuery,
    15. // Map over the $ in case of overwrite
    16.     _$ = window.$;
    18. var jQuery = window.jQuery = window.$ = function( selector, context ) {
    19.     // The jQuery object is actually just the init constructor 'enhanced'
    20.     return new jQuery.fn.init( selector, context );
    21. };
    23. // A simple way to check for HTML strings or ID strings
    24. // (both of which we optimize for)
    25. var quickExpr = /^[^<]*(<(.|/s)+>)[^>]*$|^#([/w-]+)$/,
    27. // Is it a simple selector
    28.     isSimple = /^.[^:#/[/.]*$/,
    30. // Will speed up references to undefined, and allows munging its name.
    31.     undefined;
    33. jQuery.fn = jQuery.prototype = {
    34.     init: function( selector, context ) {
    35.         // Make sure that a selection was provided
    36.         selector = selector || document;
    38.         // Handle $(DOMElement)
    39.         if ( selector.nodeType ) {
    40.             this[0] = selector;
    41.             this.length = 1;
    42.             this.context = selector;
    43.             return this;
    44.         }
    45.         // Handle HTML strings
    46.         if ( typeof selector === "string" ) {
    47.             // Are we dealing with HTML string or an ID?
    48.             var match = quickExpr.exec( selector );
    50.             // Verify a match, and that no context was specified for #id
    51.             if ( match && (match[1] || !context) ) {
    53.                 // HANDLE: $(html) -> $(array)
    54.                 if ( match[1] )
    55.                     selector = jQuery.clean( [ match[1] ], context );
    57.                 // HANDLE: $("#id")
    58.                 else {
    59.                     var elem = document.getElementById( match[3] );
    61.                     // Make sure an element was located
    62.                     if ( elem ){
    63.                         // Handle the case where IE and Opera return items
    64.                         // by name instead of ID
    65.                         if ( elem.id != match[3] )
    66.                             return jQuery().find( selector );
    68.                         // Otherwise, we inject the element directly into the jQuery object
    69.                         var ret = jQuery( elem );
    70.                         ret.context = document;
    71.                         ret.selector = selector;
    72.                         return ret;
    73.                     }
    74.                     selector = [];
    75.                 }
    77.             // HANDLE: $(expr, [context])
    78.             // (which is just equivalent to: $(content).find(expr)
    79.             } else
    80.                 return jQuery( context ).find( selector );
    82.         // HANDLE: $(function)
    83.         // Shortcut for document ready
    84.         } else if ( jQuery.isFunction( selector ) )
    85.             return jQuery( document )[ jQuery.fn.ready ? "ready" : "load" ]( selector );
    87.         return this.setArray(jQuery.makeArray(selector));
    88.     },
    90.     // Start with an empty selector
    91.     selector: "",
    93.     // The current version of jQuery being used
    94.     jquery: "1.3b1",
    96.     // The number of elements contained in the matched element set
    97.     size: function() {
    98.         return this.length;
    99.     },
    101.     // Get the Nth element in the matched element set OR
    102.     // Get the whole matched element set as a clean array
    103.     get: function( num ) {
    104.         return num === undefined ?
    106.             // Return a 'clean' array
    107.             jQuery.makeArray( this ) :
    109.             // Return just the object
    110.             this[ num ];
    111.     },
    113.     // Take an array of elements and push it onto the stack
    114.     // (returning the new matched element set)
    115.     pushStack: function( elems, name, selector ) {
    116.         // Build a new jQuery matched element set
    117.         var ret = jQuery( elems );
    119.         // Add the old object onto the stack (as a reference)
    120.         ret.prevObject = this;
    122.         ret.context = this.context;
    124.         if ( name === "find" )
    125.             ret.selector = this.selector + (this.selector ? " " : "") + selector;
    126.         else if ( name )
    127.             ret.selector = this.selector + "." + name + "(" + selector + ")";
    129.         // Return the newly-formed element set
    130.         return ret;
    131.     },
    133.     // Force the current matched set of elements to become
    134.     // the specified array of elements (destroying the stack in the process)
    135.     // You should use pushStack() in order to do this, but maintain the stack
    136.     setArray: function( elems ) {
    137.         // Resetting the length to 0, then using the native Array push
    138.         // is a super-fast way to populate an object with array-like properties
    139.         this.length = 0;
    140.         Array.prototype.push.apply( this, elems );
    142.         return this;
    143.     },
    145.     // Execute a callback for every element in the matched set.
    146.     // (You can seed the arguments with an array of args, but this is
    147.     // only used internally.)
    148.     each: function( callback, args ) {
    149.         return jQuery.each( this, callback, args );
    150.     },
    152.     // Determine the position of an element within
    153.     // the matched set of elements
    154.     index: function( elem ) {
    155.         var ret = -1;
    157.         // Locate the position of the desired element
    158.         return jQuery.inArray(
    159.             // If it receives a jQuery object, the first element is used
    160.             elem && elem.jquery ? elem[0] : elem
    161.         , this );
    162.     },
    164.     attr: function( name, value, type ) {
    165.         var options = name;
    167.         // Look for the case where we're accessing a style value
    168.         if ( typeof name === "string" )
    169.             if ( value === undefined )
    170.                 return this[0] && jQuery[ type || "attr" ]( this[0], name );
    172.             else {
    173.                 options = {};
    174.                 options[ name ] = value;
    175.             }
    177.         // Check to see if we're setting style values
    178.         return this.each(function(i){
    179.             // Set all the styles
    180.             for ( name in options )
    181.                 jQuery.attr(
    182.                     type ?
    183.                         this.style :
    184.                         this,
    185.                     name, jQuery.prop( this, options[ name ], type, i, name )
    186.                 );
    187.         });
    188.     },
    190.     css: function( key, value ) {
    191.         // ignore negative width and height values
    192.         if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
    193.             value = undefined;
    194.         return this.attr( key, value, "curCSS" );
    195.     },
    197.     text: function( text ) {
    198.         if ( typeof text !== "object" && text != null )
    199.             return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
    201.         var ret = "";
    203.         jQuery.each( text || this, function(){
    204.             jQuery.each( this.childNodes, function(){
    205.                 if ( this.nodeType != 8 )
    206.                     ret += this.nodeType != 1 ?
    207.                         this.nodeValue :
    208.                         jQuery.fn.text( [ this ] );
    209.             });
    210.         });
    212.         return ret;
    213.     },
    215.     wrapAll: function( html ) {
    216.         if ( this[0] )
    217.             // The elements to wrap the target around
    218.             jQuery( html, this[0].ownerDocument )
    219.                 .clone()
    220.                 .insertBefore( this[0] )
    221.                 .map(function(){
    222.                     var elem = this;
    224.                     while ( elem.firstChild )
    225.                         elem = elem.firstChild;
    227.                     return elem;
    228.                 })
    229.                 .append(this);
    231.         return this;
    232.     },
    234.     wrapInner: function( html ) {
    235.         return this.each(function(){
    236.             jQuery( this ).contents().wrapAll( html );
    237.         });
    238.     },
    240.     wrap: function( html ) {
    241.         return this.each(function(){
    242.             jQuery( this ).wrapAll( html );
    243.         });
    244.     },
    246.     append: function() {
    247.         return this.domManip(arguments, true, function(elem){
    248.             if (this.nodeType == 1)
    249.                 this.appendChild( elem );
    250.         });
    251.     },
    253.     prepend: function() {
    254.         return this.domManip(arguments, true, function(elem){
    255.             if (this.nodeType == 1)
    256.                 this.insertBefore( elem, this.firstChild );
    257.         });
    258.     },
    260.     before: function() {
    261.         return this.domManip(arguments, false, function(elem){
    262.             this.parentNode.insertBefore( elem, this );
    263.         });
    264.     },
    266.     after: function() {
    267.         return this.domManip(arguments, false, function(elem){
    268.             this.parentNode.insertBefore( elem, this.nextSibling );
    269.         });
    270.     },
    272.     end: function() {
    273.         return this.prevObject || jQuery( [] );
    274.     },
    276.     find: function( selector ) {
    277.         var elems = jQuery.map(this, function(elem){
    278.             return jQuery.find( selector, elem );
    279.         });
    281.         return this.pushStack( /[^+>] [^+>]/.test( selector ) ?
    282.             jQuery.unique( elems ) :
    283.             elems, "find", selector );
    284.     },
    286.     clone: function( events ) {
    287.         // Do the clone
    288.         var ret = this.map(function(){
    289.             if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {
    290.                 // IE copies events bound via attachEvent when
    291.                 // using cloneNode. Calling detachEvent on the
    292.                 // clone will also remove the events from the orignal
    293.                 // In order to get around this, we use innerHTML.
    294.                 // Unfortunately, this means some modifications to
    295.                 // attributes in IE that are actually only stored
    296.                 // as properties will not be copied (such as the
    297.                 // the name attribute on an input).
    298.                 var clone = this.cloneNode(true),
    299.                     container = document.createElement("div");
    300.                 container.appendChild(clone);
    301.                 return jQuery.clean([container.innerHTML])[0];
    302.             } else
    303.                 return this.cloneNode(true);
    304.         });
    306.         // Need to set the expando to null on the cloned set if it exists
    307.         // removeData doesn't work here, IE removes it from the original as well
    308.         // this is primarily for IE but the data expando shouldn't be copied over in any browser
    309.         var clone = ret.find("*").andSelf().each(function(){
    310.             if ( this[ expando ] !== undefined )
    311.                 this[ expando ] = null;
    312.         });
    314.         // Copy the events from the original to the clone
    315.         if ( events === true )
    316.             this.find("*").andSelf().each(function(i){
    317.                 if (this.nodeType == 3)
    318.                     return;
    319.                 var events = jQuery.data( this, "events" );
    321.                 for ( var type in events )
    322.                     for ( var handler in events[ type ] )
    323.                         jQuery.event.add( clone[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );
    324.             });
    326.         // Return the cloned set
    327.         return ret;
    328.     },
    330.     filter: function( selector ) {
    331.         return this.pushStack(
    332.             jQuery.isFunction( selector ) &&
    333.             jQuery.grep(this, function(elem, i){
    334.                 return selector.call( elem, i );
    335.             }) ||
    337.             jQuery.multiFilter( selector, jQuery.grep(this, function(elem){
    338.                 return elem.nodeType === 1;
    339.             }) ), "filter", selector );
    340.     },
    342.     closest: function( selector ) {
    343.         return this.map(function(){
    344.             var cur = this;
    345.             while ( cur && cur.ownerDocument ) {
    346.                 if ( jQuery(cur).is(selector) )
    347.                     return cur;
    348.                 cur = cur.parentNode;
    349.             }
    350.         });
    351.     },
    353.     not: function( selector ) {
    354.         if ( typeof selector === "string" )
    355.             // test special case where just one selector is passed in
    356.             if ( isSimple.test( selector ) )
    357.                 return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector );
    358.             else
    359.                 selector = jQuery.multiFilter( selector, this );
    361.         var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
    362.         return this.filter(function() {
    363.             return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
    364.         });
    365.     },
    367.     add: function( selector ) {
    368.         return this.pushStack( jQuery.unique( jQuery.merge(
    369.             this.get(),
    370.             typeof selector === "string" ?
    371.                 jQuery( selector ) :
    372.                 jQuery.makeArray( selector )
    373.         )));
    374.     },
    376.     is: function( selector ) {
    377.         return !!selector && jQuery.multiFilter( selector, this ).length > 0;
    378.     },
    380.     hasClass: function( selector ) {
    381.         return !!selector && this.is( "." + selector );
    382.     },
    384.     val: function( value ) {
    385.         if ( value === undefined ) {            
    386.             var elem = this[0];
    388.             if ( elem ) {
    389.                 if( jQuery.nodeName( elem, 'option' ) )
    390.                     return (elem.attributes.value || {}).specified ? elem.value : elem.text;
    391.                 
    392.                 // We need to handle select boxes special
    393.                 if ( jQuery.nodeName( elem, "select" ) ) {
    394.                     var index = elem.selectedIndex,
    395.                         values = [],
    396.                         options = elem.options,
    397.                         one = elem.type == "select-one";
    399.                     // Nothing was selected
    400.                     if ( index < 0 )
    401.                         return null;
    403.                     // Loop through all the selected options
    404.                     for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
    405.                         var option = options[ i ];
    407.                         if ( option.selected ) {
    408.                             // Get the specifc value for the option
    409.                             value = jQuery(option).val();
    411.                             // We don't need an array for one selects
    412.                             if ( one )
    413.                                 return value;
    415.                             // Multi-Selects return an array
    416.                             values.push( value );
    417.                         }
    418.                     }
    420.                     return values;              
    421.                 }
    423.                 // Everything else, we just grab the value
    424.                 return (elem.value || "").replace(//r/g, "");
    426.             }
    428.             return undefined;
    429.         }
    431.         if ( typeof value === "number" )
    432.             value += '';
    434.         return this.each(function(){
    435.             if ( this.nodeType != 1 )
    436.                 return;
    438.             if ( jQuery.isArray(value) && /radio|checkbox/.test( this.type ) )
    439.                 this.checked = (jQuery.inArray(this.value, value) >= 0 ||
    440.                     jQuery.inArray(this.name, value) >= 0);
    442.             else if ( jQuery.nodeName( this, "select" ) ) {
    443.                 var values = jQuery.makeArray(value);
    445.                 jQuery( "option", this ).each(function(){
    446.                     this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
    447.                         jQuery.inArray( this.text, values ) >= 0);
    448.                 });
    450.                 if ( !values.length )
    451.                     this.selectedIndex = -1;
    453.             } else
    454.                 this.value = value;
    455.         });
    456.     },
    458.     html: function( value ) {
    459.         return value === undefined ?
    460.             (this[0] ?
    461.                 this[0].innerHTML :
    462.                 null) :
    463.             this.empty().append( value );
    464.     },
    466.     replaceWith: function( value ) {
    467.         return this.after( value ).remove();
    468.     },
    470.     eq: function( i ) {
    471.         return this.slice( i, +i + 1 );
    472.     },
    474.     slice: function() {
    475.         return this.pushStack( Array.prototype.slice.apply( this, arguments ),
    476.             "slice", Array.prototype.slice.call(arguments).join(",") );
    477.     },
    479.     map: function( callback ) {
    480.         return this.pushStack( jQuery.map(this, function(elem, i){
    481.             return callback.call( elem, i, elem );
    482.         }));
    483.     },
    485.     andSelf: function() {
    486.         return this.add( this.prevObject );
    487.     },
    489.     data: function( key, value ){
    490.         var parts = key.split(".");
    491.         parts[1] = parts[1] ? "." + parts[1] : "";
    493.         if ( value === undefined ) {
    494.             var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
    496.             if ( data === undefined && this.length )
    497.                 data = jQuery.data( this[0], key );
    499.             return data == null && parts[1] ?
    500.                 this.data( parts[0] ) :
    501.                 data;
    502.         } else
    503.             return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){
    504.                 jQuery.data( this, key, value );
    505.             });
    506.     },
    508.     removeData: function( key ){
    509.         return this.each(function(){
    510.             jQuery.removeData( this, key );
    511.         });
    512.     },
    514.     domManip: function( args, table, callback ) {
    515.         if ( this[0] ) {
    516.             var fragment = this[0].ownerDocument.createDocumentFragment(),
    517.                 scripts = jQuery.clean( args, this[0].ownerDocument, fragment ),
    518.                 first = fragment.firstChild,
    519.                 extra = this.length > 1 ? fragment.cloneNode(true) : fragment;
    520.             
    521.             if ( first )
    522.                 for ( var i = 0, l = this.length; i < l; i++ )
    523.                     callback.call( root(this[i], first), i > 0 ? extra.cloneNode(true) : fragment );
    524.             
    525.             if ( scripts )
    526.                 jQuery.each( scripts, evalScript );
    527.         }
    529.         return this;
    530.         
    531.         function root( elem, cur ) {
    532.             return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ?
    533.                 (elem.getElementsByTagName("tbody")[0] ||
    534.                 elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
    535.                 elem;
    536.         }
    537.     }
    538. };
    540. // Give the init function the jQuery prototype for later instantiation
    541. jQuery.fn.init.prototype = jQuery.fn;
    543. function evalScript( i, elem ) {
    544.     if ( elem.src )
    545.         jQuery.ajax({
    546.             url: elem.src,
    547.             async: false,
    548.             dataType: "script"
    549.         });
    551.     else
    552.         jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
    554.     if ( elem.parentNode )
    555.         elem.parentNode.removeChild( elem );
    556. }
    558. function now(){
    559.     return +new Date;
    560. }
    562. jQuery.extend = jQuery.fn.extend = function() {
    563.     // copy reference to target object
    564.     var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;
    566.     // Handle a deep copy situation
    567.     if ( typeof target === "boolean" ) {
    568.         deep = target;
    569.         target = arguments[1] || {};
    570.         // skip the boolean and the target
    571.         i = 2;
    572.     }
    574.     // Handle case when target is a string or something (possible in deep copy)
    575.     if ( typeof target !== "object" && !jQuery.isFunction(target) )
    576.         target = {};
    578.     // extend jQuery itself if only one argument is passed
    579.     if ( length == i ) {
    580.         target = this;
    581.         --i;
    582.     }
    584.     for ( ; i < length; i++ )
    585.         // Only deal with non-null/undefined values
    586.         if ( (options = arguments[ i ]) != null )
    587.             // Extend the base object
    588.             for ( var name in options ) {
    589.                 var src = target[ name ], copy = options[ name ];
    591.                 // Prevent never-ending loop
    592.                 if ( target === copy )
    593.                     continue;
    595.                 // Recurse if we're merging object values
    596.                 if ( deep && copy && typeof copy === "object" && !copy.nodeType )
    597.                     target[ name ] = jQuery.extend( deep, 
    598.                         // Never move original objects, clone them
    599.                         src || ( copy.length != null ? [ ] : { } )
    600.                     , copy );
    602.                 // Don't bring in undefined values
    603.                 else if ( copy !== undefined )
    604.                     target[ name ] = copy;
    606.             }
    608.     // Return the modified object
    609.     return target;
    610. };
    612. var expando = "jQuery" + now(), uuid = 0, windowData = {},
    613.     // exclude the following css properties to add px
    614.     exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
    615.     // cache defaultView
    616.     defaultView = document.defaultView || {},
    617.     toString = Object.prototype.toString;
    619. jQuery.extend({
    620.     noConflict: function( deep ) {
    621.         window.$ = _$;
    623.         if ( deep )
    624.             window.jQuery = _jQuery;
    626.         return jQuery;
    627.     },
    629.     // See test/unit/core.js for details concerning isFunction.
    630.     // Since version 1.3, DOM methods and functions like alert
    631.     // aren't supported. They return false on IE (#2968).
    632.     isFunction: function( obj ) {
    633.         return toString.call(obj) === "[object Function]";
    634.     },
    636.     isArray: function( obj ) {
    637.         return toString.call(obj) === "[object Array]";
    638.     },
    640.     // check if an element is in a (or is an) XML document
    641.     isXMLDoc: function( elem ) {
    642.         return elem.documentElement && !elem.body ||
    643.             elem.tagName && elem.ownerDocument && !elem.ownerDocument.body;
    644.     },
    646.     // Evalulates a script in a global context
    647.     globalEval: function( data ) {
    648.         data = jQuery.trim( data );
    650.         if ( data ) {
    651.             // Inspired by code by Andrea Giammarchi
    652.             // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
    653.             var head = document.getElementsByTagName("head")[0] || document.documentElement,
    654.                 script = document.createElement("script");
    656.             script.type = "text/javascript";
    657.             if ( jQuery.support.scriptEval )
    658.                 script.appendChild( document.createTextNode( data ) );
    659.             else
    660.                 script.text = data;
    662.             // Use insertBefore instead of appendChild  to circumvent an IE6 bug.
    663.             // This arises when a base node is used (#2709).
    664.             head.insertBefore( script, head.firstChild );
    665.             head.removeChild( script );
    666.         }
    667.     },
    669.     nodeName: function( elem, name ) {
    670.         return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
    671.     },
    673.     cache: {},
    675.     data: function( elem, name, data ) {
    676.         elem = elem == window ?
    677.             windowData :
    678.             elem;
    680.         var id = elem[ expando ];
    682.         // Compute a unique ID for the element
    683.         if ( !id )
    684.             id = elem[ expando ] = ++uuid;
    686.         // Only generate the data cache if we're
    687.         // trying to access or manipulate it
    688.         if ( name && !jQuery.cache[ id ] )
    689.             jQuery.cache[ id ] = {};
    691.         // Prevent overriding the named cache with undefined values
    692.         if ( data !== undefined )
    693.             jQuery.cache[ id ][ name ] = data;
    695.         // Return the named cache data, or the ID for the element
    696.         return name ?
    697.             jQuery.cache[ id ][ name ] || null :
    698.             id;
    699.     },
    701.     removeData: function( elem, name ) {
    702.         elem = elem == window ?
    703.             windowData :
    704.             elem;
    706.         var id = elem[ expando ];
    708.         // If we want to remove a specific section of the element's data
    709.         if ( name ) {
    710.             if ( jQuery.cache[ id ] ) {
    711.                 // Remove the section of cache data
    712.                 delete jQuery.cache[ id ][ name ];
    714.                 // If we've removed all the data, remove the element's cache
    715.                 name = "";
    717.                 for ( name in jQuery.cache[ id ] )
    718.                     break;
    720.                 if ( !name )
    721.                     jQuery.removeData( elem );
    722.             }
    724.         // Otherwise, we want to remove all of the element's data
    725.         } else {
    726.             // Clean up the element expando
    727.             try {
    728.                 delete elem[ expando ];
    729.             } catch(e){
    730.                 // IE has trouble directly removing the expando
    731.                 // but it's ok with using removeAttribute
    732.                 if ( elem.removeAttribute )
    733.                     elem.removeAttribute( expando );
    734.             }
    736.             // Completely remove the data cache
    737.             delete jQuery.cache[ id ];
    738.         }
    739.     },
    741.     // args is for internal usage only
    742.     each: function( object, callback, args ) {
    743.         var name, i = 0, length = object.length;
    745.         if ( args ) {
    746.             if ( length === undefined ) {
    747.                 for ( name in object )
    748.                     if ( callback.apply( object[ name ], args ) === false )
    749.                         break;
    750.             } else
    751.                 for ( ; i < length; )
    752.                     if ( callback.apply( object[ i++ ], args ) === false )
    753.                         break;
    755.         // A special, fast, case for the most common use of each
    756.         } else {
    757.             if ( length === undefined ) {
    758.                 for ( name in object )
    759.                     if ( callback.call( object[ name ], name, object[ name ] ) === false )
    760.                         break;
    761.             } else
    762.                 for ( var value = object[0];
    763.                     i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
    764.         }
    766.         return object;
    767.     },
    769.     prop: function( elem, value, type, i, name ) {
    770.         // Handle executable functions
    771.         if ( jQuery.isFunction( value ) )
    772.             value = value.call( elem, i );
    774.         // Handle passing in a number to a CSS property
    775.         return typeof value === "number" && type == "curCSS" && !exclude.test( name ) ?
    776.             value + "px" :
    777.             value;
    778.     },
    780.     className: {
    781.         // internal only, use addClass("class")
    782.         add: function( elem, classNames ) {
    783.             jQuery.each((classNames || "").split(//s+/), function(i, className){
    784.                 if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
    785.                     elem.className += (elem.className ? " " : "") + className;
    786.             });
    787.         },
    789.         // internal only, use removeClass("class")
    790.         remove: function( elem, classNames ) {
    791.             if (elem.nodeType == 1)
    792.                 elem.className = classNames !== undefined ?
    793.                     jQuery.grep(elem.className.split(//s+/), function(className){
    794.                         return !jQuery.className.has( classNames, className );
    795.                     }).join(" ") :
    796.                     "";
    797.         },
    799.         // internal only, use hasClass("class")
    800.         has: function( elem, className ) {
    801.             return jQuery.inArray( className, (elem.className || elem).toString().split(//s+/) ) > -1;
    802.         }
    803.     },
    805.     // A method for quickly swapping in/out CSS properties to get correct calculations
    806.     swap: function( elem, options, callback ) {
    807.         var old = {};
    808.         // Remember the old values, and insert the new ones
    809.         for ( var name in options ) {
    810.             old[ name ] = elem.style[ name ];
    811.             elem.style[ name ] = options[ name ];
    812.         }
    814.         callback.call( elem );
    816.         // Revert the old values
    817.         for ( var name in options )
    818.             elem.style[ name ] = old[ name ];
    819.     },
    821.     css: function( elem, name, force ) {
    822.         if ( name == "width" || name == "height" ) {
    823.             var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
    825.             function getWH() {
    826.                 val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
    827.                 var padding = 0, border = 0;
    828.                 jQuery.each( which, function() {
    829.                     padding += parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
    830.                     border += parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
    831.                 });
    832.                 val -= Math.round(padding + border);
    833.             }
    835.             if ( jQuery(elem).is(":visible") )
    836.                 getWH();
    837.             else
    838.                 jQuery.swap( elem, props, getWH );
    840.             return Math.max(0, val);
    841.         }
    843.         return jQuery.curCSS( elem, name, force );
    844.     },
    846.     curCSS: function( elem, name, force ) {
    847.         var ret, style = elem.style;
    849.         // We need to handle opacity special in IE
    850.         if ( name == "opacity" && !jQuery.support.opacity ) {
    851.             ret = jQuery.attr( style, "opacity" );
    853.             return ret == "" ?
    854.                 "1" :
    855.                 ret;
    856.         }
    858.         // Make sure we're using the right name for getting the float value
    859.         if ( name.match( /float/i ) )
    860.             name = styleFloat;
    862.         if ( !force && style && style[ name ] )
    863.             ret = style[ name ];
    865.         else if ( defaultView.getComputedStyle ) {
    867.             // Only "float" is needed here
    868.             if ( name.match( /float/i ) )
    869.                 name = "float";
    871.             name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();
    873.             var computedStyle = defaultView.getComputedStyle( elem, null );
    875.             if ( computedStyle )
    876.                 ret = computedStyle.getPropertyValue( name );
    878.             // We should always get a number back from opacity
    879.             if ( name == "opacity" && ret == "" )
    880.                 ret = "1";
    882.         } else if ( elem.currentStyle ) {
    883.             var camelCase = name.replace(//-(/w)/g, function(all, letter){
    884.                 return letter.toUpperCase();
    885.             });
    887.             ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];
    889.             // From the awesome hack by Dean Edwards
    890.             // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
    892.             // If we're not dealing with a regular pixel number
    893.             // but a number that has a weird ending, we need to convert it to pixels
    894.             if ( !/^/d+(px)?$/i.test( ret ) && /^/d/.test( ret ) ) {
    895.                 // Remember the original values
    896.                 var left = style.left, rsLeft = elem.runtimeStyle.left;
    898.                 // Put in the new values to get a computed value out
    899.                 elem.runtimeStyle.left = elem.currentStyle.left;
    900.                 style.left = ret || 0;
    901.                 ret = style.pixelLeft + "px";
    903.                 // Revert the changed values
    904.                 style.left = left;
    905.                 elem.runtimeStyle.left = rsLeft;
    906.             }
    907.         }
    909.         return ret;
    910.     },
    912.     clean: function( elems, context, fragment ) {
    913.         var ret = [], scripts = [];
    914.         context = context || document;
    916.         // !context.createElement fails in IE with an error but returns typeof 'object'
    917.         if ( typeof context.createElement === "undefined" )
    918.             context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
    920.         jQuery.each(elems, function(i, elem){
    921.             if ( typeof elem === "number" )
    922.                 elem += '';
    924.             if ( !elem )
    925.                 return;
    927.             // Convert html string into DOM nodes
    928.             if ( typeof elem === "string" ) {
    929.                 // Fix "XHTML"-style tags in all browsers
    930.                 elem = elem.replace(/(<(/w+)[^>]*?)//>/g, function(all, front, tag){
    931.                     return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
    932.                         all :
    933.                         front + "></" + tag + ">";
    934.                 });
    936.                 // Trim whitespace, otherwise indexOf won't work as expected
    937.                 var tags = jQuery.trim( elem ).toLowerCase(), div = context.createElement("div");
    939.                 var wrap =
    940.                     // option or optgroup
    941.                     !tags.indexOf("<opt") &&
    942.                     [ 1, "<select multiple='multiple'>", "</select>" ] ||
    944.                     !tags.indexOf("<leg") &&
    945.                     [ 1, "<fieldset>", "</fieldset>" ] ||
    947.                     tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
    948.                     [ 1, "<table>", "</table>" ] ||
    950.                     !tags.indexOf("<tr") &&
    951.                     [ 2, "<table><tbody>", "</tbody></table>" ] ||
    953.                     // <thead> matched above
    954.                     (!tags.indexOf("<td") || !tags.indexOf("<th")) &&
    955.                     [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] ||
    957.                     !tags.indexOf("<col") &&
    958.                     [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] ||
    960.                     // IE can't serialize <link> and <script> tags normally
    961.                     !jQuery.support.htmlSerialize &&
    962.                     [ 1, "div<div>", "</div>" ] ||
    964.                     [ 0, "", "" ];
    966.                 // Go to html and back, then peel off extra wrappers
    967.                 div.innerHTML = wrap[1] + elem + wrap[2];
    969.                 // Move to the right depth
    970.                 while ( wrap[0]-- )
    971.                     div = div.lastChild;
    973.                 // Remove IE's autoinserted <tbody> from table fragments
    974.                 if ( !jQuery.support.tbody ) {
    976.                     // String was a <table>, *may* have spurious <tbody>
    977.                     var tbody = !tags.indexOf("<table") && tags.indexOf("<tbody") < 0 ?
    978.                         div.firstChild && div.firstChild.childNodes :
    980.                         // String was a bare <thead> or <tfoot>
    981.                         wrap[1] == "<table>" && tags.indexOf("<tbody") < 0 ?
    982.                             div.childNodes :
    983.                             [];
    985.                     for ( var j = tbody.length - 1; j >= 0 ; --j )
    986.                         if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
    987.                             tbody[ j ].parentNode.removeChild( tbody[ j ] );
    989.                     }
    991.                 // IE completely kills leading whitespace when innerHTML is used
    992.                 if ( !jQuery.support.leadingWhitespace && /^/s/.test( elem ) )
    993.                     div.insertBefore( context.createTextNode( elem.match(/^/s*/)[0] ), div.firstChild );
    994.                 
    995.                 if ( fragment ) {
    996.                     var found = div.getElementsByTagName("script");
    997.             
    998.                     while ( found.length ) {
    999.                         scripts.push( found[0] );
    1000.                         found[0].parentNode.removeChild( found[0] );
    1001.                     }
    1002.                 }
    1004.                 elem = jQuery.makeArray( div.childNodes );
    1005.             }
    1007.             if ( elem.nodeType )
    1008.                 ret.push( elem );
    1009.             else
    1010.                 ret = jQuery.merge( ret, elem );
    1012.         });
    1013.         
    1014.         if ( fragment ) {
    1015.             for ( var i = 0; ret[i]; i++ ) {
    1016.                 if ( jQuery.nodeName( ret[i], "script" ) ) {
    1017.                     ret[i].parentNode.removeChild( ret[i] );
    1018.                 } else {
    1019.                     if ( ret[i].nodeType === 1 )
    1020.                         ret = jQuery.merge( ret, ret[i].getElementsByTagName("script"));
    1021.                     fragment.appendChild( ret[i] );
    1022.                 }
    1023.             }
    1024.             
    1025.             return scripts;
    1026.         }
    1028.         return ret;
    1029.     },
    1031.     attr: function( elem, name, value ) {
    1032.         // don't set attributes on text and comment nodes
    1033.         if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
    1034.             return undefined;
    1036.         var notxml = !jQuery.isXMLDoc( elem ),
    1037.             // Whether we are setting (or getting)
    1038.             set = value !== undefined;
    1040.         // Try to normalize/fix the name
    1041.         name = notxml && jQuery.props[ name ] || name;
    1043.         // Only do all the following if this is a node (faster for style)
    1044.         // IE elem.getAttribute passes even for style
    1045.         if ( elem.tagName ) {
    1047.             // These attributes require special treatment
    1048.             var special = /href|src|style/.test( name );
    1050.             // Safari mis-reports the default selected property of a hidden option
    1051.             // Accessing the parent's selectedIndex property fixes it
    1052.             if ( name == "selected" )
    1053.                 elem.parentNode.selectedIndex;
    1055.             // If applicable, access the attribute via the DOM 0 way
    1056.             if ( name in elem && notxml && !special ) {
    1057.                 if ( set ){
    1058.                     // We can't allow the type property to be changed (since it causes problems in IE)
    1059.                     if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )
    1060.                         throw "type property can't be changed";
    1062.                     elem[ name ] = value;
    1063.                 }
    1065.                 // browsers index elements by id/name on forms, give priority to attributes.
    1066.                 if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )
    1067.                     return elem.getAttributeNode( name ).nodeValue;
    1069.                 return elem[ name ];
    1070.             }
    1072.             if ( !jQuery.support.style && notxml &&  name == "style" )
    1073.                 return jQuery.attr( elem.style, "cssText", value );
    1075.             if ( set )
    1076.                 // convert the value to a string (all browsers do this but IE) see #1070
    1077.                 elem.setAttribute( name, "" + value );
    1079.             var attr = !jQuery.support.hrefNormalized && notxml && special
    1080.                     // Some attributes require a special call on IE
    1081.                     ? elem.getAttribute( name, 2 )
    1082.                     : elem.getAttribute( name );
    1084.             // Non-existent attributes return null, we normalize to undefined
    1085.             return attr === null ? undefined : attr;
    1086.         }
    1088.         // elem is actually elem.style ... set the style
    1090.         // IE uses filters for opacity
    1091.         if ( !jQuery.support.opacity && name == "opacity" ) {
    1092.             if ( set ) {
    1093.                 // IE has trouble with opacity if it does not have layout
    1094.                 // Force it by setting the zoom level
    1095.                 elem.zoom = 1;
    1097.                 // Set the alpha filter to set the opacity
    1098.                 elem.filter = (elem.filter || "").replace( /alpha/([^)]*/)/, "" ) +
    1099.                     (parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
    1100.             }
    1102.             return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
    1103.                 (parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '':
    1104.                 "";
    1105.         }
    1107.         name = name.replace(/-([a-z])/ig, function(all, letter){
    1108.             return letter.toUpperCase();
    1109.         });
    1111.         if ( set )
    1112.             elem[ name ] = value;
    1114.         return elem[ name ];
    1115.     },
    1117.     trim: function( text ) {
    1118.         return (text || "").replace( /^/s+|/s+$/g, "" );
    1119.     },
    1121.     makeArray: function( array ) {
    1122.         var ret = [];
    1124.         if( array != null ){
    1125.             var i = array.length;
    1126.             // The window, strings (and functions) also have 'length'
    1127.             if( i == null || typeof array === "string" || jQuery.isFunction(array) || array.setInterval )
    1128.                 ret[0] = array;
    1129.             else
    1130.                 while( i )
    1131.                     ret[--i] = array[i];
    1132.         }
    1134.         return ret;
    1135.     },
    1137.     inArray: function( elem, array ) {
    1138.         for ( var i = 0, length = array.length; i < length; i++ )
    1139.         // Use === because on IE, window == document
    1140.             if ( array[ i ] === elem )
    1141.                 return i;
    1143.         return -1;
    1144.     },
    1146.     merge: function( first, second ) {
    1147.         // We have to loop this way because IE & Opera overwrite the length
    1148.         // expando of getElementsByTagName
    1149.         var i = 0, elem, pos = first.length;
    1150.         // Also, we need to make sure that the correct elements are being returned
    1151.         // (IE returns comment nodes in a '*' query)
    1152.         if ( !jQuery.support.getAll ) {
    1153.             while ( (elem = second[ i++ ]) )
    1154.                 if ( elem.nodeType != 8 )
    1155.                     first[ pos++ ] = elem;
    1157.         } else
    1158.             while ( (elem = second[ i++ ]) )
    1159.                 first[ pos++ ] = elem;
    1161.         return first;
    1162.     },
    1164.     unique: function( array ) {
    1165.         var ret = [], done = {};
    1167.         try {
    1169.             for ( var i = 0, length = array.length; i < length; i++ ) {
    1170.                 var id = jQuery.data( array[ i ] );
    1172.                 if ( !done[ id ] ) {
    1173.                     done[ id ] = true;
    1174.                     ret.push( array[ i ] );
    1175.                 }
    1176.             }
    1178.         } catch( e ) {
    1179.             ret = array;
    1180.         }
    1182.         return ret;
    1183.     },
    1185.     grep: function( elems, callback, inv ) {
    1186.         var ret = [];
    1188.         // Go through the array, only saving the items
    1189.         // that pass the validator function
    1190.         for ( var i = 0, length = elems.length; i < length; i++ )
    1191.             if ( !inv != !callback( elems[ i ], i ) )
    1192.                 ret.push( elems[ i ] );
    1194.         return ret;
    1195.     },
    1197.     map: function( elems, callback ) {
    1198.         var ret = [];
    1200.         // Go through the array, translating each of the items to their
    1201.         // new value (or values).
    1202.         for ( var i = 0, length = elems.length; i < length; i++ ) {
    1203.             var value = callback( elems[ i ], i );
    1205.             if ( value != null )
    1206.                 ret[ ret.length ] = value;
    1207.         }
    1209.         return ret.concat.apply( [], ret );
    1210.     }
    1211. });
    1213. // Use of jQuery.browser is deprecated.
    1214. // It's included for backwards compatibility and plugins,
    1215. // although they should work to migrate away.
    1217. var userAgent = navigator.userAgent.toLowerCase();
    1219. // Figure out what browser is being used
    1220. jQuery.browser = {
    1221.     version: (userAgent.match( /.+(?:rv|it|ra|ie)[//: ]([/d.]+)/ ) || [0,'0'])[1],
    1222.     safari: /webkit/.test( userAgent ),
    1223.     opera: /opera/.test( userAgent ),
    1224.     msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
    1225.     mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
    1226. };
    1228. // Check to see if the W3C box model is being used
    1229. jQuery.boxModel = !jQuery.browser.msie || document.compatMode == "CSS1Compat";
    1231. jQuery.each({
    1232.     parent: function(elem){return elem.parentNode;},
    1233.     parents: function(elem){return jQuery.dir(elem,"parentNode");},
    1234.     next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
    1235.     prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
    1236.     nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
    1237.     prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
    1238.     siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
    1239.     children: function(elem){return jQuery.sibling(elem.firstChild);},
    1240.     contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
    1241. }, function(name, fn){
    1242.     jQuery.fn[ name ] = function( selector ) {
    1243.         var ret = jQuery.map( this, fn );
    1245.         if ( selector && typeof selector == "string" )
    1246.             ret = jQuery.multiFilter( selector, ret );
    1248.         return this.pushStack( jQuery.unique( ret ), name, selector );
    1249.     };
    1250. });
    1252. jQuery.each({
    1253.     appendTo: "append",
    1254.     prependTo: "prepend",
    1255.     insertBefore: "before",
    1256.     insertAfter: "after",
    1257.     replaceAll: "replaceWith"
    1258. }, function(name, original){
    1259.     jQuery.fn[ name ] = function() {
    1260.         var args = arguments;
    1262.         return this.each(function(){
    1263.             for ( var i = 0, length = args.length; i < length; i++ )
    1264.                 jQuery( args[ i ] )[ original ]( this );
    1265.         });
    1266.     };
    1267. });
    1269. jQuery.each({
    1270.     removeAttr: function( name ) {
    1271.         jQuery.attr( this, name, "" );
    1272.         if (this.nodeType == 1)
    1273.             this.removeAttribute( name );
    1274.     },
    1276.     addClass: function( classNames ) {
    1277.         jQuery.className.add( this, classNames );
    1278.     },
    1280.     removeClass: function( classNames ) {
    1281.         jQuery.className.remove( this, classNames );
    1282.     },
    1284.     toggleClass: function( classNames ) {
    1285.         jQuery.className[ jQuery.className.has( this, classNames ) ? "remove" : "add" ]( this, classNames );
    1286.     },
    1288.     remove: function( selector ) {
    1289.         if ( !selector || jQuery.filter( selector, [ this ] ).length ) {
    1290.             // Prevent memory leaks
    1291.             jQuery( "*", this ).add([this]).each(function(){
    1292.                 jQuery.event.remove(this);
    1293.                 jQuery.removeData(this);
    1294.             });
    1295.             if (this.parentNode)
    1296.                 this.parentNode.removeChild( this );
    1297.         }
    1298.     },
    1300.     empty: function() {
    1301.         // Remove element nodes and prevent memory leaks
    1302.         jQuery( ">*", this ).remove();
    1304.         // Remove any remaining nodes
    1305.         while ( this.firstChild )
    1306.             this.removeChild( this.firstChild );
    1307.     }
    1308. }, function(name, fn){
    1309.     jQuery.fn[ name ] = function(){
    1310.         return this.each( fn, arguments );
    1311.     };
    1312. });
    1314. // Helper function used by the dimensions and offset modules
    1315. function num(elem, prop) {
    1316.     return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) || 0;
    1317. }
    1318. (function(){
    1320.     jQuery.support = {};
    1322.     var root = document.documentElement,
    1323.         script = document.createElement("script"),
    1324.         div = document.createElement("div"),
    1325.         id = "script" + (new Date).getTime();
    1327.     div.style.display = "none";
    1328.     div.innerHTML = '   <link/><table></table><a href="/a" style="color:red;float:left;opacity:.5;">a</a><select><option>text</option></select><object><param></object>';
    1330.     var all = div.getElementsByTagName("*"),
    1331.         a = div.getElementsByTagName("a")[0];
    1333.     // Can't get basic test support
    1334.     if ( !all || !all.length || !a ) {
    1335.         return;
    1336.     }
    1338.     jQuery.support = {
    1339.         // IE strips leading whitespace when .innerHTML is used
    1340.         leadingWhitespace: div.firstChild.nodeType == 3,
    1341.         
    1342.         // Make sure that tbody elements aren't automatically inserted
    1343.         // IE will insert them into empty tables
    1344.         tbody: !div.getElementsByTagName("tbody").length,
    1345.         
    1346.         // Make sure that you can get all elements in an <object> element
    1347.         // IE 7 always returns no results
    1348.         objectAll: !!div.getElementsByTagName("object")[0]
    1349.             .getElementsByTagName("*").length,
    1350.         
    1351.         // Make sure that link elements get serialized correctly by innerHTML
    1352.         // This requires a wrapper element in IE
    1353.         htmlSerialize: !!div.getElementsByTagName("link").length,
    1354.         
    1355.         // Get the style information from getAttribute
    1356.         // (IE uses .cssText insted)
    1357.         style: /red/.test( a.getAttribute("style") ),
    1358.         
    1359.         // Make sure that URLs aren't manipulated
    1360.         // (IE normalizes it by default)
    1361.         hrefNormalized: a.getAttribute("href") === "/a",
    1362.         
    1363.         // Make sure that element opacity exists
    1364.         // (IE uses filter instead)
    1365.         opacity: a.style.opacity === "0.5",
    1366.         
    1367.         // Verify style float existence
    1368.         // (IE uses styleFloat instead of cssFloat)
    1369.         cssFloat: !!a.style.cssFloat,
    1371.         // Will be defined later
    1372.         scriptEval: false,
    1373.         noCloneEvent: true
    1374.     };
    1375.     
    1376.     script.type = "text/javascript";
    1377.     try {
    1378.         script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
    1379.     } catch(e){}
    1381.     root.insertBefore( script, root.firstChild );
    1382.     
    1383.     // Make sure that the execution of code works by injecting a script
    1384.     // tag with appendChild/createTextNode
    1385.     // (IE doesn't support this, fails, and uses .text instead)
    1386.     if ( window[ id ] ) {
    1387.         jQuery.support.scriptEval = true;
    1388.         delete window[ id ];
    1389.     }
    1391.     root.removeChild( script );
    1393.     if ( div.attachEvent && div.fireEvent ) {
    1394.         div.attachEvent("onclick", function(){
    1395.             // Cloning a node shouldn't copy over any
    1396.             // bound event handlers (IE does this)
    1397.             jQuery.support.noCloneEvent = false;
    1398.         });
    1399.         div.cloneNode(true).fireEvent("onclick");
    1400.     }
    1402. })();
    1404. var styleFloat = jQuery.support.cssFloat ? "cssFloat" : "styleFloat";
    1406. jQuery.props = {
    1407.     "for": "htmlFor",
    1408.     "class": "className",
    1409.     "float": styleFloat,
    1410.     cssFloat: styleFloat,
    1411.     styleFloat: styleFloat,
    1412.     readonly: "readOnly",
    1413.     maxlength: "maxLength",
    1414.     cellspacing: "cellSpacing",
    1415.     rowspan: "rowSpan"
    1416. };/*
    1417.  * Sizzle CSS Selector Engine - v0.9
    1418.  *  Copyright 2009, John Resig (http://ejohn.org/)
    1419.  *  released under the MIT License
    1420.  */
    1421. (function(){
    1423. var chunker = /((?:/((?:/([^()]+/)|[^()]+)+/)|/[(?:/[[^[/]]+/]|[^[/]]+)+/]|//.|[^ >+~,(/[]+)+|[>+~])(/s*,/s*)?/g;
    1425. var done = 0;
    1427. var Sizzle = function(selector, context, results, seed) {
    1428.     var doCache = !results;
    1429.     results = results || [];
    1430.     context = context || document;
    1432.     if ( context.nodeType !== 1 && context.nodeType !== 9 )
    1433.         return [];
    1434.     
    1435.     if ( !selector || typeof selector !== "string" ) {
    1436.         return results;
    1437.     }
    1439.     var parts = [], m, set, checkSet, check, mode, extra;
    1440.     
    1441.     // Reset the position of the chunker regexp (start from head)
    1442.     chunker.lastIndex = 0;
    1443.     
    1444.     while ( (m = chunker.exec(selector)) !== null ) {
    1445.         parts.push( m[1] );
    1446.         
    1447.         if ( m[2] ) {
    1448.             extra = RegExp.rightContext;
    1449.             break;
    1450.         }
    1451.     }
    1453.     if ( parts.length > 1 && Expr.match.POS.exec( selector ) ) {
    1454.         if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
    1455.             var later = "", match;
    1457.             // Position selectors must be done after the filter
    1458.             while ( (match = Expr.match.POS.exec( selector )) ) {
    1459.                 later += match[0];
    1460.                 selector = selector.replace( Expr.match.POS, "" );
    1461.             }
    1463.             set = Sizzle.filter( later, Sizzle( selector, context ) );
    1464.         } else {
    1465.             set = Expr.relative[ parts[0] ] ?
    1466.                 [ context ] :
    1467.                 Sizzle( parts.shift(), context );
    1469.             while ( parts.length ) {
    1470.                 var tmpSet = [];
    1472.                 selector = parts.shift();
    1473.                 if ( Expr.relative[ selector ] )
    1474.                     selector += parts.shift();
    1476.                 for ( var i = 0, l = set.length; i < l; i++ ) {
    1477.                     Sizzle( selector, set[i], tmpSet );
    1478.                 }
    1480.                 set = tmpSet;
    1481.             }
    1482.         }
    1483.     } else {
    1484.         var ret = seed ?
    1485.             { expr: parts.pop(), set: makeArray(seed) } :
    1486.             Sizzle.find( parts.pop(), parts.length === 1 && context.parentNode ? context.parentNode : context );
    1487.         set = Sizzle.filter( ret.expr, ret.set );
    1489.         if ( parts.length > 0 ) {
    1490.             checkSet = makeArray(set);
    1491.         }
    1493.         while ( parts.length ) {
    1494.             var cur = parts.pop(), pop = cur;
    1496.             if ( !Expr.relative[ cur ] ) {
    1497.                 cur = "";
    1498.             } else {
    1499.                 pop = parts.pop();
    1500.             }
    1502.             if ( pop == null ) {
    1503.                 pop = context;
    1504.             }
    1506.             Expr.relative[ cur ]( checkSet, pop );
    1507.         }
    1508.     }
    1510.     if ( !checkSet ) {
    1511.         checkSet = set;
    1512.     }
    1514.     if ( !checkSet ) {
    1515.         throw "Syntax error, unrecognized expression: " + (cur || selector);
    1516.     }
    1518.     if ( checkSet instanceof Array ) {
    1519.         if ( context.nodeType === 1 ) {
    1520.             for ( var i = 0; checkSet[i] != null; i++ ) {
    1521.                 if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
    1522.                     results.push( set[i] );
    1523.                 }
    1524.             }
    1525.         } else {
    1526.             for ( var i = 0; checkSet[i] != null; i++ ) {
    1527.                 if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
    1528.                     results.push( set[i] );
    1529.                 }
    1530.             }
    1531.         }
    1532.     } else {
    1533.         makeArray( checkSet, results );
    1534.     }
    1536.     if ( extra ) {
    1537.         Sizzle( extra, context, results );
    1538.     }
    1540.     return results;
    1541. };
    1543. Sizzle.matches = function(expr, set){
    1544.     return Sizzle(expr, null, null, set);
    1545. };
    1547. Sizzle.find = function(expr, context){
    1548.     var set, match;
    1550.     if ( !expr ) {
    1551.         return [];
    1552.     }
    1554.     var later = "", match;
    1556.     // Pseudo-selectors could contain other selectors (like :not)
    1557.     while ( (match = Expr.match.PSEUDO.exec( expr )) ) {
    1558.         var left = RegExp.leftContext;
    1560.         if ( left.substr( left.length - 1 ) !== "//" ) {
    1561.             later += match[0];
    1562.             expr = expr.replace( Expr.match.PSEUDO, "" );
    1563.         } else {
    1564.             // TODO: Need a better solution, fails: .class/:foo:realfoo(#id)
    1565.             break;
    1566.         }
    1567.     }
    1569.     for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
    1570.         var type = Expr.order[i];
    1571.         
    1572.         if ( (match = Expr.match[ type ].exec( expr )) ) {
    1573.             var left = RegExp.leftContext;
    1575.             if ( left.substr( left.length - 1 ) !== "//" ) {
    1576.                 match[1] = (match[1] || "").replace(////g, "");
    1577.                 set = Expr.find[ type ]( match, context );
    1579.                 if ( set != null ) {
    1580.                     expr = expr.replace( Expr.match[ type ], "" );
    1581.                     break;
    1582.                 }
    1583.             }
    1584.         }
    1585.     }
    1587.     if ( !set ) {
    1588.         set = context.getElementsByTagName("*");
    1589.     }
    1591.     expr += later;
    1593.     return {set: set, expr: expr};
    1594. };
    1596. Sizzle.filter = function(expr, set, inplace){
    1597.     var old = expr, result = [], curLoop = set, match;
    1599.     while ( expr && set.length ) {
    1600.         for ( var type in Expr.filter ) {
    1601.             if ( (match = Expr.match[ type ].exec( expr )) != null ) {
    1602.                 var anyFound = false, filter = Expr.filter[ type ], goodArray = null;
    1604.                 if ( curLoop == result ) {
    1605.                     result = [];
    1606.                 }
    1608.                 if ( Expr.preFilter[ type ] ) {
    1609.                     match = Expr.preFilter[ type ]( match, curLoop );
    1611.                     if ( match[0] === true ) {
    1612.                         goodArray = [];
    1613.                         var last = null, elem;
    1614.                         for ( var i = 0; (elem = curLoop[i]) !== undefined; i++ ) {
    1615.                             if ( elem && last !== elem ) {
    1616.                                 goodArray.push( elem );
    1617.                                 last = elem;
    1618.                             }
    1619.                         }
    1620.                     }
    1622.                 }
    1624.                 var goodPos = 0, found, item;
    1626.                 for ( var i = 0; (item = curLoop[i]) !== undefined; i++ ) {
    1627.                     if ( item ) {
    1628.                         if ( goodArray && item != goodArray[goodPos] ) {
    1629.                             goodPos++;
    1630.                         }
    1632.                         found = filter( item, match, goodPos, goodArray );
    1633.                         if ( inplace && found != null ) {
    1634.                             curLoop[i] = found ? curLoop[i] : false;
    1635.                             if ( found ) {
    1636.                                 anyFound = true;
    1637.                             }
    1638.                         } else if ( found ) {
    1639.                             result.push( item );
    1640.                             anyFound = true;
    1641.                         }
    1642.                     }
    1643.                 }
    1645.                 if ( found !== undefined ) {
    1646.                     if ( !inplace ) {
    1647.                         curLoop = result;
    1648.                     }
    1650.                     expr = expr.replace( Expr.match[ type ], "" );
    1652.                     if ( !anyFound ) {
    1653.                         return [];
    1654.                     }
    1656.                     break;
    1657.                 }
    1658.             }
    1659.         }
    1662.         expr = expr.replace(//s*,/s*/, "");
    1664.         // Improper expression
    1665.         if ( expr == old ) {
    1666.             throw "Syntax error, unrecognized expression: " + expr;
    1667.         }
    1669.         old = expr;
    1670.     }
    1672.     return curLoop;
    1673. };
    1675. var Expr = Sizzle.selectors = {
    1676.     order: [ "ID", "NAME", "TAG" ],
    1677.     match: {
    1678.         ID: /#((?:[/w/u0128-/uFFFF_-]|//.)+)/,
    1679.         CLASS: //.((?:[/w/u0128-/uFFFF_-]|//.)+)/,
    1680.         NAME: //[name=((?:[/w/u0128-/uFFFF_-]|//.)+)/]/,
    1681.         ATTR: //[((?:[/w/u0128-/uFFFF_-]|//.)+)/s*(?:(/S{0,1}=)/s*(['"]*)(.*?)/3|)/]/,
    1682.         TAG: /^((?:[/w/u0128-/uFFFF/*_-]|//.)+)/,
    1683.         CHILD: /:(only|nth|last|first)-child/(?(even|odd|[/dn+-]*)/)?/,
    1684.         POS: /:(nth|eq|gt|lt|first|last|even|odd)/(?(/d*)/)?(?:[^-]|$)/,
    1685.         PSEUDO: /:((?:[/w/u0128-/uFFFF_-]|//.)+)(?:/((['"]*)((?:/([^/)]+/)|[^/2/(/)]*)+)/2/))?/
    1686.     },
    1687.     attrMap: {
    1688.         "class": "className"
    1689.     },
    1690.     relative: {
    1691.         "+": function(checkSet, part){
    1692.             for ( var i = 0, l = checkSet.length; i < l; i++ ) {
    1693.                 var elem = checkSet[i];
    1694.                 if ( elem ) {
    1695.                     var cur = elem.previousSibling;
    1696.                     while ( cur && cur.nodeType !== 1 ) {
    1697.                         cur = cur.previousSibling;
    1698.                     }
    1699.                     checkSet[i] = typeof part === "string" ?
    1700.                         cur || false :
    1701.                         cur === part;
    1702.                 }
    1703.             }
    1705.             if ( typeof part === "string" ) {
    1706.                 Sizzle.filter( part, checkSet, true );
    1707.             }
    1708.         },
    1709.         ">": function(checkSet, part){
    1710.             if ( typeof part === "string" && !//W/.test(part) ) {
    1711.                 part = part.toUpperCase();
    1713.                 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
    1714.                     var elem = checkSet[i];
    1715.                     if ( elem ) {
    1716.                         var parent = elem.parentNode;
    1717.                         checkSet[i] = parent.nodeName === part ? parent : false;
    1718.                     }
    1719.                 }
    1720.             } else {
    1721.                 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
    1722.                     var elem = checkSet[i];
    1723.                     if ( elem ) {
    1724.                         checkSet[i] = typeof part === "string" ?
    1725.                             elem.parentNode :
    1726.                             elem.parentNode === part;
    1727.                     }
    1728.                 }
    1730.                 if ( typeof part === "string" ) {
    1731.                     Sizzle.filter( part, checkSet, true );
    1732.                 }
    1733.             }
    1734.         },
    1735.         "": function(checkSet, part){
    1736.             var doneName = "done" + (done++), checkFn = dirCheck;
    1738.             if ( !part.match(//W/) ) {
    1739.                 var nodeCheck = part = part.toUpperCase();
    1740.                 checkFn = dirNodeCheck;
    1741.             }
    1743.             checkFn("parentNode", part, doneName, checkSet, nodeCheck);
    1744.         },
    1745.         "~": function(checkSet, part){
    1746.             var doneName = "done" + (done++), checkFn = dirCheck;
    1748.             if ( typeof part === "string" && !part.match(//W/) ) {
    1749.                 var nodeCheck = part = part.toUpperCase();
    1750.                 checkFn = dirNodeCheck;
    1751.             }
    1753.             checkFn("previousSibling", part, doneName, checkSet, nodeCheck);
    1754.         }
    1755.     },
    1756.     find: {
    1757.         ID: function(match, context){
    1758.             if ( context.getElementById ) {
    1759.                 var m = context.getElementById(match[1]);
    1760.                 return m ? [m] : [];
    1761.             }
    1762.         },
    1763.         NAME: function(match, context){
    1764.             return context.getElementsByName(match[1]);
    1765.         },
    1766.         TAG: function(match, context){
    1767.             return context.getElementsByTagName(match[1]);
    1768.         }
    1769.     },
    1770.     preFilter: {
    1771.         CLASS: function(match){
    1772.             return new RegExp( "(?:^|//s)" + match[1] + "(?://s|$)" );
    1773.         },
    1774.         ID: function(match){
    1775.             return match[1];
    1776.         },
    1777.         TAG: function(match){
    1778.             return match[1].toUpperCase();
    1779.         },
    1780.         CHILD: function(match){
    1781.             if ( match[1] == "nth" ) {
    1782.                 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
    1783.                 var test = /(-?)(/d*)n((?:/+|-)?/d*)/.exec(
    1784.                     match[2] == "even" && "2n" || match[2] == "odd" && "2n+1" ||
    1785.                     !//D/.test( match[2] ) && "0n+" + match[2] || match[2]);
    1787.                 // calculate the numbers (first)n+(last) including if they are negative
    1788.                 match[2] = (test[1] + (test[2] || 1)) - 0;
    1789.                 match[3] = test[3] - 0;
    1790.             }
    1792.             // TODO: Move to normal caching system
    1793.             match[0] = "done" + (done++);
    1795.             return match;
    1796.         },
    1797.         ATTR: function(match){
    1798.             var name = match[1];
    1799.             
    1800.             if ( Expr.attrMap[name] ) {
    1801.                 match[1] = Expr.attrMap[name];
    1802.             }
    1804.             if ( match[2] === "~=" ) {
    1805.                 match[4] = " " + match[4] + " ";
    1806.             }
    1808.             return match;
    1809.         },
    1810.         PSEUDO: function(match){
    1811.             if ( match[1] === "not" ) {
    1812.                 match[3] = match[3].split(//s*,/s*/);
    1813.             }
    1814.             
    1815.             return match;
    1816.         },
    1817.         POS: function(match){
    1818.             match.unshift( true );
    1819.             return match;
    1820.         }
    1821.     },
    1822.     filters: {
    1823.         enabled: function(elem){
    1824.             return elem.disabled === false && elem.type !== "hidden";
    1825.         },
    1826.         disabled: function(elem){
    1827.             return elem.disabled === true;
    1828.         },
    1829.         checked: function(elem){
    1830.             return elem.checked === true;
    1831.         },
    1832.         selected: function(elem){
    1833.             // Accessing this property makes selected-by-default
    1834.             // options in Safari work properly
    1835.             elem.parentNode.selectedIndex;
    1836.             return elem.selected === true;
    1837.         },
    1838.         parent: function(elem){
    1839.             return !!elem.firstChild;
    1840.         },
    1841.         empty: function(elem){
    1842.             return !elem.firstChild;
    1843.         },
    1844.         has: function(elem, i, match){
    1845.             return !!Sizzle( match[3], elem ).length;
    1846.         },
    1847.         header: function(elem){
    1848.             return /h/d/i.test( elem.nodeName );
    1849.         },
    1850.         text: function(elem){
    1851.             return "text" === elem.type;
    1852.         },
    1853.         radio: function(elem){
    1854.             return "radio" === elem.type;
    1855.         },
    1856.         checkbox: function(elem){
    1857.             return "checkbox" === elem.type;
    1858.         },
    1859.         file: function(elem){
    1860.             return "file" === elem.type;
    1861.         },
    1862.         password: function(elem){
    1863.             return "password" === elem.type;
    1864.         },
    1865.         submit: function(elem){
    1866.             return "submit" === elem.type;
    1867.         },
    1868.         image: function(elem){
    1869.             return "image" === elem.type;
    1870.         },
    1871.         reset: function(elem){
    1872.             return "reset" === elem.type;
    1873.         },
    1874.         button: function(elem){
    1875.             return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON";
    1876.         },
    1877.         input: function(elem){
    1878.             return /input|select|textarea|button/i.test(elem.nodeName);
    1879.         }
    1880.     },
    1881.     setFilters: {
    1882.         first: function(elem, i){
    1883.             return i === 0;
    1884.         },
    1885.         last: function(elem, i, match, array){
    1886.             return i === array.length - 1;
    1887.         },
    1888.         even: function(elem, i){
    1889.             return i % 2 === 0;
    1890.         },
    1891.         odd: function(elem, i){
    1892.             return i % 2 === 1;
    1893.         },
    1894.         lt: function(elem, i, match){
    1895.             return i < match[3] - 0;
    1896.         },
    1897.         gt: function(elem, i, match){
    1898.             return i > match[3] - 0;
    1899.         },
    1900.         nth: function(elem, i, match){
    1901.             return match[3] - 0 == i;
    1902.         },
    1903.         eq: function(elem, i, match){
    1904.             return match[3] - 0 == i;
    1905.         }
    1906.     },
    1907.     filter: {
    1908.         CHILD: function(elem, match){
    1909.             var type = match[1], parent = elem.parentNode;
    1911.             var doneName = match[0];
    1912.             
    1913.             if ( parent && !parent[ doneName ] ) {
    1914.                 var count = 1;
    1916.                 for ( var node = parent.firstChild; node; node = node.nextSibling ) {
    1917.                     if ( node.nodeType == 1 ) {
    1918.                         node.nodeIndex = count++;
    1919.                     }
    1920.                 }
    1922.                 parent[ doneName ] = count - 1;
    1923.             }
    1925.             if ( type == "first" ) {
    1926.                 return elem.nodeIndex == 1;
    1927.             } else if ( type == "last" ) {
    1928.                 return elem.nodeIndex == parent[ doneName ];
    1929.             } else if ( type == "only" ) {
    1930.                 return parent[ doneName ] == 1;
    1931.             } else if ( type == "nth" ) {
    1932.                 var add = false, first = match[2], last = match[3];
    1934.                 if ( first == 1 && last == 0 ) {
    1935.                     return true;
    1936.                 }
    1938.                 if ( first == 0 ) {
    1939.                     if ( elem.nodeIndex == last ) {
    1940.                         add = true;
    1941.                     }
    1942.                 } else if ( (elem.nodeIndex - last) % first == 0 && (elem.nodeIndex - last) / first >= 0 ) {
    1943.                     add = true;
    1944.                 }
    1946.                 return add;
    1947.             }
    1948.         },
    1949.         PSEUDO: function(elem, match, i, array){
    1950.             var name = match[1], filter = Expr.filters[ name ];
    1952.             if ( filter ) {
    1953.                 return filter( elem, i, match, array )
    1954.             } else if ( name === "contains" ) {
    1955.                 return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0;
    1956.             } else if ( name === "not" ) {
    1957.                 var not = match[3];
    1959.                 for ( var i = 0, l = not.length; i < l; i++ ) {
    1960.                     if ( Sizzle.filter(not[i], [elem]).length > 0 ) {
    1961.                         return false;
    1962.                     }
    1963.                 }
    1965.                 return true;
    1966.             }
    1967.         },
    1968.         ID: function(elem, match){
    1969.             return elem.nodeType === 1 && elem.getAttribute("id") === match;
    1970.         },
    1971.         TAG: function(elem, match){
    1972.             return (match === "*" && elem.nodeType === 1) || elem.nodeName === match;
    1973.         },
    1974.         CLASS: function(elem, match){
    1975.             return match.test( elem.className );
    1976.         },
    1977.         ATTR: function(elem, match){
    1978.             var result = elem[ match[1] ] || elem.getAttribute( match[1] ), value = result + "", type = match[2], check = match[4];
    1979.             return result == null ?
    1980.                 false :
    1981.                 type === "=" ?
    1982.                 value === check :
    1983.                 type === "*=" ?
    1984.                 value.indexOf(check) >= 0 :
    1985.                 type === "~=" ?
    1986.                 (" " + value + " ").indexOf(check) >= 0 :
    1987.                 !match[4] ?
    1988.                 result :
    1989.                 type === "!=" ?
    1990.                 value != check :
    1991.                 type === "^=" ?
    1992.                 value.indexOf(check) === 0 :
    1993.                 type === "$=" ?
    1994.                 value.substr(value.length - check.length) === check :
    1995.                 type === "|=" ?
    1996.                 value === check || value.substr(0, check.length + 1) === check + "-" :
    1997.                 false;
    1998.         },
    1999.         POS: function(elem, match, i, array){
    2000.             var name = match[2], filter = Expr.setFilters[ name ];
    2002.             if ( filter ) {
    2003.                 return filter( elem, i, match, array );
    2004.             }
    2005.         }
    2006.     }
    2007. };
    2009. var makeArray = function(array, results) {
    2010.     array = Array.prototype.slice.call( array );
    2012.     if ( results ) {
    2013.         results.push.apply( results, array );
    2014.         return results;
    2015.     }
    2016.     
    2017.     return array;
    2018. };
    2020. // Perform a simple check to determine if the browser is capable of
    2021. // converting a NodeList to an array using builtin methods.
    2022. try {
    2023.     Array.prototype.slice.call( document.documentElement.childNodes );
    2025. // Provide a fallback method if it does not work
    2026. } catch(e){
    2027.     makeArray = function(array, results) {
    2028.         var ret = results || [];
    2030.         if ( array instanceof Array ) {
    2031.             Array.prototype.push.apply( ret, array );
    2032.         } else {
    2033.             if ( typeof array.length === "number" ) {
    2034.                 for ( var i = 0, l = array.length; i < l; i++ ) {
    2035.                     ret.push( array[i] );
    2036.                 }
    2037.             } else {
    2038.                 for ( var i = 0; array[i]; i++ ) {
    2039.                     ret.push( array[i] );
    2040.                 }
    2041.             }
    2042.         }
    2044.         return ret;
    2045.     };
    2046. }
    2048. // Check to see if the browser returns elements by name when
    2049. // querying by getElementById (and provide a workaround)
    2050. (function(){
    2051.     // We're going to inject a fake input element with a specified name
    2052.     var form = document.createElement("form"),
    2053.         id = "script" + (new Date).getTime();
    2054.     form.innerHTML = "<input name='" + id + "'/>";
    2056.     // Inject it into the root element, check its status, and remove it quickly
    2057.     var root = document.documentElement;
    2058.     root.insertBefore( form, root.firstChild );
    2060.     // The workaround has to do additional checks after a getElementById
    2061.     // Which slows things down for other browsers (hence the branching)
    2062.     if ( !!document.getElementById( id ) ) {
    2063.         Expr.find.ID = function(match, context){
    2064.             if ( context.getElementById ) {
    2065.                 var m = context.getElementById(match[1]);
    2066.                 return m ? m.id === match[1] || m.getAttributeNode && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
    2067.             }
    2068.         };
    2070.         Expr.filter.ID = function(elem, match){
    2071.             var node = elem.getAttributeNode && elem.getAttributeNode("id");
    2072.             return elem.nodeType === 1 && node && node.nodeValue === match;
    2073.         };
    2074.     }
    2076.     root.removeChild( form );
    2077. })();
    2079. // Check to see if the browser returns only elements
    2080. // when doing getElementsByTagName("*")
    2081. (function(){
    2082.     // Create a fake element
    2083.     var div = document.createElement("div");
    2084.     div.appendChild( document.createComment("") );
    2086.     // Make sure no comments are found
    2087.     if ( div.getElementsByTagName("*").length > 0 ) {
    2088.         Expr.find.TAG = function(match, context){
    2089.             var results = context.getElementsByTagName(match[1]);
    2091.             // Filter out possible comments
    2092.             if ( match[1] === "*" ) {
    2093.                 var tmp = [];
    2095.                 for ( var i = 0; results[i]; i++ ) {
    2096.                     if ( results[i].nodeType === 1 ) {
    2097.                         tmp.push( results[i] );
    2098.                     }
    2099.                 }
    2101.                 results = tmp;
    2102.             }
    2104.             return results;
    2105.         };
    2106.     }
    2107. })();
    2109. if ( document.querySelectorAll ) (function(){
    2110.     var oldSizzle = Sizzle;
    2111.     
    2112.     Sizzle = function(query, context, extra){
    2113.         context = context || document;
    2115.         if ( context.nodeType === 9 ) {
    2116.             try {
    2117.                 return makeArray( context.querySelectorAll(query) );
    2118.             } catch(e){}
    2119.         }
    2120.         
    2121.         return oldSizzle(query, context, extra);
    2122.     };
    2124.     Sizzle.find = oldSizzle.find;
    2125.     Sizzle.filter = oldSizzle.filter;
    2126.     Sizzle.selectors = oldSizzle.selectors;
    2127. })();
    2129. if ( document.documentElement.getElementsByClassName ) {
    2130.     Expr.order.splice(1, 0, "CLASS");
    2131.     Expr.find.CLASS = function(match, context) {
    2132.         return context.getElementsByClassName(match[1]);
    2133.     };
    2134. }
    2136. function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck ) {
    2137.     for ( var i = 0, l = checkSet.length; i < l; i++ ) {
    2138.         var elem = checkSet[i];
    2139.         if ( elem ) {
    2140.             elem = elem[dir]
    2141.             var match = false;
    2143.             while ( elem && elem.nodeType ) {
    2144.                 var done = elem[doneName];
    2145.                 if ( done ) {
    2146.                     match = checkSet[ done ];
    2147.                     break;
    2148.                 }
    2150.                 if ( elem.nodeType === 1 )
    2151.                     elem[doneName] = i;
    2153.                 if ( elem.nodeName === cur ) {
    2154.                     match = elem;
    2155.                     break;
    2156.                 }
    2158.                 elem = elem[dir];
    2159.             }
    2161.             checkSet[i] = match;
    2162.         }
    2163.     }
    2164. }
    2166. function dirCheck( dir, cur, doneName, checkSet, nodeCheck ) {
    2167.     for ( var i = 0, l = checkSet.length; i < l; i++ ) {
    2168.         var elem = checkSet[i];
    2169.         if ( elem ) {
    2170.             elem = elem[dir]
    2171.             var match = false;
    2173.             while ( elem && elem.nodeType ) {
    2174.                 if ( elem[doneName] ) {
    2175.                     match = checkSet[ elem[doneName] ];
    2176.                     break;
    2177.                 }
    2179.                 if ( elem.nodeType === 1 ) {
    2180.                     elem[doneName] = i;
    2182.                     if ( typeof cur !== "string" ) {
    2183.                         if ( elem === cur ) {
    2184.                             match = true;
    2185.                             break;
    2186.                         }
    2188.                     } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
    2189.                         match = elem;
    2190.                         break;
    2191.                     }
    2192.                 }
    2194.                 elem = elem[dir];
    2195.             }
    2197.             checkSet[i] = match;
    2198.         }
    2199.     }
    2200. }
    2202. var contains = document.compareDocumentPosition ?  function(a, b){
    2203.     return a.compareDocumentPosition(b) & 16;
    2204. } : function(a, b){
    2205.     return a !== b && a.contains(b);
    2206. };
    2208. // EXPOSE
    2209. jQuery.find = Sizzle;
    2210. jQuery.filter = Sizzle.filter;
    2211. jQuery.expr = Sizzle.selectors;
    2212. jQuery.expr[":"] = jQuery.expr.filters;
    2214. Sizzle.selectors.filters.hidden = function(elem){
    2215.     return "hidden" === elem.type ||
    2216.         jQuery.css(elem, "display") === "none" ||
    2217.         jQuery.css(elem, "visibility") === "hidden";
    2218. };
    2220. Sizzle.selectors.filters.visible = function(elem){
    2221.     return "hidden" !== elem.type &&
    2222.         jQuery.css(elem, "display") !== "none" &&
    2223.         jQuery.css(elem, "visibility") !== "hidden";
    2224. };
    2226. jQuery.multiFilter = function( expr, elems, not ) {
    2227.     if ( not ) {
    2228.         return jQuery.multiFilter( ":not(" + expr + ")", elems );
    2229.     }
    2231.     var exprs = expr.split(//s*,/s*/), cur = [];
    2233.     for ( var i = 0; i < exprs.length; i++ ) {
    2234.         cur = jQuery.merge( cur, jQuery.filter( exprs[i], elems ) );
    2235.     }
    2237.     return cur;
    2238. };
    2240. jQuery.dir = function( elem, dir ){
    2241.     var matched = [], cur = elem[dir];
    2242.     while ( cur && cur != document ) {
    2243.         if ( cur.nodeType == 1 )
    2244.             matched.push( cur );
    2245.         cur = cur[dir];
    2246.     }
    2247.     return matched;
    2248. };
    2250. jQuery.nth = function(cur, result, dir, elem){
    2251.     result = result || 1;
    2252.     var num = 0;
    2254.     for ( ; cur; cur = cur[dir] )
    2255.         if ( cur.nodeType == 1 && ++num == result )
    2256.             break;
    2258.     return cur;
    2259. };
    2261. jQuery.sibling = function(n, elem){
    2262.     var r = [];
    2264.     for ( ; n; n = n.nextSibling ) {
    2265.         if ( n.nodeType == 1 && n != elem )
    2266.             r.push( n );
    2267.     }
    2269.     return r;
    2270. };
    2272. return;
    2274. window.Sizzle = Sizzle;
    2276. })();
    2277. /*
    2278.  * A number of helper functions used for managing events.
    2279.  * Many of the ideas behind this code originated from
    2280.  * Dean Edwards' addEvent library.
    2281.  */
    2282. jQuery.event = {
    2284.     // Bind an event to an element
    2285.     // Original by Dean Edwards
    2286.     add: function(elem, types, handler, data) {
    2287.         if ( elem.nodeType == 3 || elem.nodeType == 8 )
    2288.             return;
    2290.         // For whatever reason, IE has trouble passing the window object
    2291.         // around, causing it to be cloned in the process
    2292.         if ( elem.setInterval && elem != window )
    2293.             elem = window;
    2295.         // Make sure that the function being executed has a unique ID
    2296.         if ( !handler.guid )
    2297.             handler.guid = this.guid++;
    2299.         // if data is passed, bind to handler
    2300.         if ( data !== undefined ) {
    2301.             // Create temporary function pointer to original handler
    2302.             var fn = handler;
    2304.             // Create unique handler function, wrapped around original handler
    2305.             handler = this.proxy( fn, function() {
    2306.                 // Pass arguments and context to original handler
    2307.                 return fn.apply(this, arguments);
    2308.             });
    2310.             // Store data in unique handler
    2311.             handler.data = data;
    2312.         }
    2314.         // Init the element's event structure
    2315.         var events = jQuery.data(elem, "events") || jQuery.data(elem, "events", {}),
    2316.             handle = jQuery.data(elem, "handle") || jQuery.data(elem, "handle", function(){
    2317.                 // Handle the second event of a trigger and when
    2318.                 // an event is called after a page has unloaded
    2319.                 return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
    2320.                     jQuery.event.handle.apply(arguments.callee.elem, arguments) :
    2321.                     undefined;
    2322.             });
    2323.         // Add elem as a property of the handle function
    2324.         // This is to prevent a memory leak with non-native
    2325.         // event in IE.
    2326.         handle.elem = elem;
    2328.         // Handle multiple events separated by a space
    2329.         // jQuery(...).bind("mouseover mouseout", fn);
    2330.         jQuery.each(types.split(//s+/), function(index, type) {
    2331.             // Namespaced event handlers
    2332.             var namespaces = type.split(".");
    2333.             type = namespaces.shift();
    2334.             handler.type = namespaces.slice().sort().join(".");
    2336.             // Get the current list of functions bound to this event
    2337.             var handlers = events[type];
    2338.             
    2339.             if ( jQuery.event.specialAll[type] )
    2340.                 jQuery.event.specialAll[type].setup.call(elem, data, namespaces);
    2342.             // Init the event handler queue
    2343.             if (!handlers) {
    2344.                 handlers = events[type] = {};
    2346.                 // Check for a special event handler
    2347.                 // Only use addEventListener/attachEvent if the special
    2348.                 // events handler returns false
    2349.                 if ( !jQuery.event.special[type] || jQuery.event.special[type].setup.call(elem, data, namespaces) === false ) {
    2350.                     // Bind the global event handler to the element
    2351.                     if (elem.addEventListener)
    2352.                         elem.addEventListener(type, handle, false);
    2353.                     else if (elem.attachEvent)
    2354.                         elem.attachEvent("on" + type, handle);
    2355.                 }
    2356.             }
    2358.             // Add the function to the element's handler list
    2359.             handlers[handler.guid] = handler;
    2361.             // Keep track of which events have been used, for global triggering
    2362.             jQuery.event.global[type] = true;
    2363.         });
    2365.         // Nullify elem to prevent memory leaks in IE
    2366.         elem = null;
    2367.     },
    2369.     guid: 1,
    2370.     global: {},
    2372.     // Detach an event or set of events from an element
    2373.     remove: function(elem, types, handler) {
    2374.         // don't do events on text and comment nodes
    2375.         if ( elem.nodeType == 3 || elem.nodeType == 8 )
    2376.             return;
    2378.         var events = jQuery.data(elem, "events"), ret, index;
    2380.         if ( events ) {
    2381.             // Unbind all events for the element
    2382.             if ( types === undefined || (typeof types === "string" && types.charAt(0) == ".") )
    2383.                 for ( var type in events )
    2384.                     this.remove( elem, type + (types || "") );
    2385.             else {
    2386.                 // types is actually an event object here
    2387.                 if ( types.type ) {
    2388.                     handler = types.handler;
    2389.                     types = types.type;
    2390.                 }
    2392.                 // Handle multiple events seperated by a space
    2393.                 // jQuery(...).unbind("mouseover mouseout", fn);
    2394.                 jQuery.each(types.split(//s+/), function(index, type){
    2395.                     // Namespaced event handlers
    2396.                     var namespaces = type.split(".");
    2397.                     type = namespaces.shift();
    2398.                     var namespace = RegExp("(^|//.)" + namespaces.slice().sort().join(".*//.") + "(//.|$)");
    2400.                     if ( events[type] ) {
    2401.                         // remove the given handler for the given type
    2402.                         if ( handler )
    2403.                             delete events[type][handler.guid];
    2405.                         // remove all handlers for the given type
    2406.                         else
    2407.                             for ( handler in events[type] )
    2408.                                 // Handle the removal of namespaced events
    2409.                                 if ( namespace.test(events[type][handler].type) )
    2410.                                     delete events[type][handler];
    2411.                                     
    2412.                         if ( jQuery.event.specialAll[type] )
    2413.                             jQuery.event.specialAll[type].teardown.call(elem, namespaces);
    2415.                         // remove generic event handler if no more handlers exist
    2416.                         for ( ret in events[type] ) break;
    2417.                         if ( !ret ) {
    2418.                             if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem, namespaces) === false ) {
    2419.                                 if (elem.removeEventListener)
    2420.                                     elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
    2421.                                 else if (elem.detachEvent)
    2422.                                     elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
    2423.                             }
    2424.                             ret = null;
    2425.                             delete events[type];
    2426.                         }
    2427.                     }
    2428.                 });
    2429.             }
    2431.             // Remove the expando if it's no longer used
    2432.             for ( ret in events ) break;
    2433.             if ( !ret ) {
    2434.                 var handle = jQuery.data( elem, "handle" );
    2435.                 if ( handle ) handle.elem = null;
    2436.                 jQuery.removeData( elem, "events" );
    2437.                 jQuery.removeData( elem, "handle" );
    2438.             }
    2439.         }
    2440.     },
    2442.     trigger: function(type, data, elem, donative, extra, dohandlers) {
    2443.         // Clone the incoming data, if any
    2444.         data = jQuery.makeArray(data);
    2446.         if ( type.indexOf("!") >= 0 ) {
    2447.             type = type.slice(0, -1);
    2448.             var exclusive = true;
    2449.         }
    2451.         // Handle a global trigger
    2452.         if ( !elem ) {
    2453.             // Only trigger if we've ever bound an event for it
    2454.             if ( this.global[type] )
    2455.                 jQuery.each( jQuery.cache, function(){
    2456.                     if ( this.events && this.events[type] )
    2457.                         jQuery.event.trigger( type, data, this.handle.elem, false );
    2458.                 });
    2460.         // Handle triggering a single element
    2461.         } else {
    2462.             // don't do events on text and comment nodes
    2463.             if ( elem.nodeType == 3 || elem.nodeType == 8 )
    2464.                 return undefined;
    2466.             var val, ret, fn = jQuery.isFunction( elem[ type ] || null ),
    2467.                 // Check to see if we need to provide a fake event, or not
    2468.                 event = !data[0] || !data[0].preventDefault;
    2470.             // Pass along a fake event
    2471.             if ( event ) {
    2472.                 data.unshift({
    2473.                     type: type,
    2474.                     target: elem,
    2475.                     preventDefault: function(){},
    2476.                     stopPropagation: function(){},
    2477.                     stopImmediatePropagation:stopImmediatePropagation,
    2478.                     timeStamp: now()
    2479.                 });
    2480.                 data[0][expando] = true; // no need to fix fake event
    2481.             }
    2483.             // Enforce the right trigger type
    2484.             data[0].type = type;
    2485.             if ( exclusive )
    2486.                 data[0].exclusive = true;
    2488.             if ( dohandlers !== false ) {
    2489.                 // Trigger the event, it is assumed that "handle" is a function
    2490.                 var handle = jQuery.data(elem, "handle");
    2491.                 if ( handle )
    2492.                     val = handle.apply( elem, data );
    2494.                 // Handle triggering native .onfoo handlers (and on links since we don't call .click() for links)
    2495.                 if ( (!fn || (jQuery.nodeName(elem, 'a') && type == "click")) && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
    2496.                     val = false;
    2497.             }
    2499.             if ( donative !== false && val !== false ) {
    2500.                 var parent = elem.parentNode || elem.ownerDocument;
    2501.                 if ( parent )
    2502.                     jQuery.event.trigger(type, data, parent, donative);
    2503.             }
    2505.             // Extra functions don't get the custom event object
    2506.             if ( event )
    2507.                 data.shift();
    2509.             // Handle triggering of extra function
    2510.             if ( extra && jQuery.isFunction( extra ) ) {
    2511.                 // call the extra function and tack the current return value on the end for possible inspection
    2512.                 ret = extra.apply( elem, val == null ? data : data.concat( val ) );
    2513.                 // if anything is returned, give it precedence and have it overwrite the previous value
    2514.                 if ( ret !== undefined )
    2515.                     val = ret;
    2516.             }
    2518.             // Trigger the native events (except for clicks on links)
    2519.             if ( fn && donative !== false && val !== false && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
    2520.                 this.triggered = true;
    2521.                 try {
    2522.                     elem[ type ]();
    2523.                 // prevent IE from throwing an error for some hidden elements
    2524.                 } catch (e) {}
    2525.             }
    2527.             this.triggered = false;
    2528.         }
    2530.         return val;
    2531.     },
    2533.     handle: function(event) {
    2534.         // returned undefined or false
    2535.         var val, ret, all, handlers;
    2537.         event = arguments[0] = jQuery.event.fix( event || window.event );
    2539.         // Namespaced event handlers
    2540.         var namespaces = event.type.split(".");
    2541.         event.type = namespaces.shift();
    2543.         // Cache this now, all = true means, any handler
    2544.         all = !namespaces.length && !event.exclusive;
    2545.         
    2546.         var namespace = RegExp("(^|//.)" + namespaces.slice().sort().join(".*//.") + "(//.|$)");
    2548.         handlers = ( jQuery.data(this, "events") || {} )[event.type];
    2550.         for ( var j in handlers ) {
    2551.             var handler = handlers[j];
    2553.             // Filter the functions by class
    2554.             if ( all || namespace.test(handler.type) ) {
    2555.                 // Pass in a reference to the handler function itself
    2556.                 // So that we can later remove it
    2557.                 event.handler = handler;
    2558.                 event.data = handler.data;
    2560.                 ret = handler.apply( this, arguments );
    2562.                 if ( val !== false )
    2563.                     val = ret;
    2565.                 if ( ret === false ) {
    2566.                     event.preventDefault();
    2567.                     event.stopPropagation();
    2568.                 }
    2570.                 if( event._sip )
    2571.                     break;
    2573.             }
    2574.         }
    2576.         return val;
    2577.     },
    2579.     props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target timeStamp toElement type view wheelDelta which".split(" "),
    2581.     fix: function(event) {
    2582.         if ( event[expando] )
    2583.             return event;
    2585.         // store a copy of the original event object
    2586.         // and "clone" to set read-only properties
    2587.         var originalEvent = event;
    2588.         event = { originalEvent: originalEvent };
    2590.         for ( var i = this.props.length, prop; i; ){
    2591.             prop = this.props[ --i ];
    2592.             event[ prop ] = originalEvent[ prop ];
    2593.         }
    2595.         // Mark it as fixed
    2596.         event[expando] = true;
    2598.         // add preventDefault and stopPropagation since
    2599.         // they will not work on the clone
    2600.         event.preventDefault = function() {
    2601.             // if preventDefault exists run it on the original event
    2602.             if (originalEvent.preventDefault)
    2603.                 originalEvent.preventDefault();
    2604.             // otherwise set the returnValue property of the original event to false (IE)
    2605.             originalEvent.returnValue = false;
    2606.         };
    2607.         event.stopPropagation = function() {
    2608.             // if stopPropagation exists run it on the original event
    2609.             if (originalEvent.stopPropagation)
    2610.                 originalEvent.stopPropagation();
    2611.             // otherwise set the cancelBubble property of the original event to true (IE)
    2612.             originalEvent.cancelBubble = true;
    2613.         };
    2615.         event.stopImmediatePropagation = stopImmediatePropagation;
    2617.         // Fix timeStamp
    2618.         event.timeStamp = event.timeStamp || now();
    2620.         // Fix target property, if necessary
    2621.         if ( !event.target )
    2622.             event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
    2624.         // check if target is a textnode (safari)
    2625.         if ( event.target.nodeType == 3 )
    2626.             event.target = event.target.parentNode;
    2628.         // Add relatedTarget, if necessary
    2629.         if ( !event.relatedTarget && event.fromElement )
    2630.             event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
    2632.         // Calculate pageX/Y if missing and clientX/Y available
    2633.         if ( event.pageX == null && event.clientX != null ) {
    2634.             var doc = document.documentElement, body = document.body;
    2635.             event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
    2636.             event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
    2637.         }
    2639.         // Add which for key events
    2640.         if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
    2641.             event.which = event.charCode || event.keyCode;
    2643.         // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
    2644.         if ( !event.metaKey && event.ctrlKey )
    2645.             event.metaKey = event.ctrlKey;
    2647.         // Add which for click: 1 == left; 2 == middle; 3 == right
    2648.         // Note: button is not normalized, so don't use it
    2649.         if ( !event.which && event.button )
    2650.             event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
    2652.         return event;
    2653.     },
    2655.     proxy: function( fn, proxy ){
    2656.         // Set the guid of unique handler to the same of original handler, so it can be removed
    2657.         proxy.guid = fn.guid = fn.guid || proxy.guid || this.guid++;
    2658.         // So proxy can be declared as an argument
    2659.         return proxy;
    2660.     },
    2662.     special: {
    2663.         ready: {
    2664.             // Make sure the ready event is setup
    2665.             setup: bindReady,
    2666.             teardown: function() {}
    2667.         }
    2668.     },
    2669.     
    2670.     specialAll: {
    2671.         live: {
    2672.             setup: function( selector, namespaces ){
    2673.                 jQuery.event.add( this, namespaces[0], liveHandler );
    2674.             },
    2675.             teardown:  function( namespaces ){
    2676.                 if ( namespaces.length ) {
    2677.                     var remove = 0, name = RegExp("(^|//.)" + namespaces[0] + "(//.|$)");
    2678.                     
    2679.                     jQuery.each( (jQuery.data(this, "events").live || {}), function(){
    2680.                         if ( name.test(this.type) )
    2681.                             remove++;
    2682.                     });
    2683.                     
    2684.                     if ( remove <= 1 )
    2685.                         jQuery.event.remove( this, namespaces[0], liveHandler );
    2686.                 }
    2687.             }
    2688.         }
    2689.     }
    2690. };
    2692. function stopImmediatePropagation(){
    2693.     this._sip = 1;
    2694.     this.stopPropagation();
    2695. }
    2697. // Checks if an event happened on an element within another element
    2698. // Used in jQuery.event.special.mouseenter and mouseleave handlers
    2699. var withinElement = function(event) {
    2700.     // Check if mouse(over|out) are still within the same parent element
    2701.     var parent = event.relatedTarget;
    2702.     // Traverse up the tree
    2703.     while ( parent && parent != this )
    2704.         try { parent = parent.parentNode; }
    2705.         catch(e) { parent = this; }
    2706.     
    2707.     if( parent != this ){
    2708.         // set the correct event type
    2709.         event.type = event.data;
    2710.         // handle event if we actually just moused on to a non sub-element
    2711.         jQuery.event.handle.apply( this, arguments );
    2712.     }
    2713. };
    2714.     
    2715. jQuery.each({ 
    2716.     mouseover: 'mouseenter', 
    2717.     mouseout: 'mouseleave'
    2718. }, function( orig, fix ){
    2719.     jQuery.event.special[ fix ] = {
    2720.         setup: function(){
    2721.             jQuery.event.add( this, orig, withinElement, fix );
    2722.         },
    2723.         teardown: function(){
    2724.             jQuery.event.remove( this, orig, withinElement );
    2725.         }
    2726.     };             
    2727. });
    2729. jQuery.fn.extend({
    2730.     bind: function( type, data, fn ) {
    2731.         return type == "unload" ? this.one(type, data, fn) : this.each(function(){
    2732.             jQuery.event.add( this, type, fn || data, fn && data );
    2733.         });
    2734.     },
    2736.     one: function( type, data, fn ) {
    2737.         var one = jQuery.event.proxy( fn || data, function(event) {
    2738.             jQuery(this).unbind(event, one);
    2739.             return (fn || data).apply( this, arguments );
    2740.         });
    2741.         return this.each(function(){
    2742.             jQuery.event.add( this, type, one, fn && data);
    2743.         });
    2744.     },
    2746.     unbind: function( type, fn ) {
    2747.         return this.each(function(){
    2748.             jQuery.event.remove( this, type, fn );
    2749.         });
    2750.     },
    2752.     trigger: function( type, data, fn ) {
    2753.         return this.each(function(){
    2754.             jQuery.event.trigger( type, data, this, true, fn );
    2755.         });
    2756.     },
    2758.     triggerHandler: function( type, data, fn ) {
    2759.         return this[0] && jQuery.event.trigger( type, data, this[0], false, fn );
    2760.     },
    2762.     toggle: function( fn ) {
    2763.         // Save reference to arguments for access in closure
    2764.         var args = arguments, i = 1;
    2766.         // link all the functions, so any of them can unbind this click handler
    2767.         while( i < args.length )
    2768.             jQuery.event.proxy( fn, args[i++] );
    2770.         return this.click( jQuery.event.proxy( fn, function(event) {
    2771.             // Figure out which function to execute
    2772.             this.lastToggle = ( this.lastToggle || 0 ) % i;
    2774.             // Make sure that clicks stop
    2775.             event.preventDefault();
    2777.             // and execute the function
    2778.             return args[ this.lastToggle++ ].apply( this, arguments ) || false;
    2779.         }));
    2780.     },
    2782.     hover: function(fnOver, fnOut) {
    2783.         return this.mouseenter(fnOver).mouseleave(fnOut);
    2784.     },
    2786.     ready: function(fn) {
    2787.         // Attach the listeners
    2788.         bindReady();
    2790.         // If the DOM is already ready
    2791.         if ( jQuery.isReady )
    2792.             // Execute the function immediately
    2793.             fn.call( document, jQuery );
    2795.         // Otherwise, remember the function for later
    2796.         else
    2797.             // Add the function to the wait list
    2798.             jQuery.readyList.push( function() { return fn.call(this, jQuery); } );
    2800.         return this;
    2801.     },
    2802.     
    2803.     live: function( type, fn ){
    2804.         jQuery(document).bind( liveConvert(type, this.selector), this.selector, fn );
    2805.         return this;
    2806.     },
    2807.     
    2808.     die: function( type, fn ){
    2809.         jQuery(document).unbind( liveConvert(type, this.selector), fn );
    2810.         return this;
    2811.     }
    2812. });
    2814. function liveHandler( event ){
    2815.     var check = RegExp("(^|//.)" + event.type + "(//.|$)");
    2816.     jQuery.each(jQuery.data(this, "events").live || [], function(i, fn){
    2817.         if ( check.test(fn.type) ) {
    2818.             var elem = jQuery(event.target).closest(fn.data)[0];
    2819.             if ( elem )
    2820.                 jQuery.event.trigger( event.type, fn.data, elem, false, fn, false );
    2821.         }
    2822.     });
    2823. }
    2825. function liveConvert(type, selector){
    2826.     return ["live", type, selector.replace(//./g, "_")].join(".");
    2827. }
    2829. jQuery.extend({
    2830.     isReady: false,
    2831.     readyList: [],
    2832.     // Handle when the DOM is ready
    2833.     ready: function() {
    2834.         // Make sure that the DOM is not already loaded
    2835.         if ( !jQuery.isReady ) {
    2836.             // Remember that the DOM is ready
    2837.             jQuery.isReady = true;
    2839.             // If there are functions bound, to execute
    2840.             if ( jQuery.readyList ) {
    2841.                 // Execute all of them
    2842.                 jQuery.each( jQuery.readyList, function(){
    2843.                     this.call( document );
    2844.                 });
    2846.                 // Reset the list of functions
    2847.                 jQuery.readyList = null;
    2848.             }
    2850.             // Trigger any bound ready events
    2851.             jQuery(document).triggerHandler("ready");
    2852.         }
    2853.     }
    2854. });
    2856. var readyBound = false;
    2858. function bindReady(){
    2859.     if ( readyBound ) return;
    2860.     readyBound = true;
    2862.     // Mozilla, Opera and webkit nightlies currently support this event
    2863.     if ( document.addEventListener ) {
    2864.         // Use the handy event callback
    2865.         document.addEventListener( "DOMContentLoaded", function(){
    2866.             document.removeEventListener( "DOMContentLoaded", arguments.callee, false );
    2867.             jQuery.ready();
    2868.         }, false );
    2870.     // If IE event model is used
    2871.     } else if ( document.attachEvent ) {
    2872.         // ensure firing before onload,
    2873.         // maybe late but safe also for iframes
    2874.         document.attachEvent("onreadystatechange", function(){
    2875.             if ( document.readyState === "complete" ) {
    2876.                 document.detachEvent( "onreadystatechange", arguments.callee );
    2877.                 jQuery.ready();
    2878.             }
    2879.         });
    2881.         // If IE and not an iframe
    2882.         // continually check to see if the document is ready
    2883.         if ( document.documentElement.doScroll && !window.frameElement ) (function(){
    2884.             if ( jQuery.isReady ) return;
    2886.             try {
    2887.                 // If IE is used, use the trick by Diego Perini
    2888.                 // http://javascript.nwbox.com/IEContentLoaded/
    2889.                 document.documentElement.doScroll("left");
    2890.             } catch( error ) {
    2891.                 setTimeout( arguments.callee, 0 );
    2892.                 return;
    2893.             }
    2895.             // and execute any waiting functions
    2896.             jQuery.ready();
    2897.         })();
    2898.     }
    2900.     // A fallback to window.onload, that will always work
    2901.     jQuery.event.add( window, "load", jQuery.ready );
    2902. }
    2904. jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," +
    2905.     "mousedown,mouseup,mousemove,mouseover,mouseout,mouseenter,mouseleave," +
    2906.     "change,select,submit,keydown,keypress,keyup,error").split(","), function(i, name){
    2908.     // Handle event binding
    2909.     jQuery.fn[name] = function(fn){
    2910.         return fn ? this.bind(name, fn) : this.trigger(name);
    2911.     };
    2912. });
    2914. // Prevent memory leaks in IE
    2915. // And prevent errors on refresh with events like mouseover in other browsers
    2916. // Window isn't included so as not to unbind existing unload events
    2917. jQuery( window ).bind( 'unload', function(){ 
    2918.     for ( var id in jQuery.cache )
    2919.         // Skip the window
    2920.         if ( id != 1 && jQuery.cache[ id ].handle )
    2921.             jQuery.event.remove( jQuery.cache[ id ].handle.elem );
    2922. }); 
    2923. jQuery.fn.extend({
    2924.     // Keep a copy of the old load
    2925.     _load: jQuery.fn.load,
    2927.     load: function( url, params, callback ) {
    2928.         if ( typeof url !== "string" )
    2929.             return this._load( url );
    2931.         var off = url.indexOf(" ");
    2932.         if ( off >= 0 ) {
    2933.             var selector = url.slice(off, url.length);
    2934.             url = url.slice(0, off);
    2935.         }
    2937.         // Default to a GET request
    2938.         var type = "GET";
    2940.         // If the second parameter was provided
    2941.         if ( params )
    2942.             // If it's a function
    2943.             if ( jQuery.isFunction( params ) ) {
    2944.                 // We assume that it's the callback
    2945.                 callback = params;
    2946.                 params = null;
    2948.             // Otherwise, build a param string
    2949.             } else if( typeof params === "object" ) {
    2950.                 params = jQuery.param( params );
    2951.                 type = "POST";
    2952.             }
    2954.         var self = this;
    2956.         // Request the remote document
    2957.         jQuery.ajax({
    2958.             url: url,
    2959.             type: type,
    2960.             dataType: "html",
    2961.             data: params,
    2962.             complete: function(res, status){
    2963.                 // If successful, inject the HTML into all the matched elements
    2964.                 if ( status == "success" || status == "notmodified" )
    2965.                     // See if a selector was specified
    2966.                     self.html( selector ?
    2967.                         // Create a dummy div to hold the results
    2968.                         jQuery("<div/>")
    2969.                             // inject the contents of the document in, removing the scripts
    2970.                             // to avoid any 'Permission Denied' errors in IE
    2971.                             .append(res.responseText.replace(/<script(.|/s)*?//script>/g, ""))
    2973.                             // Locate the specified elements
    2974.                             .find(selector) :
    2976.                         // If not, just inject the full result
    2977.                         res.responseText );
    2979.                 if( callback )
    2980.                     self.each( callback, [res.responseText, status, res] );
    2981.             }
    2982.         });
    2983.         return this;
    2984.     },
    2986.     serialize: function() {
    2987.         return jQuery.param(this.serializeArray());
    2988.     },
    2989.     serializeArray: function() {
    2990.         return this.map(function(){
    2991.             return this.elements ? jQuery.makeArray(this.elements) : this;
    2992.         })
    2993.         .filter(function(){
    2994.             return this.name && !this.disabled &&
    2995.                 (this.checked || /select|textarea/i.test(this.nodeName) ||
    2996.                     /text|hidden|password/i.test(this.type));
    2997.         })
    2998.         .map(function(i, elem){
    2999.             var val = jQuery(this).val();
    3000.             return val == null ? null :
    3001.                 jQuery.isArray(val) ?
    3002.                     jQuery.map( val, function(val, i){
    3003.                         return {name: elem.name, value: val};
    3004.                     }) :
    3005.                     {name: elem.name, value: val};
    3006.         }).get();
    3007.     }
    3008. });
    3010. // Attach a bunch of functions for handling common AJAX events
    3011. jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
    3012.     jQuery.fn[o] = function(f){
    3013.         return this.bind(o, f);
    3014.     };
    3015. });
    3017. var jsc = now();
    3019. jQuery.extend({
    3020.   
    3021.     get: function( url, data, callback, type ) {
    3022.         // shift arguments if data argument was ommited
    3023.         if ( jQuery.isFunction( data ) ) {
    3024.             callback = data;
    3025.             data = null;
    3026.         }
    3028.         return jQuery.ajax({
    3029.             type: "GET",
    3030.             url: url,
    3031.             data: data,
    3032.             success: callback,
    3033.             dataType: type
    3034.         });
    3035.     },
    3037.     getScript: function( url, callback ) {
    3038.         return jQuery.get(url, null, callback, "script");
    3039.     },
    3041.     getJSON: function( url, data, callback ) {
    3042.         return jQuery.get(url, data, callback, "json");
    3043.     },
    3045.     post: function( url, data, callback, type ) {
    3046.         if ( jQuery.isFunction( data ) ) {
    3047.             callback = data;
    3048.             data = {};
    3049.         }
    3051.         return jQuery.ajax({
    3052.             type: "POST",
    3053.             url: url,
    3054.             data: data,
    3055.             success: callback,
    3056.             dataType: type
    3057.         });
    3058.     },
    3060.     ajaxSetup: function( settings ) {
    3061.         jQuery.extend( jQuery.ajaxSettings, settings );
    3062.     },
    3064.     ajaxSettings: {
    3065.         url: location.href,
    3066.         global: true,
    3067.         type: "GET",
    3068.         timeout: 0,
    3069.         contentType: "application/x-www-form-urlencoded",
    3070.         processData: true,
    3071.         async: true,
    3072.         data: null,
    3073.         username: null,
    3074.         password: null,
    3075.         // Create the request object; Microsoft failed to properly
    3076.         // implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available
    3077.         // This function can be overriden by calling jQuery.ajaxSetup
    3078.         xhr:function(){
    3079.             return window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
    3080.         },
    3081.         accepts: {
    3082.             xml: "application/xml, text/xml",
    3083.             html: "text/html",
    3084.             script: "text/javascript, application/javascript",
    3085.             json: "application/json, text/javascript",
    3086.             text: "text/plain",
    3087.             _default: "*/*"
    3088.         }
    3089.     },
    3091.     // Last-Modified header cache for next request
    3092.     lastModified: {},
    3094.     ajax: function( s ) {
    3095.         // Extend the settings, but re-extend 's' so that it can be
    3096.         // checked again later (in the test suite, specifically)
    3097.         s = jQuery.extend(true, s, jQuery.extend(true, {}, jQuery.ajaxSettings, s));
    3099.         var jsonp, jsre = /=/?(&|$)/g, status, data,
    3100.             type = s.type.toUpperCase();
    3102.         // convert data if not already a string
    3103.         if ( s.data && s.processData && typeof s.data !== "string" )
    3104.             s.data = jQuery.param(s.data);
    3106.         // Handle JSONP Parameter Callbacks
    3107.         if ( s.dataType == "jsonp" ) {
    3108.             if ( type == "GET" ) {
    3109.                 if ( !s.url.match(jsre) )
    3110.                     s.url += (s.url.match(//?/) ? "&" : "?") + (s.jsonp || "callback") + "=?";
    3111.             } else if ( !s.data || !s.data.match(jsre) )
    3112.                 s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
    3113.             s.dataType = "json";
    3114.         }
    3116.         // Build temporary JSONP function
    3117.         if ( s.dataType == "json" && (s.data && s.data.match(jsre) || s.url.match(jsre)) ) {
    3118.             jsonp = "jsonp" + jsc++;
    3120.             // Replace the =? sequence both in the query string and the data
    3121.             if ( s.data )
    3122.                 s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
    3123.             s.url = s.url.replace(jsre, "=" + jsonp + "$1");
    3125.             // We need to make sure
    3126.             // that a JSONP style response is executed properly
    3127.             s.dataType = "script";
    3129.             // Handle JSONP-style loading
    3130.             window[ jsonp ] = function(tmp){
    3131.                 data = tmp;
    3132.                 success();
    3133.                 complete();
    3134.                 // Garbage collect
    3135.                 window[ jsonp ] = undefined;
    3136.                 try{ delete window[ jsonp ]; } catch(e){}
    3137.                 if ( head )
    3138.                     head.removeChild( script );
    3139.             };
    3140.         }
    3142.         if ( s.dataType == "script" && s.cache == null )
    3143.             s.cache = false;
    3145.         if ( s.cache === false && type == "GET" ) {
    3146.             var ts = now();
    3147.             // try replacing _= if it is there
    3148.             var ret = s.url.replace(/(/?|&)_=.*?(&|$)/, "$1_=" + ts + "$2");
    3149.             // if nothing was replaced, add timestamp to the end
    3150.             s.url = ret + ((ret == s.url) ? (s.url.match(//?/) ? "&" : "?") + "_=" + ts : "");
    3151.         }
    3153.         // If data is available, append data to url for get requests
    3154.         if ( s.data && type == "GET" ) {
    3155.             s.url += (s.url.match(//?/) ? "&" : "?") + s.data;
    3157.             // IE likes to send both get and post data, prevent this
    3158.             s.data = null;
    3159.         }
    3161.         // Watch for a new set of requests
    3162.         if ( s.global && ! jQuery.active++ )
    3163.             jQuery.event.trigger( "ajaxStart" );
    3165.         // Matches an absolute URL, and saves the domain
    3166.         var parts = /^(/w+:)?////([^//?#]+)/.exec( s.url );
    3168.         // If we're requesting a remote document
    3169.         // and trying to load JSON or Script with a GET
    3170.         if ( s.dataType == "script" && type == "GET" && parts
    3171.             && ( parts[1] && parts[1] != location.protocol || parts[2] != location.host )){
    3173.             var head = document.getElementsByTagName("head")[0];
    3174.             var script = document.createElement("script");
    3175.             script.src = s.url;
    3176.             if (s.scriptCharset)
    3177.                 script.charset = s.scriptCharset;
    3179.             // Handle Script loading
    3180.             if ( !jsonp ) {
    3181.                 var done = false;
    3183.                 // Attach handlers for all browsers
    3184.                 script.onload = script.onreadystatechange = function(){
    3185.                     if ( !done && (!this.readyState ||
    3186.                             this.readyState == "loaded" || this.readyState == "complete") ) {
    3187.                         done = true;
    3188.                         success();
    3189.                         complete();
    3190.                         head.removeChild( script );
    3191.                     }
    3192.                 };
    3193.             }
    3195.             head.appendChild(script);
    3197.             // We handle everything using the script element injection
    3198.             return undefined;
    3199.         }
    3201.         var requestDone = false;
    3203.         // Create the request object
    3204.         var xhr = s.xhr();
    3206.         // Open the socket
    3207.         // Passing null username, generates a login popup on Opera (#2865)
    3208.         if( s.username )
    3209.             xhr.open(type, s.url, s.async, s.username, s.password);
    3210.         else
    3211.             xhr.open(type, s.url, s.async);
    3213.         // Need an extra try/catch for cross domain requests in Firefox 3
    3214.         try {
    3215.             // Set the correct header, if data is being sent
    3216.             if ( s.data )
    3217.                 xhr.setRequestHeader("Content-Type", s.contentType);
    3219.             // Set the If-Modified-Since header, if ifModified mode.
    3220.             if ( s.ifModified )
    3221.                 xhr.setRequestHeader("If-Modified-Since",
    3222.                     jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" );
    3224.             // Set header so the called script knows that it's an XMLHttpRequest
    3225.             xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
    3227.             // Set the Accepts header for the server, depending on the dataType
    3228.             xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
    3229.                 s.accepts[ s.dataType ] + ", */*" :
    3230.                 s.accepts._default );
    3231.         } catch(e){}
    3233.         // Allow custom headers/mimetypes and early abort
    3234.         if ( s.beforeSend && s.beforeSend(xhr, s) === false ) {
    3235.             // Handle the global AJAX counter
    3236.             if ( s.global && ! --jQuery.active )
    3237.                 jQuery.event.trigger( "ajaxStop" );
    3238.             // close opended socket
    3239.             xhr.abort();
    3240.             return false;
    3241.         }
    3243.         if ( s.global )
    3244.             jQuery.event.trigger("ajaxSend", [xhr, s]);
    3246.         // Wait for a response to come back
    3247.         var onreadystatechange = function(isTimeout){
    3248.             // The request was aborted, clear the interval and decrement jQuery.active
    3249.             if (xhr.readyState == 0) {
    3250.                 if (ival) {
    3251.                     // clear poll interval
    3252.                     clearInterval(ival);
    3253.                     ival = null;
    3254.                     // Handle the global AJAX counter
    3255.                     if ( s.global && ! --jQuery.active )
    3256.                         jQuery.event.trigger( "ajaxStop" );
    3257.                 }
    3258.             // The transfer is complete and the data is available, or the request timed out
    3259.             } else if ( !requestDone && xhr && (xhr.readyState == 4 || isTimeout == "timeout") ) {
    3260.                 requestDone = true;
    3262.                 // clear poll interval
    3263.                 if (ival) {
    3264.                     clearInterval(ival);
    3265.                     ival = null;
    3266.                 }
    3268.                 status = isTimeout == "timeout" ? "timeout" :
    3269.                     !jQuery.httpSuccess( xhr ) ? "error" :
    3270.                     s.ifModified && jQuery.httpNotModified( xhr, s.url ) ? "notmodified" :
    3271.                     "success";
    3273.                 if ( status == "success" ) {
    3274.                     // Watch for, and catch, XML document parse errors
    3275.                     try {
    3276.                         // process the data (runs the xml through httpData regardless of callback)
    3277.                         data = jQuery.httpData( xhr, s.dataType, s );
    3278.                     } catch(e) {
    3279.                         status = "parsererror";
    3280.                     }
    3281.                 }
    3283.                 // Make sure that the request was successful or notmodified
    3284.                 if ( status == "success" ) {
    3285.                     // Cache Last-Modified header, if ifModified mode.
    3286.                     var modRes;
    3287.                     try {
    3288.                         modRes = xhr.getResponseHeader("Last-Modified");
    3289.                     } catch(e) {} // swallow exception thrown by FF if header is not available
    3291.                     if ( s.ifModified && modRes )
    3292.                         jQuery.lastModified[s.url] = modRes;
    3294.                     // JSONP handles its own success callback
    3295.                     if ( !jsonp )
    3296.                         success();
    3297.                 } else
    3298.                     jQuery.handleError(s, xhr, status);
    3300.                 // Fire the complete handlers
    3301.                 complete();
    3303.                 // Stop memory leaks
    3304.                 if ( s.async )
    3305.                     xhr = null;
    3306.             }
    3307.         };
    3309.         if ( s.async ) {
    3310.             // don't attach the handler to the request, just poll it instead
    3311.             var ival = setInterval(onreadystatechange, 13);
    3313.             // Timeout checker
    3314.             if ( s.timeout > 0 )
    3315.                 setTimeout(function(){
    3316.                     // Check to see if the request is still happening
    3317.                     if ( xhr ) {
    3318.                         if( !requestDone )
    3319.                             onreadystatechange( "timeout" );
    3321.                         // Cancel the request
    3322.                         if ( xhr )
    3323.                             xhr.abort();
    3324.                     }
    3325.                 }, s.timeout);
    3326.         }
    3328.         // Send the data
    3329.         try {
    3330.             xhr.send(s.data);
    3331.         } catch(e) {
    3332.             jQuery.handleError(s, xhr, null, e);
    3333.         }
    3335.         // firefox 1.5 doesn't fire statechange for sync requests
    3336.         if ( !s.async )
    3337.             onreadystatechange();
    3339.         function success(){
    3340.             // If a local callback was specified, fire it and pass it the data
    3341.             if ( s.success )
    3342.                 s.success( data, status );
    3344.             // Fire the global callback
    3345.             if ( s.global )
    3346.                 jQuery.event.trigger( "ajaxSuccess", [xhr, s] );
    3347.         }
    3349.         function complete(){
    3350.             // Process result
    3351.             if ( s.complete )
    3352.                 s.complete(xhr, status);
    3354.             // The request was completed
    3355.             if ( s.global )
    3356.                 jQuery.event.trigger( "ajaxComplete", [xhr, s] );
    3358.             // Handle the global AJAX counter
    3359.             if ( s.global && ! --jQuery.active )
    3360.                 jQuery.event.trigger( "ajaxStop" );
    3361.         }
    3363.         // return XMLHttpRequest to allow aborting the request etc.
    3364.         return xhr;
    3365.     },
    3367.     handleError: function( s, xhr, status, e ) {
    3368.         // If a local callback was specified, fire it
    3369.         if ( s.error ) s.error( xhr, status, e );
    3371.         // Fire the global callback
    3372.         if ( s.global )
    3373.             jQuery.event.trigger( "ajaxError", [xhr, s, e] );
    3374.     },
    3376.     // Counter for holding the number of active queries
    3377.     active: 0,
    3379.     // Determines if an XMLHttpRequest was successful or not
    3380.     httpSuccess: function( xhr ) {
    3381.         try {
    3382.             // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
    3383.             return !xhr.status && location.protocol == "file:" ||
    3384.                 ( xhr.status >= 200 && xhr.status < 300 ) || xhr.status == 304 || xhr.status == 1223;
    3385.         } catch(e){}
    3386.         return false;
    3387.     },
    3389.     // Determines if an XMLHttpRequest returns NotModified
    3390.     httpNotModified: function( xhr, url ) {
    3391.         try {
    3392.             var xhrRes = xhr.getResponseHeader("Last-Modified");
    3394.             // Firefox always returns 200. check Last-Modified date
    3395.             return xhr.status == 304 || xhrRes == jQuery.lastModified[url];
    3396.         } catch(e){}
    3397.         return false;
    3398.     },
    3400.     httpData: function( xhr, type, s ) {
    3401.         var ct = xhr.getResponseHeader("content-type"),
    3402.             xml = type == "xml" || !type && ct && ct.indexOf("xml") >= 0,
    3403.             data = xml ? xhr.responseXML : xhr.responseText;
    3405.         if ( xml && data.documentElement.tagName == "parsererror" )
    3406.             throw "parsererror";
    3407.             
    3408.         // Allow a pre-filtering function to sanitize the response
    3409.         // s != null is checked to keep backwards compatibility
    3410.         if( s && s.dataFilter )
    3411.             data = s.dataFilter( data, type );
    3413.         // The filter can actually parse the response
    3414.         if( typeof data === "string" ){
    3416.             // If the type is "script", eval it in global context
    3417.             if ( type == "script" )
    3418.                 jQuery.globalEval( data );
    3420.             // Get the JavaScript object, if JSON is used.
    3421.             if ( type == "json" )
    3422.                 data = eval("(" + data + ")");
    3423.         }
    3424.         
    3425.         return data;
    3426.     },
    3428.     // Serialize an array of form elements or a set of
    3429.     // key/values into a query string
    3430.     param: function( a ) {
    3431.         var s = [ ];
    3433.         function add( key, value ){
    3434.             s[ s.length ] = encodeURIComponent(key) + '=' + encodeURIComponent(value);
    3435.         };
    3437.         // If an array was passed in, assume that it is an array
    3438.         // of form elements
    3439.         if ( jQuery.isArray(a) || a.jquery )
    3440.             // Serialize the form elements
    3441.             jQuery.each( a, function(){
    3442.                 add( this.name, this.value );
    3443.             });
    3445.         // Otherwise, assume that it's an object of key/value pairs
    3446.         else
    3447.             // Serialize the key/values
    3448.             for ( var j in a )
    3449.                 // If the value is an array then the key names need to be repeated
    3450.                 if ( jQuery.isArray(a[j]) )
    3451.                     jQuery.each( a[j], function(){
    3452.                         add( j, this );
    3453.                     });
    3454.                 else
    3455.                     add( j, jQuery.isFunction(a[j]) ? a[j]() : a[j] );
    3457.         // Return the resulting serialization
    3458.         return s.join("&").replace(/%20/g, "+");
    3459.     }
    3461. });
    3462. var elemdisplay = {};
    3464. jQuery.fn.extend({
    3465.     show: function(speed,callback){
    3466.         if ( speed ) {
    3467.             return this.animate({
    3468.                 height: "show",  "show", opacity: "show"
    3469.             }, speed, callback);
    3470.         } else {
    3471.             for ( var i = 0, l = this.length; i < l; i++ ){
    3472.                 var old = jQuery.data(this[i], "olddisplay");
    3473.                 
    3474.                 this[i].style.display = old || "";
    3475.                 
    3476.                 if ( jQuery.css(this[i], "display") === "none" ) {
    3477.                     var tagName = this[i].tagName, display;
    3478.                     
    3479.                     if ( elemdisplay[ tagName ] ) {
    3480.                         display = elemdisplay[ tagName ];
    3481.                     } else {
    3482.                         var elem = jQuery("<" + this[i].tagName + " />").appendTo("body");
    3483.                         
    3484.                         display = elem.css("display");
    3485.                         if ( display === "none" )
    3486.                             display = "block";
    3487.                         
    3488.                         elem.remove();
    3489.                         
    3490.                         elemdisplay[ this[i].tagName ] = display;
    3491.                     }
    3492.                     
    3493.                     this[i].style.display = jQuery.data(this[i], "olddisplay", display);
    3494.                 }
    3495.             }
    3496.             
    3497.             return this;
    3498.         }
    3499.     },
    3501.     hide: function(speed,callback){
    3502.         if ( speed ) {
    3503.             return this.animate({
    3504.                 height: "hide",  "hide", opacity: "hide"
    3505.             }, speed, callback);
    3506.         } else {
    3507.             for ( var i = 0, l = this.length; i < l; i++ ){
    3508.                 var old = jQuery.data(this[i], "olddisplay");
    3509.                 if ( !old && old !== "none" )
    3510.                     jQuery.data(this[i], "olddisplay", jQuery.css(this[i], "display"));
    3511.                 this[i].style.display = "none";
    3512.             }
    3513.             return this;
    3514.         }
    3515.     },
    3517.     // Save the old toggle function
    3518.     _toggle: jQuery.fn.toggle,
    3520.     toggle: function( fn, fn2 ){
    3521.         return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
    3522.             this._toggle.apply( this, arguments ) :
    3523.             fn ?
    3524.                 this.animate({
    3525.                     height: "toggle",  "toggle", opacity: "toggle"
    3526.                 }, fn, fn2) :
    3527.                 this.each(function(){
    3528.                     jQuery(this)[ jQuery(this).is(":hidden") ? "show" : "hide" ]();
    3529.                 });
    3530.     },
    3532.     fadeTo: function(speed,to,callback){
    3533.         return this.animate({opacity: to}, speed, callback);
    3534.     },
    3536.     animate: function( prop, speed, easing, callback ) {
    3537.         var optall = jQuery.speed(speed, easing, callback);
    3539.         return this[ optall.queue === false ? "each" : "queue" ](function(){
    3540.         
    3541.             var opt = jQuery.extend({}, optall), p,
    3542.                 hidden = this.nodeType == 1 && jQuery(this).is(":hidden"),
    3543.                 self = this;
    3544.     
    3545.             for ( p in prop ) {
    3546.                 if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden )
    3547.                     return opt.complete.call(this);
    3549.                 if ( ( p == "height" || p == "width" ) && this.style ) {
    3550.                     // Store display property
    3551.                     opt.display = jQuery.css(this, "display");
    3553.                     // Make sure that nothing sneaks out
    3554.                     opt.overflow = this.style.overflow;
    3555.                 }
    3556.             }
    3558.             if ( opt.overflow != null )
    3559.                 this.style.overflow = "hidden";
    3561.             opt.curAnim = jQuery.extend({}, prop);
    3563.             jQuery.each( prop, function(name, val){
    3564.                 var e = new jQuery.fx( self, opt, name );
    3566.                 if ( /toggle|show|hide/.test(val) )
    3567.                     e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );
    3568.                 else {
    3569.                     var parts = val.toString().match(/^([+-]=)?([/d+-.]+)(.*)$/),
    3570.                         start = e.cur(true) || 0;
    3572.                     if ( parts ) {
    3573.                         var end = parseFloat(parts[2]),
    3574.                             unit = parts[3] || "px";
    3576.                         // We need to compute starting value
    3577.                         if ( unit != "px" ) {
    3578.                             self.style[ name ] = (end || 1) + unit;
    3579.                             start = ((end || 1) / e.cur(true)) * start;
    3580.                             self.style[ name ] = start + unit;
    3581.                         }
    3583.                         // If a +=/-= token was provided, we're doing a relative animation
    3584.                         if ( parts[1] )
    3585.                             end = ((parts[1] == "-=" ? -1 : 1) * end) + start;
    3587.                         e.custom( start, end, unit );
    3588.                     } else
    3589.                         e.custom( start, val, "" );
    3590.                 }
    3591.             });
    3593.             // For JS strict compliance
    3594.             return true;
    3595.         });
    3596.     },
    3598.     queue: function(type, fn){
    3599.         if ( jQuery.isFunction(type) || jQuery.isArray(type) ) {
    3600.             fn = type;
    3601.             type = "fx";
    3602.         }
    3604.         if ( !type || (typeof type === "string" && !fn) )
    3605.             return queue( this[0], type );
    3607.         return this.each(function(){
    3608.             if ( jQuery.isArray(fn) )
    3609.                 queue(this, type, fn);
    3610.             else {
    3611.                 queue(this, type).push( fn );
    3613.                 if ( queue(this, type).length == 1 )
    3614.                     fn.call(this);
    3615.             }
    3616.         });
    3617.     },
    3619.     stop: function(clearQueue, gotoEnd){
    3620.         var timers = jQuery.timers;
    3622.         if (clearQueue)
    3623.             this.queue([]);
    3625.         this.each(function(){
    3626.             // go in reverse order so anything added to the queue during the loop is ignored
    3627.             for ( var i = timers.length - 1; i >= 0; i-- )
    3628.                 if ( timers[i].elem == this ) {
    3629.                     if (gotoEnd)
    3630.                         // force the next step to be the last
    3631.                         timers[i](true);
    3632.                     timers.splice(i, 1);
    3633.                 }
    3634.         });
    3636.         // start the next in the queue if the last step wasn't forced
    3637.         if (!gotoEnd)
    3638.             this.dequeue();
    3640.         return this;
    3641.     }
    3643. });
    3645. // Generate shortcuts for custom animations
    3646. jQuery.each({
    3647.     slideDown: { height:"show" },
    3648.     slideUp: { height: "hide" },
    3649.     slideToggle: { height: "toggle" },
    3650.     fadeIn: { opacity: "show" },
    3651.     fadeOut: { opacity: "hide" }
    3652. }, function( name, props ){
    3653.     jQuery.fn[ name ] = function( speed, callback ){
    3654.         return this.animate( props, speed, callback );
    3655.     };
    3656. });
    3658. var queue = function( elem, type, array ) {
    3659.     if ( elem ){
    3661.         type = type || "fx";
    3663.         var q = jQuery.data( elem, type + "queue" );
    3665.         if ( !q || array )
    3666.             q = jQuery.data( elem, type + "queue", jQuery.makeArray(array) );
    3668.     }
    3669.     return q;
    3670. };
    3672. jQuery.fn.dequeue = function(type){
    3673.     type = type || "fx";
    3675.     return this.each(function(){
    3676.         var q = queue(this, type);
    3678.         q.shift();
    3680.         if ( q.length )
    3681.             q[0].call( this );
    3682.     });
    3683. };
    3685. jQuery.extend({
    3687.     speed: function(speed, easing, fn) {
    3688.         var opt = typeof speed === "object" ? speed : {
    3689.             complete: fn || !fn && easing ||
    3690.                 jQuery.isFunction( speed ) && speed,
    3691.             duration: speed,
    3692.             easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
    3693.         };
    3695.         opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
    3696.             jQuery.fx.speeds[opt.duration] || jQuery.fx.speeds._default;
    3698.         // Queueing
    3699.         opt.old = opt.complete;
    3700.         opt.complete = function(){
    3701.             if ( opt.queue !== false )
    3702.                 jQuery(this).dequeue();
    3703.             if ( jQuery.isFunction( opt.old ) )
    3704.                 opt.old.call( this );
    3705.         };
    3707.         return opt;
    3708.     },
    3710.     easing: {
    3711.         linear: function( p, n, firstNum, diff ) {
    3712.             return firstNum + diff * p;
    3713.         },
    3714.         swing: function( p, n, firstNum, diff ) {
    3715.             return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
    3716.         }
    3717.     },
    3719.     timers: [],
    3720.     timerId: null,
    3722.     fx: function( elem, options, prop ){
    3723.         this.options = options;
    3724.         this.elem = elem;
    3725.         this.prop = prop;
    3727.         if ( !options.orig )
    3728.             options.orig = {};
    3729.     }
    3731. });
    3733. jQuery.fx.prototype = {
    3735.     // Simple function for setting a style value
    3736.     update: function(){
    3737.         if ( this.options.step )
    3738.             this.options.step.call( this.elem, this.now, this );
    3740.         (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
    3742.         // Set display property to block for height/width animations
    3743.         if ( ( this.prop == "height" || this.prop == "width" ) && this.elem.style )
    3744.             this.elem.style.display = "block";
    3745.     },
    3747.     // Get the current size
    3748.     cur: function(force){
    3749.         if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) )
    3750.             return this.elem[ this.prop ];
    3752.         var r = parseFloat(jQuery.css(this.elem, this.prop, force));
    3753.         return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
    3754.     },
    3756.     // Start an animation from one number to another
    3757.     custom: function(from, to, unit){
    3758.         this.startTime = now();
    3759.         this.start = from;
    3760.         this.end = to;
    3761.         this.unit = unit || this.unit || "px";
    3762.         this.now = this.start;
    3763.         this.pos = this.state = 0;
    3765.         var self = this;
    3766.         function t(gotoEnd){
    3767.             return self.step(gotoEnd);
    3768.         }
    3770.         t.elem = this.elem;
    3772.         jQuery.timers.push(t);
    3774.         if ( t() && jQuery.timerId == null ) {
    3775.             jQuery.timerId = setInterval(function(){
    3776.                 var timers = jQuery.timers;
    3778.                 for ( var i = 0; i < timers.length; i++ )
    3779.                     if ( !timers[i]() )
    3780.                         timers.splice(i--, 1);
    3782.                 if ( !timers.length ) {
    3783.                     clearInterval( jQuery.timerId );
    3784.                     jQuery.timerId = null;
    3785.                 }
    3786.             }, 13);
    3787.         }
    3788.     },
    3790.     // Simple 'show' function
    3791.     show: function(){
    3792.         // Remember where we started, so that we can go back to it later
    3793.         this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
    3794.         this.options.show = true;
    3796.         // Begin the animation
    3797.         this.custom(0, this.cur());
    3799.         // Make sure that we start at a small width/height to avoid any
    3800.         // flash of content
    3801.         if ( this.prop == "width" || this.prop == "height" )
    3802.             this.elem.style[this.prop] = "1px";
    3804.         // Start by showing the element
    3805.         jQuery(this.elem).show();
    3806.     },
    3808.     // Simple 'hide' function
    3809.     hide: function(){
    3810.         // Remember where we started, so that we can go back to it later
    3811.         this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
    3812.         this.options.hide = true;
    3814.         // Begin the animation
    3815.         this.custom(this.cur(), 0);
    3816.     },
    3818.     // Each step of an animation
    3819.     step: function(gotoEnd){
    3820.         var t = now();
    3822.         if ( gotoEnd || t >= this.options.duration + this.startTime ) {
    3823.             this.now = this.end;
    3824.             this.pos = this.state = 1;
    3825.             this.update();
    3827.             this.options.curAnim[ this.prop ] = true;
    3829.             var done = true;
    3830.             for ( var i in this.options.curAnim )
    3831.                 if ( this.options.curAnim[i] !== true )
    3832.                     done = false;
    3834.             if ( done ) {
    3835.                 if ( this.options.display != null ) {
    3836.                     // Reset the overflow
    3837.                     this.elem.style.overflow = this.options.overflow;
    3839.                     // Reset the display
    3840.                     this.elem.style.display = this.options.display;
    3841.                     if ( jQuery.css(this.elem, "display") == "none" )
    3842.                         this.elem.style.display = "block";
    3843.                 }
    3845.                 // Hide the element if the "hide" operation was done
    3846.                 if ( this.options.hide )
    3847.                     this.elem.style.display = "none";
    3849.                 // Reset the properties, if the item has been hidden or shown
    3850.                 if ( this.options.hide || this.options.show )
    3851.                     for ( var p in this.options.curAnim )
    3852.                         jQuery.attr(this.elem.style, p, this.options.orig[p]);
    3853.             }
    3855.             if ( done )
    3856.                 // Execute the complete function
    3857.                 this.options.complete.call( this.elem );
    3859.             return false;
    3860.         } else {
    3861.             var n = t - this.startTime;
    3862.             this.state = n / this.options.duration;
    3864.             // Perform the easing function, defaults to swing
    3865.             this.pos = jQuery.easing[this.options.easing || (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
    3866.             this.now = this.start + ((this.end - this.start) * this.pos);
    3868.             // Perform the next step of the animation
    3869.             this.update();
    3870.         }
    3872.         return true;
    3873.     }
    3875. };
    3877. jQuery.extend( jQuery.fx, {
    3878.     speeds:{
    3879.         slow: 600,
    3880.         fast: 200,
    3881.         // Default speed
    3882.         _default: 400
    3883.     },
    3884.     step: {
    3886.         opacity: function(fx){
    3887.             jQuery.attr(fx.elem.style, "opacity", fx.now);
    3888.         },
    3890.         _default: function(fx){
    3891.             if( fx.prop in fx.elem ) 
    3892.                 fx.elem[ fx.prop ] = fx.now;
    3893.             else if( fx.elem.style )
    3894.                 fx.elem.style[ fx.prop ] = fx.now + fx.unit;
    3895.         }
    3896.     }
    3897. });
    3898. if ( document.documentElement["getBoundingClientRect"] )
    3899.     jQuery.fn.offset = function() {
    3900.         if ( !this[0] ) return { top: 0, left: 0 };
    3901.         if ( this[0] === this[0].ownerDocument.body ) return jQuery.offset.bodyOffset( this[0] );
    3902.         var box  = this[0].getBoundingClientRect(), doc = this[0].ownerDocument, body = doc.body, docElem = doc.documentElement,
    3903.             clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0,
    3904.             top  = box.top  + (self.pageYOffset || jQuery.boxModel && docElem.scrollTop  || body.scrollTop ) - clientTop,
    3905.             left = box.left + (self.pageXOffset || jQuery.boxModel && docElem.scrollLeft || body.scrollLeft) - clientLeft;
    3906.         return { top: top, left: left };
    3907.     };
    3908. else 
    3909.     jQuery.fn.offset = function() {
    3910.         if ( !this[0] ) return { top: 0, left: 0 };
    3911.         if ( this[0] === this[0].ownerDocument.body ) return jQuery.offset.bodyOffset( this[0] );
    3912.         jQuery.offset.initialized || jQuery.offset.initialize();
    3914.         var elem = this[0], offsetParent = elem.offsetParent, prevOffsetParent = elem,
    3915.             doc = elem.ownerDocument, computedStyle, docElem = doc.documentElement,
    3916.             body = doc.body, defaultView = doc.defaultView,
    3917.             prevComputedStyle = defaultView.getComputedStyle(elem, null),
    3918.             top = elem.offsetTop, left = elem.offsetLeft;
    3920.         while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
    3921.             computedStyle = defaultView.getComputedStyle(elem, null);
    3922.             top -= elem.scrollTop, left -= elem.scrollLeft;
    3923.             if ( elem === offsetParent ) {
    3924.                 top += elem.offsetTop, left += elem.offsetLeft;
    3925.                 if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && /^t(able|d|h)$/i.test(elem.tagName)) )
    3926.                     top  += parseInt( computedStyle.borderTopWidth,  10) || 0,
    3927.                     left += parseInt( computedStyle.borderLeftWidth, 10) || 0;
    3928.                 prevOffsetParent = offsetParent, offsetParent = elem.offsetParent;
    3929.             }
    3930.             if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" )
    3931.                 top  += parseInt( computedStyle.borderTopWidth,  10) || 0,
    3932.                 left += parseInt( computedStyle.borderLeftWidth, 10) || 0;
    3933.             prevComputedStyle = computedStyle;
    3934.         }
    3936.         if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" )
    3937.             top  += body.offsetTop,
    3938.             left += body.offsetLeft;
    3940.         if ( prevComputedStyle.position === "fixed" )
    3941.             top  += Math.max(docElem.scrollTop, body.scrollTop),
    3942.             left += Math.max(docElem.scrollLeft, body.scrollLeft);
    3944.         return { top: top, left: left };
    3945.     };
    3947. jQuery.offset = {
    3948.     initialize: function() {
    3949.         if ( this.initialized ) return;
    3950.         var body = document.body, container = document.createElement('div'), innerDiv, checkDiv, table, rules, prop, bodyMarginTop = body.style.marginTop,
    3951.             html = '<div style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;1px;height:1px;"><div></div></div><table style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;1px;height:1px;"cellpadding="0"cellspacing="0"><tr><td></td></tr></table>';
    3953.         rules = { position: 'absolute', top: 0, left: 0, margin: 0, border: 0,  '1px', height: '1px', visibility: 'hidden' };
    3954.         for ( prop in rules ) container.style[prop] = rules[prop];
    3956.         container.innerHTML = html;
    3957.         body.insertBefore(container, body.firstChild);
    3958.         innerDiv = container.firstChild, checkDiv = innerDiv.firstChild, td = innerDiv.nextSibling.firstChild.firstChild;
    3960.         this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
    3961.         this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
    3963.         innerDiv.style.overflow = 'hidden', innerDiv.style.position = 'relative';
    3964.         this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
    3966.         body.style.marginTop = '1px';
    3967.         this.doesNotIncludeMarginInBodyOffset = (body.offsetTop === 0);
    3968.         body.style.marginTop = bodyMarginTop;
    3970.         body.removeChild(container);
    3971.         this.initialized = true;
    3972.     },
    3974.     bodyOffset: function(body) {
    3975.         jQuery.offset.initialized || jQuery.offset.initialize();
    3976.         var top = body.offsetTop, left = body.offsetLeft;
    3977.         if ( jQuery.offset.doesNotIncludeMarginInBodyOffset )
    3978.             top  += parseInt( jQuery.curCSS(body, 'marginTop',  true), 10 ) || 0,
    3979.             left += parseInt( jQuery.curCSS(body, 'marginLeft', true), 10 ) || 0;
    3980.         return { top: top, left: left };
    3981.     }
    3982. };
    3985. jQuery.fn.extend({
    3986.     position: function() {
    3987.         var left = 0, top = 0, results;
    3989.         if ( this[0] ) {
    3990.             // Get *real* offsetParent
    3991.             var offsetParent = this.offsetParent(),
    3993.             // Get correct offsets
    3994.             offset       = this.offset(),
    3995.             parentOffset = /^body|html$/i.test(offsetParent[0].tagName) ? { top: 0, left: 0 } : offsetParent.offset();
    3997.             // Subtract element margins
    3998.             // note: when an element has margin: auto the offsetLeft and marginLeft 
    3999.             // are the same in Safari causing offset.left to incorrectly be 0
    4000.             offset.top  -= num( this, 'marginTop'  );
    4001.             offset.left -= num( this, 'marginLeft' );
    4003.             // Add offsetParent borders
    4004.             parentOffset.top  += num( offsetParent, 'borderTopWidth'  );
    4005.             parentOffset.left += num( offsetParent, 'borderLeftWidth' );
    4007.             // Subtract the two offsets
    4008.             results = {
    4009.                 top:  offset.top  - parentOffset.top,
    4010.                 left: offset.left - parentOffset.left
    4011.             };
    4012.         }
    4014.         return results;
    4015.     },
    4017.     offsetParent: function() {
    4018.         var offsetParent = this[0].offsetParent || document.body;
    4019.         while ( offsetParent && (!/^body|html$/i.test(offsetParent.tagName) && jQuery.css(offsetParent, 'position') == 'static') )
    4020.             offsetParent = offsetParent.offsetParent;
    4021.         return jQuery(offsetParent);
    4022.     }
    4023. });
    4026. // Create scrollLeft and scrollTop methods
    4027. jQuery.each( ['Left', 'Top'], function(i, name) {
    4028.     var method = 'scroll' + name;
    4029.     
    4030.     jQuery.fn[ method ] = function(val) {
    4031.         if (!this[0]) return null;
    4033.         return val !== undefined ?
    4035.             // Set the scroll offset
    4036.             this.each(function() {
    4037.                 this == window || this == document ?
    4038.                     window.scrollTo(
    4039.                         !i ? val : jQuery(window).scrollLeft(),
    4040.                          i ? val : jQuery(window).scrollTop()
    4041.                     ) :
    4042.                     this[ method ] = val;
    4043.             }) :
    4045.             // Return the scroll offset
    4046.             this[0] == window || this[0] == document ?
    4047.                 self[ i ? 'pageYOffset' : 'pageXOffset' ] ||
    4048.                     jQuery.boxModel && document.documentElement[ method ] ||
    4049.                     document.body[ method ] :
    4050.                 this[0][ method ];
    4051.     };
    4052. });
    4053. // Create innerHeight, innerWidth, outerHeight and outerWidth methods
    4054. jQuery.each([ "Height", "Width" ], function(i, name){
    4056.     var tl = i ? "Left"  : "Top",  // top or left
    4057.         br = i ? "Right" : "Bottom"; // bottom or right
    4059.     // innerHeight and innerWidth
    4060.     jQuery.fn["inner" + name] = function(){
    4061.         return this[ name.toLowerCase() ]() +
    4062.             num(this, "padding" + tl) +
    4063.             num(this, "padding" + br);
    4064.     };
    4066.     // outerHeight and outerWidth
    4067.     jQuery.fn["outer" + name] = function(margin) {
    4068.         return this["inner" + name]() +
    4069.             num(this, "border" + tl + "Width") +
    4070.             num(this, "border" + br + "Width") +
    4071.             (margin ?
    4072.                 num(this, "margin" + tl) + num(this, "margin" + br) : 0);
    4073.     };
    4074.     
    4075.     var type = name.toLowerCase();
    4077.     jQuery.fn[ type ] = function( size ) {
    4078.         // Get window width or height
    4079.         return this[0] == window ?
    4080.             // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
    4081.             document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] ||
    4082.             document.body[ "client" + name ] :
    4084.             // Get document width or height
    4085.             this[0] == document ?
    4086.                 // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
    4087.                 Math.max(
    4088.                     document.documentElement["client" + name],
    4089.                     document.body["scroll" + name], document.documentElement["scroll" + name],
    4090.                     document.body["offset" + name], document.documentElement["offset" + name]
    4091.                 ) :
    4093.                 // Get or set width or height on the element
    4094.                 size === undefined ?
    4095.                     // Get width or height on the element
    4096.                     (this.length ? jQuery.css( this[0], type ) : null) :
    4098.                     // Set the width or height on the element (default to pixels if value is unitless)
    4099.                     this.css( type, typeof size === "string" ? size : size + "px" );
    4100.     };
    4102. });})();
  • 相关阅读:
    【BZOJ】2100: [Usaco2010 Dec]Apple Delivery（spfa+优化）
    【BZOJ】2101: [Usaco2010 Dec]Treasure Chest 藏宝箱（dp）
    【BZOJ】3404: [Usaco2009 Open]Cow Digit Game又见数字游戏（博弈论）
    【BZOJ】3403: [Usaco2009 Open]Cow Line 直线上的牛（模拟）
    【BZOJ】3402: [Usaco2009 Open]Hide and Seek 捉迷藏（spfa）
    【BZOJ】3400: [Usaco2009 Mar]Cow Frisbee Team 奶牛沙盘队（dp）
    【BZOJ】3399: [Usaco2009 Mar]Sand Castle城堡（贪心）
    【BZOJ】3392: [Usaco2005 Feb]Part Acquisition 交易（spfa）
    【BZOJ】2020: [Usaco2010 Jan]Buying Feed, II （dp）
    【BZOJ】2015: [Usaco2010 Feb]Chocolate Giving（spfa）
  • 原文地址：https://www.cnblogs.com/fengju/p/6173935.html
Copyright © 2011-2022 走看看