Хранилища Subversion ant

/*!

 * jQuery JavaScript Library v1.3.3pre

 * http://jquery.com/

 *

 * Copyright (c) 2009 John Resig

 * Dual licensed under the MIT and GPL licenses.

 * http://docs.jquery.com/License

 *

 * Date: 2009-05-12 22:43:51 +0700 (Втр, 12 Май 2009)

 * Revision: 6348

 */

(function(){

// Will speed up references to window, and allows munging its name.

var window = this,

        // Will speed up references to undefined, and allows munging its name.

        undefined,

        // Map over jQuery in case of overwrite

        _jQuery = window.jQuery,

        // Map over the $ in case of overwrite

        _$ = window.$,

        // Define a local copy of jQuery

        jQuery,

        // A central reference to the root jQuery(document)

        rootjQuery,

        jQuery = window.jQuery = window.$ = function( selector, context ) {

                // The jQuery object is actually just the init constructor 'enhanced'

                return arguments.length === 0 ?

                        rootjQuery :

                        new jQuery.fn.init( selector, context );

        },

        // A simple way to check for HTML strings or ID strings

        // (both of which we optimize for)

        quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/,

        // Is it a simple selector

        isSimple = /^.[^:#\[\.,]*$/,

        // Keep a UserAgent string for use with jQuery.browser

        userAgent = navigator.userAgent.toLowerCase(),

        // Save a reference to the core toString method

        toString = Object.prototype.toString;

jQuery.fn = jQuery.prototype = {

        init: function( selector, context ) {

                var match, elem, ret;

                // Handle $(""), $(null), or $(undefined)

                if ( !selector ) {

                        this.length = 0;

                        return this;

                }

                // Handle $(DOMElement)

                if ( selector.nodeType ) {

                        this[0] = selector;

                        this.length = 1;

                        this.context = selector;

                        return this;

                }

                // Handle HTML strings

                if ( typeof selector === "string" ) {

                        // Are we dealing with HTML string or an ID?

                        match = quickExpr.exec( selector );

                        // Verify a match, and that no context was specified for #id

                        if ( match && (match[1] || !context) ) {

                                // HANDLE: $(html) -> $(array)

                                if ( match[1] ) {

                                        selector = jQuery.clean( [ match[1] ], context );

                                // HANDLE: $("#id")

                                } else {

                                        elem = document.getElementById( match[3] );

                                        // Handle the case where IE and Opera return items

                                        // by name instead of ID

                                        if ( elem && elem.id !== match[3] ) {

                                                return rootjQuery.find( selector );

                                        }

                                        // Otherwise, we inject the element directly into the jQuery object

                                        ret = jQuery( elem || null );

                                        ret.context = document;

                                        ret.selector = selector;

                                        return ret;

                                }

                        // HANDLE: $(expr, $(...))

                        } else if ( !context || context.jquery ) {

                                return (context || rootjQuery).find( selector );

                        // HANDLE: $(expr, context)

                        // (which is just equivalent to: $(context).find(expr)

                        } else {

                                return jQuery( context ).find( selector );

                        }

                // HANDLE: $(function)

                // Shortcut for document ready

                } else if ( jQuery.isFunction( selector ) ) {

                        return rootjQuery.ready( selector );

                }

                // Make sure that old selector state is passed along

                if ( selector.selector && selector.context ) {

                        this.selector = selector.selector;

                        this.context = selector.context;

                }

                return this.setArray(jQuery.isArray( selector ) ?

                        selector :

                        jQuery.makeArray(selector));

        },

        // Start with an empty selector

        selector: "",

        // The current version of jQuery being used

        jquery: "1.3.3pre",

        // The number of elements contained in the matched element set

        size: function() {

                return this.length;

        },

        // Get the Nth element in the matched element set OR

        // Get the whole matched element set as a clean array

        get: function( num ) {

                return num == null ?

                        // Return a 'clean' array

                        Array.prototype.slice.call( this ) :

                        // Return just the object

                        this[ num ];

        },

        // Take an array of elements and push it onto the stack

        // (returning the new matched element set)

        pushStack: function( elems, name, selector ) {

                // Build a new jQuery matched element set

                var ret = jQuery( elems || null );

                // Add the old object onto the stack (as a reference)

                ret.prevObject = this;

                ret.context = this.context;

                if ( name === "find" ) {

                        ret.selector = this.selector + (this.selector ? " " : "") + selector;

                } else if ( name ) {

                        ret.selector = this.selector + "." + name + "(" + selector + ")";

                }

                // Return the newly-formed element set

                return ret;

        },

        // Force the current matched set of elements to become

        // the specified array of elements (destroying the stack in the process)

        // You should use pushStack() in order to do this, but maintain the stack

        setArray: function( elems ) {

                // Resetting the length to 0, then using the native Array push

                // is a super-fast way to populate an object with array-like properties

                this.length = 0;

                Array.prototype.push.apply( this, elems );

                return this;

        },

        // Execute a callback for every element in the matched set.

        // (You can seed the arguments with an array of args, but this is

        // only used internally.)

        each: function( callback, args ) {

                return jQuery.each( this, callback, args );

        },

        // Determine the position of an element within

        // the matched set of elements

        index: function( elem ) {

                if ( !elem || typeof elem === "string" ) {

                        return jQuery.inArray( this[0],

                                // If it receives a string, the selector is used

                                // If it receives nothing, the siblings are used

                                elem ? jQuery( elem ) : this.parent().children() );

                }

                // Locate the position of the desired element

                return jQuery.inArray(

                        // If it receives a jQuery object, the first element is used

                        elem.jquery ? elem[0] : elem, this );

        },

        is: function( selector ) {

                return !!selector && jQuery.multiFilter( selector, this ).length > 0;

        },

        // For internal use only.

        // Behaves like an Array's method, not like a jQuery method.

        push: [].push,

        sort: [].sort,

        splice: [].splice

};

// Give the init function the jQuery prototype for later instantiation

jQuery.fn.init.prototype = jQuery.fn;

jQuery.extend = jQuery.fn.extend = function() {

        // copy reference to target object

        var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options, name, src, copy;

        // Handle a deep copy situation

        if ( typeof target === "boolean" ) {

                deep = target;

                target = arguments[1] || {};

                // skip the boolean and the target

                i = 2;

        }

        // Handle case when target is a string or something (possible in deep copy)

        if ( typeof target !== "object" && !jQuery.isFunction(target) ) {

                target = {};

        }

        // extend jQuery itself if only one argument is passed

        if ( length === i ) {

                target = this;

                --i;

        }

        for ( ; i < length; i++ ) {

                // Only deal with non-null/undefined values

                if ( (options = arguments[ i ]) != null ) {

                        // Extend the base object

                        for ( name in options ) {

                                src = target[ name ];

                                copy = options[ name ];

                                // Prevent never-ending loop

                                if ( target === copy ) {

                                        continue;

                                }

                                // Recurse if we're merging object values

                                if ( deep && copy && typeof copy === "object" && !copy.nodeType ) {

                                        target[ name ] = jQuery.extend( deep,

                                                // Never move original objects, clone them

                                                src || ( copy.length != null ? [ ] : { } ), copy );

                                // Don't bring in undefined values

                                } else if ( copy !== undefined ) {

                                        target[ name ] = copy;

                                }

                        }

                }

        }

        // Return the modified object

        return target;

};

jQuery.extend({

        noConflict: function( deep ) {

                window.$ = _$;

                if ( deep ) {

                        window.jQuery = _jQuery;

                }

                return jQuery;

        },

        // See test/unit/core.js for details concerning isFunction.

        // Since version 1.3, DOM methods and functions like alert

        // aren't supported. They return false on IE (#2968).

        isFunction: function( obj ) {

                return toString.call(obj) === "[object Function]";

        },

        isArray: function( obj ) {

                return toString.call(obj) === "[object Array]";

        },

        // check if an element is in a (or is an) XML document

        isXMLDoc: function( elem ) {

                return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||

                        !!elem.ownerDocument && elem.ownerDocument.documentElement.nodeName !== "HTML";

        },

        // Evalulates a script in a global context

        globalEval: function( data ) {

                if ( data && /\S/.test(data) ) {

                        // Inspired by code by Andrea Giammarchi

                        // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html

                        var head = document.getElementsByTagName("head")[0] || document.documentElement,

                                script = document.createElement("script");

                        script.type = "text/javascript";

                        if ( jQuery.support.scriptEval ) {

                                script.appendChild( document.createTextNode( data ) );

                        } else {

                                script.text = data;

                        }

                        // Use insertBefore instead of appendChild  to circumvent an IE6 bug.

                        // This arises when a base node is used (#2709).

                        head.insertBefore( script, head.firstChild );

                        head.removeChild( script );

                }

        },

        nodeName: function( elem, name ) {

                return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();

        },

        // args is for internal usage only

        each: function( object, callback, args ) {

                var name, i = 0, length = object.length;

                if ( args ) {

                        if ( length === undefined ) {

                                for ( name in object ) {

                                        if ( callback.apply( object[ name ], args ) === false ) {

                                                break;

                                        }

                                }

                        } else {

                                for ( ; i < length; ) {

                                        if ( callback.apply( object[ i++ ], args ) === false ) {

                                                break;

                                        }

                                }

                        }

                // A special, fast, case for the most common use of each

                } else {

                        if ( length === undefined ) {

                                for ( name in object ) {

                                        if ( callback.call( object[ name ], name, object[ name ] ) === false ) {

                                                break;

                                        }

                                }

                        } else {

                                for ( var value = object[0];

                                        i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {}

                        }

                }

                return object;

        },

        trim: function( text ) {

                return (text || "").replace( /^\s+|\s+$/g, "" );

        },

        makeArray: function( array ) {

                var ret = [], i;

                if ( array != null ) {

                        i = array.length;

                        // The window, strings (and functions) also have 'length'

                        if ( i == null || typeof array === "string" || jQuery.isFunction(array) || array.setInterval ) {

                                ret[0] = array;

                        } else {

                                while ( i ) {

                                        ret[--i] = array[i];

                                }

                        }

                }

                return ret;

        },

        inArray: function( elem, array ) {

                for ( var i = 0, length = array.length; i < length; i++ ) {

                        if ( array[ i ] === elem ) {

                                return i;

                        }

                }

                return -1;

        },

        merge: function( first, second ) {

                // We have to loop this way because IE & Opera overwrite the length

                // expando of getElementsByTagName

                var i = 0, elem, pos = first.length;

                // Also, we need to make sure that the correct elements are being returned

                // (IE returns comment nodes in a '*' query)

                if ( !jQuery.support.getAll ) {

                        while ( (elem = second[ i++ ]) != null ) {

                                if ( elem.nodeType !== 8 ) {

                                        first[ pos++ ] = elem;

                                }

                        }

                } else {

                        while ( (elem = second[ i++ ]) != null ) {

                                first[ pos++ ] = elem;

                        }

                }

                return first;

        },

        unique: function( array ) {

                var ret = [], done = {}, id;

                try {

                        for ( var i = 0, length = array.length; i < length; i++ ) {

                                id = jQuery.data( array[ i ] );

                                if ( !done[ id ] ) {

                                        done[ id ] = true;

                                        ret.push( array[ i ] );

                                }

                        }

                } catch( e ) {

                        ret = array;

                }

                return ret;

        },

        grep: function( elems, callback, inv ) {

                var ret = [];

                // Go through the array, only saving the items

                // that pass the validator function

                for ( var i = 0, length = elems.length; i < length; i++ ) {

                        if ( !inv !== !callback( elems[ i ], i ) ) {

                                ret.push( elems[ i ] );

                        }

                }

                return ret;

        },

        map: function( elems, callback ) {

                var ret = [], value;

                // Go through the array, translating each of the items to their

                // new value (or values).

                for ( var i = 0, length = elems.length; i < length; i++ ) {

                        value = callback( elems[ i ], i );

                        if ( value != null ) {

                                ret[ ret.length ] = value;

                        }

                }

                return ret.concat.apply( [], ret );

        },

        // Use of jQuery.browser is deprecated.

        // It's included for backwards compatibility and plugins,

        // although they should work to migrate away.

        browser: {

                version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [0,'0'])[1],

                safari: /webkit/.test( userAgent ),

                opera: /opera/.test( userAgent ),

                msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),

                mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )

        }

});

// All jQuery objects should point back to these

rootjQuery = jQuery(document);

function evalScript( i, elem ) {

        if ( elem.src ) {

                jQuery.ajax({

                        url: elem.src,

                        async: false,

                        dataType: "script"

                });

        } else {

                jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );

        }

        if ( elem.parentNode ) {

                elem.parentNode.removeChild( elem );

        }

}

function now() {

        return (new Date).getTime();

}

var expando = "jQuery" + now(), uuid = 0, windowData = {};

jQuery.extend({

        cache: {},

        data: function( elem, name, data ) {

                elem = elem == window ?

                        windowData :

                        elem;

                var id = elem[ expando ];

                // Compute a unique ID for the element

                if ( !id )

                        id = elem[ expando ] = ++uuid;

                // Only generate the data cache if we're

                // trying to access or manipulate it

                if ( name && !jQuery.cache[ id ] )

                        jQuery.cache[ id ] = {};

                // Prevent overriding the named cache with undefined values

                if ( data !== undefined )

                        jQuery.cache[ id ][ name ] = data;

                // Return the named cache data, or the ID for the element

                return name ?

                        jQuery.cache[ id ][ name ] :

                        id;

        },

        removeData: function( elem, name ) {

                elem = elem == window ?

                        windowData :

                        elem;

                var id = elem[ expando ];

                // If we want to remove a specific section of the element's data

                if ( name ) {

                        if ( jQuery.cache[ id ] ) {

                                // Remove the section of cache data

                                delete jQuery.cache[ id ][ name ];

                                // If we've removed all the data, remove the element's cache

                                name = "";

                                for ( name in jQuery.cache[ id ] )

                                        break;

                                if ( !name )

                                        jQuery.removeData( elem );

                        }

                // Otherwise, we want to remove all of the element's data

                } else {

                        // Clean up the element expando

                        try {

                                delete elem[ expando ];

                        } catch(e){

                                // IE has trouble directly removing the expando

                                // but it's ok with using removeAttribute

                                if ( elem.removeAttribute )

                                        elem.removeAttribute( expando );

                        }

                        // Completely remove the data cache

                        delete jQuery.cache[ id ];

                }

        },

        queue: function( elem, type, data ) {

                if ( elem ){

                        type = (type || "fx") + "queue";

                        var q = jQuery.data( elem, type );

                        if ( !q || jQuery.isArray(data) )

                                q = jQuery.data( elem, type, jQuery.makeArray(data) );

                        else if( data )

                                q.push( data );

                }

                return q;

        },

        dequeue: function( elem, type ){

                var queue = jQuery.queue( elem, type ),

                        fn = queue.shift();

                if( !type || type === "fx" )

                        fn = queue[0];

                if( fn !== undefined )

                        fn.call(elem);

        }

});

jQuery.fn.extend({

        data: function( key, value ){

                var parts = key.split(".");

                parts[1] = parts[1] ? "." + parts[1] : "";

                if ( value === undefined ) {

                        var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);

                        if ( data === undefined && this.length )

                                data = jQuery.data( this[0], key );

                        return data === undefined && parts[1] ?

                                this.data( parts[0] ) :

                                data;

                } else

                        return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){

                                jQuery.data( this, key, value );

                        });

        },

        removeData: function( key ){

                return this.each(function(){

                        jQuery.removeData( this, key );

                });

        },

        queue: function(type, data){

                if ( typeof type !== "string" ) {

                        data = type;

                        type = "fx";

                }

                if ( data === undefined )

                        return jQuery.queue( this[0], type );

                return this.each(function(){

                        var queue = jQuery.queue( this, type, data );

                         if( type == "fx" && queue.length == 1 )

                                queue[0].call(this);

                });

        },

        dequeue: function(type){

                return this.each(function(){

                        jQuery.dequeue( this, type );

                });

        }

});/*!

 * Sizzle CSS Selector Engine - v1.0

 *  Copyright 2009, The Dojo Foundation

 *  Released under the MIT, BSD, and GPL Licenses.

 *  More information: http://sizzlejs.com/

 */

(function(){

var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?/g,

        done = 0,

        toString = Object.prototype.toString,

        hasDuplicate = false;

var Sizzle = function(selector, context, results, seed) {

        results = results || [];

        var origContext = context = context || document;

        if ( context.nodeType !== 1 && context.nodeType !== 9 ) {

                return [];

        }

        if ( !selector || typeof selector !== "string" ) {

                return results;

        }

        var parts = [], m, set, checkSet, check, mode, extra, prune = true, contextXML = isXML(context);

        // Reset the position of the chunker regexp (start from head)

        chunker.lastIndex = 0;

        while ( (m = chunker.exec(selector)) !== null ) {

                parts.push( m[1] );

                if ( m[2] ) {

                        extra = RegExp.rightContext;

                        break;

                }

        }

        if ( parts.length > 1 && origPOS.exec( selector ) ) {

                if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {

                        set = posProcess( parts[0] + parts[1], context );

                } else {

                        set = Expr.relative[ parts[0] ] ?

                                [ context ] :

                                Sizzle( parts.shift(), context );

                        while ( parts.length ) {

                                selector = parts.shift();

                                if ( Expr.relative[ selector ] )

                                        selector += parts.shift();

                                set = posProcess( selector, set );

                        }

                }

        } else {

                // Take a shortcut and set the context if the root selector is an ID

                // (but not if it'll be faster if the inner selector is an ID)

                if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&

                                Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {

                        var ret = Sizzle.find( parts.shift(), context, contextXML );

                        context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0];

                }

                if ( context ) {

                        var ret = seed ?

                                { expr: parts.pop(), set: makeArray(seed) } :

                                Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );

                        set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set;

                        if ( parts.length > 0 ) {

                                checkSet = makeArray(set);

                        } else {

                                prune = false;

                        }

                        while ( parts.length ) {

                                var cur = parts.pop(), pop = cur;

                                if ( !Expr.relative[ cur ] ) {

                                        cur = "";

                                } else {

                                        pop = parts.pop();

                                }

                                if ( pop == null ) {

                                        pop = context;

                                }