Club Drupal

/*!

 * http://jquery.com/

 *

 * Copyright 2011, John Resig

 * Copyright 2011, The Dojo Foundation

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

 *

 */

(function( window, undefined ) {

	selector: "",

	// The current version of jQuery being used

	// The default length of a jQuery object is 0

	length: 0,

		return jQuery.type(obj) === "array";

	},

	isWindow: function( obj ) {

	},

	isNumeric: function( obj ) {

	// Cross-browser xml parsing

	parseXML: function( data ) {

		var xml, tmp;

		try {

			if ( window.DOMParser ) { // Standard

	// Mutifunctional method to get and set values to a collection

	// The value/s can optionally be executed if it's a function

			}

			// Optionally, function values get executed if exec is true

			}

		}

	},

	now: function() {

		stack = [],

		// Last fire value (for non-forgettable lists)

		memory,

		// Flag to know if list is currently firing

		firing,

		// First callback to fire (used internally by add and fireWith)

		fire = function( context, args ) {

			args = args || [];

			memory = !flags.memory || [ context, args ];

			firing = true;

			firingIndex = firingStart || 0;

			firingStart = 0;

			},

			// To know if the callbacks have already been called at least once

			fired: function() {

			}

		};

		select,

		opt,

		input,

		fragment,

		tds,

		events,

		noCloneEvent: true,

		inlineBlockNeedsLayout: false,

		shrinkWrapBlocks: false,

	};

	// Make sure checked status is properly cloned

	input.checked = true;

	support.noCloneChecked = input.cloneNode( true ).checked;

	support.radioValue = input.value === "t";

	input.setAttribute("checked", "checked");

	div.appendChild( input );

	fragment = document.createDocumentFragment();

	fragment.appendChild( div.lastChild );

	fragment.removeChild( input );

	fragment.appendChild( div );

	// Technique from Juriy Zaytsev

	// http://perfectionkills.com/detecting-event-support-without-browser-sniffing/

	// We only care about the case where non-standard event systems

	// avoid an eval call (in setAttribute) which can cause CSP

	// to go haywire. See: https://developer.mozilla.org/en/Security/CSP

	if ( div.attachEvent ) {

			submit: 1,

			change: 1,

			focusin: 1

	fragment.removeChild( div );

	// Null elements to avoid leaks in IE

	// Run tests that need a body at doc ready

	jQuery(function() {

		var container, outer, inner, table, td, offsetSupport,

			body = document.getElementsByTagName("body")[0];

		if ( !body ) {

		}

		conMarginTop = 1;

			"<tr><td></td></tr></table>";

		container = document.createElement("div");

		body.insertBefore( container, body.firstChild );

		// Construct the test element

		// display:none (it is still safe to use offsets if a parent element is

		// hidden; don safety goggles and see bug #4512 for more information).

		// (only IE 8 fails this test)

		tds = div.getElementsByTagName( "td" );

		isSupported = ( tds[ 0 ].offsetHeight === 0 );

		// (IE <= 8 fail this test)

		support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );

		if ( typeof div.style.zoom !== "undefined" ) {

			// Check if natively block-level elements act like inline-block

			// elements when setting their display to 'inline' and giving

			// them layout

			// (IE < 8 does this)

			div.style.display = "inline";

			div.style.zoom = 1;

			// Check if elements with layout shrink-wrap their children

			// (IE 6 does this)

		}

		div.innerHTML = html;

		outer = div.firstChild;

		offsetSupport.subtractsBorderForOverflowNotVisible = ( inner.offsetTop === -5 );

		offsetSupport.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== conMarginTop );

		body.removeChild( container );

		jQuery.extend( support, offsetSupport );

	});

jQuery.fn.extend({

	data: function( key, value ) {

			data = null;

			if ( this.length ) {

						name = attr[i].name;

						if ( name.indexOf( "data-" ) === 0 ) {

							name = jQuery.camelCase( name.substring(5) );

						}

					}

				}

			}

			return data;

			return this.each(function() {

				jQuery.data( this, key );

			});

		}

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

				jQuery.data( this, key, value );

			});

	},

	removeData: function( key ) {

				data = data === "true" ? true :

				data === "false" ? false :

				data === "null" ? null :

					rbrace.test( data ) ? jQuery.parseJSON( data ) :

					data;

			} catch( e ) {}

jQuery.fn.extend({

	queue: function( type, data ) {

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

			data = type;

			type = "fx";

		}

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

		}

	},

	dequeue: function( type ) {

		return this.each(function() {

			}

		}

		resolve();

	}

});

jQuery.fn.extend({

	attr: function( name, value ) {

	},

	removeAttr: function( name ) {

	},

	prop: function( name, value ) {

	},

	removeProp: function( name ) {

		if ( !arguments.length ) {

			if ( elem ) {

				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {

					return ret;

				});

			}

			// If set returns undefined, fall back to normal setting

			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {

	},

	removeAttr: function( elem, value ) {

			i = 0;

		if ( value && elem.nodeType === 1 ) {

				if ( name ) {

					propName = jQuery.propFix[ name ] || name;

					// See #9699 for explanation of this approach (setting first, then removal)

					elem.removeAttribute( getSetAttribute ? name : propName );

					// Set corresponding property to false for boolean attributes

						elem[ propName ] = false;

					}

				}

	fixSpecified = {

		name: true,

	};

	// Use this for any attribute in IE6/7

var rformElems = /^(?:textarea|input|select)$/i,

	rtypenamespace = /^([^\.]*)?(?:\.(.+))?$/,

	rkeyEvent = /^key/,

	rmouseEvent = /^(?:mouse|contextmenu)|click/,

	rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,

		if ( handler.handler ) {

			handleObjIn = handler;

			handler = handleObjIn.handler;

		}

		// Make sure that the handler has a unique ID, used to find/remove it later

				handler: handler,

				guid: handler.guid,

				selector: selector,

				namespace: namespaces.join(".")

			}, handleObjIn );

			delegateCount = handlers.delegateCount,

			args = [].slice.call( arguments, 0 ),

			run_all = !event.exclusive && !event.namespace,

			handlerQueue = [],

			i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related;

		args[0] = event;

		event.delegateTarget = this;

		// Determine handlers that should run if there are delegated events

			// Pregenerate a single jQuery object for reuse with .is()

			jqcur = jQuery(this);

			jqcur.context = this.ownerDocument || this;

			for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {

					}

					}

				}

			}

		}

			}

		}

		return event.result;

	},

					form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;

				if ( form && !form._submit_attached ) {

					jQuery.event.add( form, "submit._submit", function( event ) {

					});

					form._submit_attached = true;

				}

			});

			// return undefined since we don't need an event listener

		},

		teardown: function() {

			// Only need this for delegated form submit events

		// Types can be a map of types/handlers

		if ( typeof types === "object" ) {

			// ( types-Object, selector, data )

				// ( types-Object, data )

				selector = undefined;

			}

			for ( type in types ) {

		});

	},

	one: function( types, selector, data, fn ) {

	},

	off: function( types, selector, fn ) {

		if ( types && types.preventDefault && types.handleObj ) {

			// ( event )  dispatched jQuery.Event

			var handleObj = types.handleObj;

			jQuery( types.delegateTarget ).off(

				handleObj.selector,

				handleObj.handler

			);

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

		return [];

	}

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

		return results;

	}

		contextXML = Sizzle.isXML( context ),

		parts = [],

		soFar = selector;

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

	do {

		chunker.exec( "" );

		if ( m ) {

			soFar = m[3];

			parts.push( m[1] );

			if ( m[2] ) {

				extra = m[3];

				break;

				if ( Expr.relative[ selector ] ) {

					selector += parts.shift();

				}

				set = posProcess( selector, set, seed );

			}

		}

	for ( i = 0, len = Expr.order.length; i < len; i++ ) {

		type = Expr.order[i];

		if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {

			left = match[1];

			match.splice( 1, 1 );

		ret = "";

	if ( nodeType ) {

			// Use textContent || innerText for elements

			if ( typeof elem.textContent === 'string' ) {

				return elem.textContent;

		ATTR: function( match, curLoop, inplace, result, not, isXML ) {

			var name = match[1] = match[1].replace( rBackslash, "" );

			if ( !isXML && Expr.attrMap[name] ) {

				match[1] = Expr.attrMap[name];

			}

			} else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {

				return true;

			}

			return match;

		},

			return match;

		}

	},

	filters: {

		enabled: function( elem ) {

			return elem.disabled === false && elem.type !== "hidden";

		checked: function( elem ) {

			return elem.checked === true;

		},

		selected: function( elem ) {

			// Accessing this property makes selected-by-default

			// options in Safari work properly

			if ( elem.parentNode ) {

				elem.parentNode.selectedIndex;

			}

			return elem.selected === true;

		},

		text: function( elem ) {

			var attr = elem.getAttribute( "type" ), type = elem.type;

			// use getAttribute instead to test this case

			return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null );

		},

			switch ( type ) {

				case "only":

				case "first":

						}

					}

					}

					node = elem;

				case "last":

						}

					}

					if ( first === 1 && last === 0 ) {

						return true;

					}

					doneName = match[0];

					parent = elem.parentNode;

					if ( parent && (parent[ expando ] !== doneName || !elem.nodeIndex) ) {

						count = 0;

						for ( node = parent.firstChild; node; node = node.nextSibling ) {

							if ( node.nodeType === 1 ) {

								node.nodeIndex = ++count;

							}

						parent[ expando ] = doneName;

					}

					diff = elem.nodeIndex - last;

					if ( first === 0 ) {

		TAG: function( elem, match ) {

			return (match === "*" && elem.nodeType === 1) || !!elem.nodeName && elem.nodeName.toLowerCase() === match;

		},

		CLASS: function( elem, match ) {

			return (" " + (elem.className || elem.getAttribute("class")) + " ")

				.indexOf( match ) > -1;

	Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );

	Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );

}

var makeArray = function( array, results ) {

	array = Array.prototype.slice.call( array, 0 );

		results.push.apply( results, array );

		return results;

	}

	return array;

};

		if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {

			return;

		}

		Sizzle = function( query, context, extra, seed ) {

			context = context || document;

			if ( !seed && !Sizzle.isXML(context) ) {

				// See if we find a selector to speed up

				var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );

				if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {

					// Speed-up: Sizzle("TAG")

					if ( match[1] ) {

						return makeArray( context.getElementsByTagName( query ), extra );

					// Speed-up: Sizzle(".CLASS")

					} else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {

						return makeArray( context.getElementsByClassName( match[2] ), extra );

					}

				}

				if ( context.nodeType === 9 ) {

					// Speed-up: Sizzle("body")

					// The body element only exists once, optimize finding it

					if ( query === "body" && context.body ) {

						return makeArray( [ context.body ], extra );

					// Speed-up: Sizzle("#ID")

					} else if ( match && match[3] ) {

						var elem = context.getElementById( match[3] );

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

								return makeArray( [ elem ], extra );

							}

						} else {

							return makeArray( [], extra );

						}

					}

					try {

						return makeArray( context.querySelectorAll(query), extra );

					} catch(qsaError) {}

					}

				}

			}

			return oldSizzle(query, context, extra, seed);

		};

			// This should fail with an exception

			// Gecko does not error, returns false instead

			matches.call( document.documentElement, "[test!='']:sizzle" );

		} catch( pseudoError ) {

			pseudoWorks = true;

		}

			expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");

			if ( !Sizzle.isXML( node ) ) {

					if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {

						var ret = matches.call( node, expr );

	if ( div.getElementsByClassName("e").length === 1 ) {

		return;

	}

	Expr.order.splice(1, 0, "CLASS");

	Expr.find.CLASS = function( match, context, isXML ) {

		if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {

		if ( elem ) {

			var match = false;

			elem = elem[dir];

			while ( elem ) {

Sizzle.isXML = function( elem ) {

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

	var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;

	return documentElement ? documentElement.nodeName !== "HTML" : false;

	rmultiselector = /,/,

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

	slice = Array.prototype.slice,

	// methods guaranteed to produce a unique set when starting from a unique set

	guaranteedUnique = {

		children: true,

	},

	is: function( selector ) {

			typeof selector === "string" ?

				// If this is a positional selector, check membership in the returned set

				// so $("p:first").is("p:last") won't return true for a doc with two "p".

					jQuery( selector, this.context ).index( this[0] ) >= 0 :

					jQuery.filter( selector, this ).length > 0 :

				this.filter( selector ).length > 0 );

	closest: function( selectors, context ) {

		var ret = [], i, l, cur = this[0];

		// Array (deprecated as of jQuery 1.7)

		if ( jQuery.isArray( selectors ) ) {

			var level = 1;

		return jQuery.dir( elem, "previousSibling", until );

	},

	siblings: function( elem ) {

	},

	children: function( elem ) {

		return jQuery.sibling( elem.firstChild );

	return safeFrag;

}

		"header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",

	rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,

	rleadingWhitespace = /^\s+/,

	rhtml = /<|&#?\w+;/,

	rnoInnerhtml = /<(?:script|style)/i,

	rnocache = /<(?:script|object|embed|option|style)/i,

	// checked="checked" or checked

	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,

	rscriptType = /\/(java|ecma)script/i,

}

jQuery.fn.extend({

	},

	wrapAll: function( html ) {

	},

	html: function( value ) {

	},

	replaceWith: function( value ) {

			}

			if ( scripts.length ) {

			}

		}

		for ( type in events ) {

			for ( i = 0, l = events[ type ].length; i < l; i++ ) {

			}

		}

	}

	// cloning other types of input fields

	} else if ( nodeName === "input" || nodeName === "textarea" ) {

		dest.defaultValue = src.defaultValue;

	}

	// Event data gets referenced instead of copied if the expando

	// gets copied too

	dest.removeAttribute( jQuery.expando );

}

jQuery.buildFragment = function( args, nodes, scripts ) {

			destElements,

			i,

			// IE<=8 does not properly clone detached, unknown element nodes

				elem.cloneNode( true ) :

				shimCloneNode( elem );

	},

	clean: function( elems, context, fragment, scripts ) {

		context = context || document;

			context = context.ownerDocument || context[0] && context[0].ownerDocument || document;

		}

		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {

			if ( typeof elem === "number" ) {

				elem += "";

					var tag = ( rtagName.exec( elem ) || ["", ""] )[1].toLowerCase(),

						wrap = wrapMap[ tag ] || wrapMap._default,

						depth = wrap[0],

					// Append wrapper element to unknown element safe doc fragment

					if ( context === document ) {

					}

					elem = div.childNodes;

				}

			}

				return !elem.type || rscriptType.test( elem.type );

			};

			for ( i = 0; ret[i]; i++ ) {

				} else {

						ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );

					}

				}

			}

		}

	}

});

	ropacity = /opacity=([^)]*)/,

	// fixed for IE9, see #8346

	rupper = /([A-Z]|^ms)/g,

	rrelNum = /^([\-+])=([\-+.\de]+)/,

	cssShow = { position: "absolute", visibility: "hidden", display: "block" },

	curCSS,

	getComputedStyle,

	currentStyle;

jQuery.fn.css = function( name, value ) {

		return value !== undefined ?

			jQuery.style( elem, name, value ) :

			jQuery.css( elem, name );

};

jQuery.extend({

			get: function( elem, computed ) {

				if ( computed ) {

					// We should always get a number back from opacity

					return ret === "" ? "1" : ret;

				} else {

	// A method for quickly swapping in/out CSS properties to get correct calculations

	swap: function( elem, options, callback ) {

		// Remember the old values, and insert the new ones

			old[ name ] = elem.style[ name ];

			elem.style[ name ] = options[ name ];

		}

		// Revert the old values

		for ( name in options ) {

			elem.style[ name ] = old[ name ];

		}

	}

});

jQuery.curCSS = jQuery.css;