Хранилища 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-07-28 03:48:42 +0700 (Втр, 28 Июл 2009)

 * Revision: 6514

 */

(function(window, undefined){

// Define a local copy of jQuery

var jQuery = function( selector, context ) {

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

                return arguments.length === 0 ?

                        rootjQuery :

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

        },

        // Map over jQuery in case of overwrite

        _jQuery = window.jQuery,

        // Map over the $ in case of overwrite

        _$ = window.$,

        // Use the correct document accordingly with window argument (sandbox)

        document = window.document,

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

        rootjQuery,

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

        // (both of which we optimize for)

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

        // Is it a simple selector

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

        // Check if a string has a non-whitespace character in it

        rnotwhite = /\S/,

        // Used for trimming whitespace

        rtrim = /^\s+|\s+$/g,

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

        userAgent = navigator.userAgent.toLowerCase(),

        // Save a reference to some core methods

        toString = Object.prototype.toString,

        push = Array.prototype.push,

        slice = Array.prototype.slice;

// Expose jQuery to the global object

window.jQuery = window.$ = jQuery;

jQuery.fn = jQuery.prototype = {

        init: function( selector, context ) {

                var match, elem, ret;

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

                if ( !selector ) {

                        return this;

                }

                // Handle $(DOMElement)

                if ( selector.nodeType ) {

                        this.context = this[0] = selector;

                        this.length++;

                        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[2] );

                                        if ( elem ) {

                                                // Handle the case where IE and Opera return items

                                                // by name instead of ID

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

                                                        return rootjQuery.find( selector );

                                                }

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

                                                this.length++;

                                                this[0] = elem;

                                        }

                                        this.context = document;

                                        this.selector = selector;

                                        return this;

                                }

                        // 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 default length of a jQuery object is 0

        length: 0,

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

        size: function() {

                return this.length;

        },

        toArray: function(){

                return slice.call( this, 0 );

        },

        // 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

                        this.toArray() :

                        // Return just the object

                        ( num < 0 ? this.slice(num)[ 0 ] : 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;

                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 ) {

                                        var clone;

                                        if ( src ) {

                                                clone = src;

                                        } else if ( jQuery.isArray(copy) ) {

                                                clone = [];

                                        } else if ( jQuery.isObject(copy) ) {

                                                clone = {};

                                        } else {

                                                clone = copy;

                                        }

                                        // Never move original objects, clone them

                                        target[ name ] = jQuery.extend( deep, clone, 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]";

        },

        isObject: function( obj ) {

                return this.constructor.call(obj) === Object;

        },

        isEmptyObject: function( obj ) {

                for ( var name in obj ) {

                        return false;

                }

                return true;

        },

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

        isXMLDoc: function( elem ) {

                // documentElement is verified for cases where it doesn't yet exist

                // (such as loading iframes in IE - #4833)

                return ((elem.ownerDocument || elem).documentElement || 0).nodeName !== "HTML";

        },

        // Evalulates a script in a global context

        globalEval: function( data ) {

                if ( data && rnotwhite.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,

                        isObj = length === undefined || jQuery.isFunction(object);

                if ( args ) {

                        if ( isObj ) {

                                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 ( isObj ) {

                                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( rtrim, "" );

        },

        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: (/.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/.exec(userAgent) || [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 ], cache = jQuery.cache;

                // 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 && !cache[ id ] )

                        cache[ id ] = {};

                var thisCache = cache[ id ];

                // Prevent overriding the named cache with undefined values

                if ( data !== undefined ) thisCache[ name ] = data;

                if(name === true) return thisCache

                else if(name) return thisCache[name]

                else return id

        },

        removeData: function( elem, name ) {

                elem = elem == window ?

                        windowData :

                        elem;

                var id = elem[ expando ], cache = jQuery.cache, thisCache = cache[ id ];

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

                if ( name ) {

                        if ( thisCache ) {

                                // Remove the section of cache data

                                delete thisCache[ name ];

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

                                if( jQuery.isEmptyObject(thisCache) )

                                        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 cache[ id ];

                }

        },

        queue: function( elem, type, data ) {

                if( !elem ) return;

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

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

                // Speed up dequeue by getting out quickly if this is just a lookup

                if( !data ) return q || [];

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

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

                else

                        q.push( data );

                return q;

        },

        dequeue: function( elem, type ){

                type = type || "fx";

                var queue = jQuery.queue( elem, type ), fn = queue.shift();

                // If the fx queue is dequeued, always remove the progress sentinel

                if( fn === "inprogress" ) fn = queue.shift();

                if( fn ) {

                        // Add a progress sentinel to prevent the fx queue from being

                        // automatically dequeued

                        if( type == "fx" ) queue.unshift("inprogress");

                        fn.call(elem, function() { jQuery.dequeue(elem, type); });

                }

        }

});

jQuery.fn.extend({

        data: function( key, value ){

                if(typeof key === "undefined" && this.length) return jQuery.data(this[0], true);

                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(i, elem){

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

                        if( type == "fx" && queue[0] !== "inprogress" )

                                jQuery.dequeue( this, type )

                });

        },

        dequeue: function(type){

                return this.each(function(){

                        jQuery.dequeue( this, type );

                });

        },

        clearQueue: function(type){

                return this.queue( type || "fx", [] );

        }

});/*!

 * 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] ] ?