jQuery 1.0.2_jquery

/* prevent execution of jQuery if included more then once */
if(typeof window.jQuery == "undefined") {
/*
 * jQuery 1.0.2 - 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-10-09 20:23:18 -0400 (Mon, 09 Oct 2006) $
 * $Rev: 413 $
 */

// Global undefined variable
window.undefined = window.undefined;
jQuery = function(a,c) {

    // Shortcut for document ready (because $(document).each() is silly)
    if ( a && typeof a == "function" && jQuery.fn.ready )
        return jQuery(document).ready(a);

    // Make sure that a selection was provided
    a = a || jQuery.context || 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
    var m = /^[^)[^>]*$/.exec(a);
    if ( m ) a = jQuery.clean( [ m[1] ] );

    // Watch for when an array is passed in
    this.get( a.constructor == Array || a.length && !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);
};

// 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.2",

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

    get: function( num ) {
        // Watch for when an array (of elements) is passed in
        if ( num && num.constructor == Array ) {

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

            return this;
        } else
            return num == undefined ?

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

                // Return just the object
                this[num];
    },
    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             var r = e[j].childNodes;
            for ( var i = 0; 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() {
        return this.get( 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                     if ( jQuery.filter(t[i],[a]).r.length )
                        return a;
            }) ||

            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( t.constructor == 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, t.constructor == 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                 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.get( a );
        } else {
            var old = this.get();
            this.get( a );

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

        return this;
    }
};

jQuery.extend = jQuery.fn.extend = function(obj,prop) {
    if ( !prop ) { prop = obj; obj = this; }
    for ( var i in prop ) obj[i] = prop[i];
    return obj;
};

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 && a.constructor == 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                         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 );
            };
        });

    },
    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                 fn.apply( obj[i], args || [i, obj[i]] );
        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; 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 in d ) {
                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)).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 (!force && elem.style[prop]) {

            ret = elem.style[prop];

        } else if (elem.currentStyle) {

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

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

            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() {
                    ret = document.defaultView.getComputedStyle(this,null).getPropertyValue(prop);
                });

        }

        return ret;
    },

    clean: function(a) {
        var r = [];
        for ( var i = 0; i             if ( a[i].constructor == String ) {
                // trim whitespace, otherwise indexOf won't work as expected
                a[i] = jQuery.trim(a[i]);

                var table = "";

                if ( !a[i].indexOf("                    table = "thead";
                    a[i] = "" + a[i] + "";
                } else if ( !a[i].indexOf("                    table = "tr";
                    a[i] = "" + a[i] + "";
                } else if ( !a[i].indexOf("                    table = "td";
                    a[i] = "" + a[i] + "";
                }

                var div = document.createElement("div");
                div.innerHTML = a[i];

                if ( table ) {
                    div = div.firstChild;
                    if ( table != "thead" ) div = div.firstChild;
                    if ( table == "td" ) div = div.firstChild;
                }

                for ( var j = 0; j                     r.push( div.childNodes[j] );
                } else if ( a[i].jquery || a[i].length && !a[i].nodeType )
                    for ( var k = 0; k                         r.push( a[i][k] );
                else if ( a[i] !== null )
                    r.push(    a[i].nodeType ? a[i] : document.createTextNode(a[i].toString()) );
        }
        return r;
    },

    expr: {
        "": "m[2]== '*'||a.nodeName.toUpperCase()==m[2].toUpperCase()",
        "#": "a.getAttribute('id')&&a.getAttribute('id')==m[2]",
        ":": {
            // Position Checks
            lt: "i            gt: "i>m[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: "(a.innerText||a.innerHTML).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: "a.nodeName.toLowerCase().match(/input|select|textarea|button/)"
        },
        ".": "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 r = [];
            var s = jQuery.sibling(a);
            if ( s.n > 0 )
                for ( var i = s.n; i                     r.push( s[i] );
            return r;
        }
    ],
    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 || jQuery.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                 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                             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;
                t = jQuery.trim(val.t);
            }
        }

        if ( ret && ret[0] == context ) ret.shift();
        done = jQuery.merge( done, ret );

        return done;
    },

    getAll: function(o,r) {
        r = r || [];
        var s = o.childNodes;
        for ( var i = 0; i             if ( s[i].nodeType == 1 ) {
                r.push( s[i] );
                jQuery.getAll( s[i], r );
            }
        return r;
    },

    attr: function(elem, name, value){
        var fix = {
            "for": "htmlFor",
            "class": "className",
            "float": "cssFloat",
            innerHTML: "innerHTML",
            className: "className",