代码如下：

/* prevent execution of jQuery if included more then once */
if(typeof window.jQuery == "undefined") {
/*
 * jQuery 1.0.4 - New Wave Javascript
 *
 * Copyright (c) 2006 John Resig (jquery.com)
 * Dual licensed under the MIT (MIT-LICENSE.txt)
 * and GPL (GPL-LICENSE.txt) licenses.
 *
 * $Date: 2006-12-12 15:33:10 -0500 (Tue, 12 Dec 2006) $
 * $Rev: 696 $
 */

// Global undefined variable
window.undefined = window.undefined;

var jQuery = function(a,c) {

    // Shortcut for document ready
    if ( a && typeof a == "function" && jQuery.fn.ready && !a.nodeType && a[0] == undefined ) // Safari reports typeof on DOM NodeLists as a function
        return jQuery(document).ready(a);

    // Make sure that a selection was provided
    a = a || document;

    // Watch for when a jQuery object is passed as the selector
    if ( a.jquery )
        return jQuery( jQuery.merge( a, [] ) );

    // Watch for when a jQuery object is passed at the context
    if ( c && c.jquery )
        return jQuery( c ).find(a);

    // If the context is global, return a new object
    if ( window == this )
        return new jQuery(a,c);

    // Handle HTML strings
    if ( typeof a  == "string" ) {
        var m = /^[^]*(.+)[^]*$/.exec(a);
        if ( m ) a = jQuery.clean( [ m[1] ] );
    }

    // Watch for when an array is passed in
    this.set( a.constructor == Array || a.length && a != window && !a.nodeType && a[0] != undefined && a[0].nodeType ?
        // Assume that it is an array of DOM Elements
        jQuery.merge( a, [] ) :

        // Find the matching elements and save them for later
        jQuery.find( a, c ) );

    // See if an extra function was provided
    var fn = arguments[ arguments.length - 1 ];

    // If so, execute it in context
    if ( fn && typeof fn == "function" )
        this.each(fn);

    return this;
};

// Map over the $ in case of overwrite
if ( typeof $ != "undefined" )
    jQuery._$ = $;

// Map the jQuery namespace to the '$' one
var $ = jQuery;



jQuery.fn = jQuery.prototype = {

    jquery: "1.0.4",


    size: function() {
        return this.length;
    },


    get: function( num ) {
        return num == undefined ?

            // Return a 'clean' array
            jQuery.merge( this, [] ) :

            // Return just the object
            this[num];
    },

    set: function( array ) {
        // Use a tricky hack to make the jQuery object
        // look and feel like an array
        this.length = 0;
        [].push.apply( this, array );
        return this;
    },

    each: function( fn, args ) {
        return jQuery.each( this, fn, args );
    },

    index: function( obj ) {
        var pos = -1;
        this.each(function(i){
            if ( this == obj ) pos = i;
        });
        return pos;
    },


    attr: function( key, value, type ) {
        // Check to see if we're setting style values
        return key.constructor != String || value != undefined ?
            this.each(function(){
                // See if we're setting a hash of styles
                if ( value == undefined )
                    // Set all the styles
                    for ( var prop in key )
                        jQuery.attr(
                            type ? this.style : this,
                            prop, key[prop]
                        );

                // See if we're setting a single key/value style
                else
                    jQuery.attr(
                        type ? this.style : this,
                        key, value
                    );
            }) :

            // Look for the case where we're accessing a style value
            jQuery[ type || "attr" ]( this[0], key );
    },


    css: function( key, value ) {
        return this.attr( key, value, "curCSS" );
    },

    text: function(e) {
        e = e || this;
        var t = "";
        for ( var j = 0; j  e.length; j++ ) {
            var r = e[j].childNodes;
            for ( var i = 0; i  r.length; i++ )
                if ( r[i].nodeType != 8 )
                    t += r[i].nodeType != 1 ?
                        r[i].nodeValue : jQuery.fn.text([ r[i] ]);
        }
        return t;
    },


    wrap: function() {
        // The elements to wrap the target around
        var a = jQuery.clean(arguments);

        // Wrap each of the matched elements individually
        return this.each(function(){
            // Clone the structure that we're using to wrap
            var b = a[0].cloneNode(true);

            // Insert it before the element to be wrapped
            this.parentNode.insertBefore( b, this );

            // Find the deepest point in the wrap structure
            while ( b.firstChild )
                b = b.firstChild;

            // Move the matched element to within the wrap structure
            b.appendChild( this );
        });
    },


    append: function() {
        return this.domManip(arguments, true, 1, function(a){
            this.appendChild( a );
        });
    },


    prepend: function() {
        return this.domManip(arguments, true, -1, function(a){
            this.insertBefore( a, this.firstChild );
        });
    },


    before: function() {
        return this.domManip(arguments, false, 1, function(a){
            this.parentNode.insertBefore( a, this );
        });
    },


    after: function() {
        return this.domManip(arguments, false, -1, function(a){
            this.parentNode.insertBefore( a, this.nextSibling );
        });
    },

    end: function() {
        if( !(this.stack && this.stack.length) )
            return this;
        return this.set( this.stack.pop() );
    },

    find: function(t) {
        return this.pushStack( jQuery.map( this, function(a){
            return jQuery.find(t,a);
        }), arguments );
    },

    clone: function(deep) {
        return this.pushStack( jQuery.map( this, function(a){
            return a.cloneNode( deep != undefined ? deep : true );
        }), arguments );
    },


    filter: function(t) {
        return this.pushStack(
            t.constructor == Array &&
            jQuery.map(this,function(a){
                for ( var i = 0; i  t.length; i++ )
                    if ( jQuery.filter(t[i],[a]).r.length )
                        return a;
                return null;
            }) ||

            t.constructor == Boolean &&
            ( t ? this.get() : [] ) ||

            typeof t == "function" &&
            jQuery.grep( this, t ) ||

            jQuery.filter(t,this).r, arguments );
    },


    not: function(t) {
        return this.pushStack( typeof t == "string" ?
            jQuery.filter(t,this,false).r :
            jQuery.grep(this,function(a){ return a != t; }), arguments );
    },


    add: function(t) {
        return this.pushStack( jQuery.merge( this, typeof t == "string" ?
            jQuery.find(t) : t.constructor == Array ? t : [t] ), arguments );
    },

    is: function(expr) {
        return expr ? jQuery.filter(expr,this).r.length  0 : false;
    },

    domManip: function(args, table, dir, fn){
        var clone = this.size()  1;
        var a = jQuery.clean(args);

        return this.each(function(){
            var obj = this;

            if ( table && this.nodeName.toUpperCase() == "TABLE" && a[0].nodeName.toUpperCase() != "THEAD" ) {
                var tbody = this.getElementsByTagName("tbody");

                if ( !tbody.length ) {
                    obj = document.createElement("tbody");
                    this.appendChild( obj );
                } else
                    obj = tbody[0];
            }

            for ( var i = ( dir  0 ? a.length - 1 : 0 );
                i != ( dir  0 ? dir : a.length ); i += dir ) {
                    fn.apply( obj, [ clone ? a[i].cloneNode(true) : a[i] ] );
            }
        });
    },

    pushStack: function(a,args) {
        var fn = args && args[args.length-1];
        var fn2 = args && args[args.length-2];

        if ( fn && fn.constructor != Function ) fn = null;
        if ( fn2 && fn2.constructor != Function ) fn2 = null;

        if ( !fn ) {
            if ( !this.stack ) this.stack = [];
            this.stack.push( this.get() );
            this.set( a );
        } else {
            var old = this.get();
            this.set( a );

            if ( fn2 && a.length || !fn2 )
                this.each( fn2 || fn ).set( old );
            else
                this.set( old ).each( fn );
        }

        return this;
    }
};


jQuery.extend = jQuery.fn.extend = function() {
    // copy reference to target object
    var target = arguments[0],
        a = 1;

    // extend jQuery itself if only one argument is passed
    if ( arguments.length == 1 ) {
        target = this;
        a = 0;
    }
    var prop;
    while (prop = arguments[a++])
        // Extend the base object
        for ( var i in prop ) target[i] = prop[i];

    // Return the modified object
    return target;
};

jQuery.extend({

    init: function(){
        jQuery.initDone = true;

        jQuery.each( jQuery.macros.axis, function(i,n){
            jQuery.fn[ i ] = function(a) {
                var ret = jQuery.map(this,n);
                if ( a && typeof a == "string" )
                    ret = jQuery.filter(a,ret).r;
                return this.pushStack( ret, arguments );
            };
        });

        jQuery.each( jQuery.macros.to, function(i,n){
            jQuery.fn[ i ] = function(){
                var a = arguments;
                return this.each(function(){
                    for ( var j = 0; j  a.length; j++ )
                        jQuery(a[j])[n]( this );
                });
            };
        });

        jQuery.each( jQuery.macros.each, function(i,n){
            jQuery.fn[ i ] = function() {
                return this.each( n, arguments );
            };
        });

        jQuery.each( jQuery.macros.filter, function(i,n){
            jQuery.fn[ n ] = function(num,fn) {
                return this.filter( ":" + n + "(" + num + ")", fn );
            };
        });

        jQuery.each( jQuery.macros.attr, function(i,n){
            n = n || i;
            jQuery.fn[ i ] = function(h) {
                return h == undefined ?
                    this.length ? this[0][n] : null :
                    this.attr( n, h );
            };
        });

        jQuery.each( jQuery.macros.css, function(i,n){
            jQuery.fn[ n ] = function(h) {
                return h == undefined ?
                    ( this.length ? jQuery.css( this[0], n ) : null ) :
                    this.css( n, h );
            };
        });

    },

    // args is for internal usage only
    each: function( obj, fn, args ) {
        if ( obj.length == undefined )
            for ( var i in obj )
                fn.apply( obj[i], args || [i, obj[i]] );
        else
            for ( var i = 0; i  obj.length; i++ )
                if ( fn.apply( obj[i], args || [i, obj[i]] ) === false ) break;
        return obj;
    },

    className: {
        add: function(o,c){
            if (jQuery.className.has(o,c)) return;
            o.className += ( o.className ? " " : "" ) + c;
        },
        remove: function(o,c){
            if( !c ) {
                o.className = "";
            } else {
                var classes = o.className.split(" ");
                for(var i=0; iclasses.length; i++) {
                    if(classes[i] == c) {
                        classes.splice(i, 1);
                        break;
                    }
                }
                o.className = classes.join(' ');
            }
        },
        has: function(e,a) {
            if ( e.className != undefined )
                e = e.className;
            return new RegExp("(^|\s)" + a + "(\s|$)").test(e);
        }
    },

    swap: function(e,o,f) {
        for ( var i in o ) {
            e.style["old"+i] = e.style[i];
            e.style[i] = o[i];
        }
        f.apply( e, [] );
        for ( var i in o )
            e.style[i] = e.style["old"+i];
    },

    css: function(e,p) {
        if ( p == "height" || p == "width" ) {
            var old = {}, oHeight, oWidth, d = ["Top","Bottom","Right","Left"];

            for ( var i=0; id.length; i++ ) {
                old["padding" + d[i]] = 0;
                old["border" + d[i] + "Width"] = 0;
            }

            jQuery.swap( e, old, function() {
                if (jQuery.css(e,"display") != "none") {
                    oHeight = e.offsetHeight;
                    oWidth = e.offsetWidth;
                } else {
                    e = jQuery(e.cloneNode(true))
                        .find(":radio").removeAttr("checked").end()
                        .css({
                            visibility: "hidden", position: "absolute", display: "block", right: "0", left: "0"
                        }).appendTo(e.parentNode)[0];

                    var parPos = jQuery.css(e.parentNode,"position");
                    if ( parPos == "" || parPos == "static" )
                        e.parentNode.style.position = "relative";

                    oHeight = e.clientHeight;
                    oWidth = e.clientWidth;

                    if ( parPos == "" || parPos == "static" )
                        e.parentNode.style.position = "static";

                    e.parentNode.removeChild(e);
                }
            });

            return p == "height" ? oHeight : oWidth;
        }

        return jQuery.curCSS( e, p );
    },

    curCSS: function(elem, prop, force) {
        var ret;

        if (prop == 'opacity' && jQuery.browser.msie)
            return jQuery.attr(elem.style, 'opacity');

        if (prop == "float" || prop == "cssFloat")
            prop = jQuery.browser.msie ? "styleFloat" : "cssFloat";

        if (!force && elem.style[prop]) {

            ret = elem.style[prop];

        } else if (document.defaultView && document.defaultView.getComputedStyle) {

            if (prop == "cssFloat" || prop == "styleFloat")
                prop = "float";

            prop = prop.replace(/([A-Z])/g,"-$1").toLowerCase();
            var cur = document.defaultView.getComputedStyle(elem, null);

            if ( cur )
                ret = cur.getPropertyValue(prop);
            else if ( prop == 'display' )
                ret = 'none';
            else
                jQuery.swap(elem, { display: 'block' }, function() {
                    var c = document.defaultView.getComputedStyle(this, '');
                    ret = c && c.getPropertyValue(prop) || '';
                });

        } else if (elem.currentStyle) {

            var newProp = prop.replace(/-(w)/g,function(m,c){return c.toUpperCase();});
            ret = elem.currentStyle[prop] || elem.currentStyle[newProp];

        }

        return ret;
    },

    clean: function(a) {
        var r = [];
        for ( var i = 0; i  a.length; i++ ) {
            var arg = a[i];
            if ( typeof arg == "string" ) { // Convert html string into DOM nodes
                // Trim whitespace, otherwise indexOf won't work as expected
                var s = jQuery.trim(arg), div = document.createElement("div"), wrap = [0,"",""];

                if ( !s.indexOf("opt") ) // option or optgroup
                    wrap = [1, "select", "/select"];
                else if ( !s.indexOf("thead") || !s.indexOf("tbody") )
                    wrap = [1, "table", "/table"];
                else if ( !s.indexOf("tr") )
                    wrap = [2, "table", "/table"];    // tbody auto-inserted
                else if ( !s.indexOf("td") || !s.indexOf("th") )
                    wrap = [3, "tabletbodytr", "/tr/tbody/table"];

                // Go to html and back, then peel off extra wrappers
                div.innerHTML = wrap[1] + s + wrap[2];
                while ( wrap[0]-- ) div = div.firstChild;
                arg = div.childNodes;
            } 

            
            if ( arg.length != undefined && ( (jQuery.browser.safari && typeof arg == 'function') || !arg.nodeType ) ) // Safari reports typeof on a DOM NodeList to be a function
                for ( var n = 0; n  arg.length; n++ ) // Handles Array, jQuery, DOM NodeList collections
                    r.push(arg[n]);
            else
                r.push(    arg.nodeType ? arg : document.createTextNode(arg.toString()) );
        }

        return r;
    },

    expr: {
        "": "m[2]== '*'||a.nodeName.toUpperCase()==m[2].toUpperCase()",
        "#": "a.getAttribute('id')&&a.getAttribute('id')==m[2]",
        ":": {
            // Position Checks
            lt: "im[3]-0",
            gt: "im[3]-0",
            nth: "m[3]-0==i",
            eq: "m[3]-0==i",
            first: "i==0",
            last: "i==r.length-1",
            even: "i%2==0",
            odd: "i%2",

            // Child Checks
            "nth-child": "jQuery.sibling(a,m[3]).cur",
            "first-child": "jQuery.sibling(a,0).cur",
            "last-child": "jQuery.sibling(a,0).last",
            "only-child": "jQuery.sibling(a).length==1",

            // Parent Checks
            parent: "a.childNodes.length",
            empty: "!a.childNodes.length",

            // Text Check
            contains: "jQuery.fn.text.apply([a]).indexOf(m[3])=0",

            // Visibility
            visible: "a.type!='hidden'&&jQuery.css(a,'display')!='none'&&jQuery.css(a,'visibility')!='hidden'",
            hidden: "a.type=='hidden'||jQuery.css(a,'display')=='none'||jQuery.css(a,'visibility')=='hidden'",

            // Form attributes
            enabled: "!a.disabled",
            disabled: "a.disabled",
            checked: "a.checked",
            selected: "a.selected || jQuery.attr(a, 'selected')",

            // Form elements
            text: "a.type=='text'",
            radio: "a.type=='radio'",
            checkbox: "a.type=='checkbox'",
            file: "a.type=='file'",
            password: "a.type=='password'",
            submit: "a.type=='submit'",
            image: "a.type=='image'",
            reset: "a.type=='reset'",
            button: "a.type=='button'",
            input: "/input|select|textarea|button/i.test(a.nodeName)"
        },
        ".": "jQuery.className.has(a,m[2])",
        "@": {
            "=": "z==m[4]",
            "!=": "z!=m[4]",
            "^=": "z && !z.indexOf(m[4])",
            "$=": "z && z.substr(z.length - m[4].length,m[4].length)==m[4]",
            "*=": "z && z.indexOf(m[4])=0",
            "": "z"
        },
        "[": "jQuery.find(m[2],a).length"
    },

    token: [
        "\.\.|/\.\.", "a.parentNode",
        "|/", "jQuery.sibling(a.firstChild)",
        "\+", "jQuery.sibling(a).next",
        "~", function(a){
            var s = jQuery.sibling(a);
            return s.n = 0 ? s.slice(s.n+1) : [];
        }
    ],

    find: function( t, context ) {
        // Make sure that the context is a DOM Element
        if ( context && context.nodeType == undefined )
            context = null;

        // Set the correct context (if none is provided)
        context = context || document;

        if ( t.constructor != String ) return [t];

        if ( !t.indexOf("//") ) {
            context = context.documentElement;
            t = t.substr(2,t.length);
        } else if ( !t.indexOf("/") ) {
            context = context.documentElement;
            t = t.substr(1,t.length);
            // FIX Assume the root element is right :(
            if ( t.indexOf("/") = 1 )
                t = t.substr(t.indexOf("/"),t.length);
        }

        var ret = [context];
        var done = [];
        var last = null;

        while ( t.length  0 && last != t ) {
            var r = [];
            last = t;

            t = jQuery.trim(t).replace( /^///i, "" );

            var foundToken = false;

            for ( var i = 0; i  jQuery.token.length; i += 2 ) {
                if ( foundToken ) continue;

                var re = new RegExp("^(" + jQuery.token[i] + ")");
                var m = re.exec(t);

                if ( m ) {
                    r = ret = jQuery.map( ret, jQuery.token[i+1] );
                    t = jQuery.trim( t.replace( re, "" ) );
                    foundToken = true;
                }
            }

            if ( !foundToken ) {
                if ( !t.indexOf(",") || !t.indexOf("|") ) {
                    if ( ret[0] == context ) ret.shift();
                    done = jQuery.merge( done, ret );
                    r = ret = [context];
                    t = " " + t.substr(1,t.length);
                } else {
                    var re2 = /^([#.]?)([a-z0-9\*_-]*)/i;
                    var m = re2.exec(t);

                    if ( m[1] == "#" ) {
                        // Ummm, should make this work in all XML docs
                        var oid = document.getElementById(m[2]);
                        r = ret = oid ? [oid] : [];
                        t = t.replace( re2, "" );
                    } else {
                        if ( !m[2] || m[1] == "." ) m[2] = "*";

                        for ( var i = 0; i  ret.length; i++ )
                            r = jQuery.merge( r,
                                m[2] == "*" ?
                                    jQuery.getAll(ret[i]) :
                                    ret[i].getElementsByTagName(m[2])
                            );
                    }
                }

            }

            if ( t ) {
                var val = jQuery.filter(t,r);
                ret = r = val.r