/* Prototype JavaScript framework, version 1.5.1.1
 * (c) 2005-2007 Sam Stephenson
 *
 * Prototype is freely distributable under the terms of an MIT-style license.
 * For details, see the Prototype web site: http://www.prototypejs.org/
 *
/*--------------------------------------------------------------------------*/

var Prototype = {
 Version: '1.5.1.1',

 Browser: {
 IE: !!(window.attachEvent && !window.opera),
 Opera: !!window.opera,
 WebKit: navigator.userAgent.indexOf('AppleWebKit/') > -1,
 Gecko: navigator.userAgent.indexOf('Gecko') > -1 && navigator.userAgent.indexOf('KHTML') == -1
 },

 BrowserFeatures: {
 XPath: !!document.evaluate,
 ElementExtensions: !!window.HTMLElement,
 SpecificElementExtensions:
 (document.createElement('div').__proto__ !==
 document.createElement('form').__proto__)
 },

 ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',
 JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,

 emptyFunction: function() { },
 K: function(x) { return x }
}

var Class = {
 create: function() {
 return function() {
 this.initialize.apply(this, arguments);
 }
 }
}

var Abstract = new Object();

Object.extend = function(destination, source) {
 for (var property in source) {
 destination[property] = source[property];
 }
 return destination;
}

Object.extend(Object, {
 inspect: function(object) {
 try {
 if (object === undefined) return 'undefined';
 if (object === null) return 'null';
 return object.inspect ? object.inspect() : object.toString();
 } catch (e) {
 if (e instanceof RangeError) return '...';
 throw e;
 }
 },

 toJSON: function(object) {
 var type = typeof object;
 switch(type) {
 case 'undefined':
 case 'function':
 case 'unknown': return;
 case 'boolean': return object.toString();
 }
 if (object === null) return 'null';
 if (object.toJSON) return object.toJSON();
 if (object.ownerDocument === document) return;
 var results = [];
 for (var property in object) {
 var value = Object.toJSON(object[property]);
 if (value !== undefined)
 results.push(property.toJSON() + ': ' + value);
 }
 return '{' + results.join(', ') + '}';
 },

 keys: function(object) {
 var keys = [];
 for (var property in object)
 keys.push(property);
 return keys;
 },

 values: function(object) {
 var values = [];
 for (var property in object)
 values.push(object[property]);
 return values;
 },

 clone: function(object) {
 return Object.extend({}, object);
 }
});

Function.prototype.bind = function() {
 var __method = this, args = $A(arguments), object = args.shift();
 return function() {
 return __method.apply(object, args.concat($A(arguments)));
 }
}

Function.prototype.bindAsEventListener = function(object) {
 var __method = this, args = $A(arguments), object = args.shift();
 return function(event) {
 return __method.apply(object, [event || window.event].concat(args));
 }
}

Object.extend(Number.prototype, {
 toColorPart: function() {
 return this.toPaddedString(2, 16);
 },

 succ: function() {
 return this + 1;
 },

 times: function(iterator) {
 $R(0, this, true).each(iterator);
 return this;
 },

 toPaddedString: function(length, radix) {
 var string = this.toString(radix || 10);
 return '0'.times(length - string.length) + string;
 },

 toJSON: function() {
 return isFinite(this) ? this.toString() : 'null';
 }
});

Date.prototype.toJSON = function() {
 return '"' + this.getFullYear() + '-' +
 (this.getMonth() + 1).toPaddedString(2) + '-' +
 this.getDate().toPaddedString(2) + 'T' +
 this.getHours().toPaddedString(2) + ':' +
 this.getMinutes().toPaddedString(2) + ':' +
 this.getSeconds().toPaddedString(2) + '"';
};

var Try = {
 these: function() {
 var returnValue;

 for (var i = 0, length = arguments.length; i < length; i++) {
 var lambda = arguments[i];
 try {
 returnValue = lambda();
 break;
 } catch (e) {}
 }

 return returnValue;
 }
}

/*--------------------------------------------------------------------------*/

var PeriodicalExecuter = Class.create();
PeriodicalExecuter.prototype = {
 initialize: function(callback, frequency) {
 this.callback = callback;
 this.frequency = frequency;
 this.currentlyExecuting = false;

 this.registerCallback();
 },

 registerCallback: function() {
 this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
 },

 stop: function() {
 if (!this.timer) return;
 clearInterval(this.timer);
 this.timer = null;
 },

 onTimerEvent: function() {
 if (!this.currentlyExecuting) {
 try {
 this.currentlyExecuting = true;
 this.callback(this);
 } finally {
 this.currentlyExecuting = false;
 }
 }
 }
}
Object.extend(String, {
 interpret: function(value) {
 return value == null ? '' : String(value);
 },
 specialChar: {
 '\b': '\\b',
 '\t': '\\t',
 '\n': '\\n',
 '\f': '\\f',
 '\r': '\\r',
 '\\': '\\\\'
 }
});

Object.extend(String.prototype, {
 gsub: function(pattern, replacement) {
 var result = '', source = this, match;
 replacement = arguments.callee.prepareReplacement(replacement);

 while (source.length > 0) {
 if (match = source.match(pattern)) {
 result += source.slice(0, match.index);
 result += String.interpret(replacement(match));
 source = source.slice(match.index + match[0].length);
 } else {
 result += source, source = '';
 }
 }
 return result;
 },

 sub: function(pattern, replacement, count) {
 replacement = this.gsub.prepareReplacement(replacement);
 count = count === undefined ? 1 : count;

 return this.gsub(pattern, function(match) {
 if (--count < 0) return match[0];
 return replacement(match);
 });
 },

 scan: function(pattern, iterator) {
 this.gsub(pattern, iterator);
 return this;
 },

 truncate: function(length, truncation) {
 length = length || 30;
 truncation = truncation === undefined ? '...' : truncation;
 return this.length > length ?
 this.slice(0, length - truncation.length) + truncation : this;
 },

 strip: function() {
 return this.replace(/^\s+/, '').replace(/\s+$/, '');
 },

 stripTags: function() {
 return this.replace(/<\/?[^>]+>/gi, '');
 },

 stripScripts: function() {
 return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
 },

 extractScripts: function() {
 var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
 var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
 return (this.match(matchAll) || []).map(function(scriptTag) {
 return (scriptTag.match(matchOne) || ['', ''])[1];
 });
 },

 evalScripts: function() {
 return this.extractScripts().map(function(script) { return eval(script) });
 },

 escapeHTML: function() {
 var self = arguments.callee;
 self.text.data = this;
 return self.div.innerHTML;
 },

 unescapeHTML: function() {
 var div = document.createElement('div');
 div.innerHTML = this.stripTags();
 return div.childNodes[0] ? (div.childNodes.length > 1 ?
 $A(div.childNodes).inject('', function(memo, node) { return memo+node.nodeValue }) :
 div.childNodes[0].nodeValue) : '';
 },

 toQueryParams: function(separator) {
 var match = this.strip().match(/([^?#]*)(#.*)?$/);
 if (!match) return {};

 return match[1].split(separator || '&').inject({}, function(hash, pair) {
 if ((pair = pair.split('='))[0]) {
 var key = decodeURIComponent(pair.shift());
 var value = pair.length > 1 ? pair.join('=') : pair[0];
 if (value != undefined) value = decodeURIComponent(value);

 if (key in hash) {
 if (hash[key].constructor != Array) hash[key] = [hash[key]];
 hash[key].push(value);
 }
 else hash[key] = value;
 }
 return hash;
 });
 },

 toArray: function() {
 return this.split('');
 },

 succ: function() {
 return this.slice(0, this.length - 1) +
 String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
 },

 times: function(count) {
 var result = '';
 for (var i = 0; i < count; i++) result += this;
 return result;
 },

 camelize: function() {
 var parts = this.split('-'), len = parts.length;
 if (len == 1) return parts[0];

 var camelized = this.charAt(0) == '-'
 ? parts[0].charAt(0).toUpperCase() + parts[0].substring(1)
 : parts[0];

 for (var i = 1; i < len; i++)
 camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);

 return camelized;
 },

 capitalize: function() {
 return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
 },

 underscore: function() {
 return this.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'#{1}_#{2}').gsub(/([a-z\d])([A-Z])/,'#{1}_#{2}').gsub(/-/,'_').toLowerCase();
 },

 dasherize: function() {
 return this.gsub(/_/,'-');
 },

 inspect: function(useDoubleQuotes) {
 var escapedString = this.gsub(/[\x00-\x1f\\]/, function(match) {
 var character = String.specialChar[match[0]];
 return character ? character : '\\u00' + match[0].charCodeAt().toPaddedString(2, 16);
 });
 if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
 return "'" + escapedString.replace(/'/g, '\\\'') + "'";
 },

 toJSON: function() {
 return this.inspect(true);
 },

 unfilterJSON: function(filter) {
 return this.sub(filter || Prototype.JSONFilter, '#{1}');
 },

 isJSON: function() {
 var str = this.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');
 return (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(str);
 },

 evalJSON: function(sanitize) {
 var json = this.unfilterJSON();
 try {
 if (!sanitize || json.isJSON()) return eval('(' + json + ')');
 } catch (e) { }
 throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
 },

 include: function(pattern) {
 return this.indexOf(pattern) > -1;
 },

 startsWith: function(pattern) {
 return this.indexOf(pattern) === 0;
 },

 endsWith: function(pattern) {
 var d = this.length - pattern.length;
 return d >= 0 && this.lastIndexOf(pattern) === d;
 },

 empty: function() {
 return this == '';
 },

 blank: function() {
 return /^\s*$/.test(this);
 }
});

if (Prototype.Browser.WebKit || Prototype.Browser.IE) Object.extend(String.prototype, {
 escapeHTML: function() {
 return this.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
 },
 unescapeHTML: function() {
 return this.replace(/&amp;/g,'&').replace(/&lt;/g,'<').replace(/&gt;/g,'>');
 }
});

String.prototype.gsub.prepareReplacement = function(replacement) {
 if (typeof replacement == 'function') return replacement;
 var template = new Template(replacement);
 return function(match) { return template.evaluate(match) };
}

String.prototype.parseQuery = String.prototype.toQueryParams;

Object.extend(String.prototype.escapeHTML, {
 div: document.createElement('div'),
 text: document.createTextNode('')
});

with (String.prototype.escapeHTML) div.appendChild(text);

var Template = Class.create();
Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
Template.prototype = {
 initialize: function(template, pattern) {
 this.template = template.toString();
 this.pattern = pattern || Template.Pattern;
 },

 evaluate: function(object) {
 return this.template.gsub(this.pattern, function(match) {
 var before = match[1];
 if (before == '\\') return match[2];
 return before + String.interpret(object[match[3]]);
 });
 }
}

var $break = {}, $continue = new Error('"throw $continue" is deprecated, use "return" instead');

var Enumerable = {
 each: function(iterator) {
 var index = 0;
 try {
 this._each(function(value) {
 iterator(value, index++);
 });
 } catch (e) {
 if (e != $break) throw e;
 }
 return this;
 },

 eachSlice: function(number, iterator) {
 var index = -number, slices = [], array = this.toArray();
 while ((index += number) < array.length)
 slices.push(array.slice(index, index+number));
 return slices.map(iterator);
 },

 all: function(iterator) {
 var result = true;
 this.each(function(value, index) {
 result = result && !!(iterator || Prototype.K)(value, index);
 if (!result) throw $break;
 });
 return result;
 },

 any: function(iterator) {
 var result = false;
 this.each(function(value, index) {
 if (result = !!(iterator || Prototype.K)(value, index))
 throw $break;
 });
 return result;
 },

 collect: function(iterator) {
 var results = [];
 this.each(function(value, index) {
 results.push((iterator || Prototype.K)(value, index));
 });
 return results;
 },

 detect: function(iterator) {
 var result;
 this.each(function(value, index) {
 if (iterator(value, index)) {
 result = value;
 throw $break;
 }
 });
 return result;
 },

 findAll: function(iterator) {
 var results = [];
 this.each(function(value, index) {
 if (iterator(value, index))
 results.push(value);
 });
 return results;
 },

 grep: function(pattern, iterator) {
 var results = [];
 this.each(function(value, index) {
 var stringValue = value.toString();
 if (stringValue.match(pattern))
 results.push((iterator || Prototype.K)(value, index));
 })
 return results;
 },

 include: function(object) {
 var found = false;
 this.each(function(value) {
 if (value == object) {
 found = true;
 throw $break;
 }
 });
 return found;
 },

 inGroupsOf: function(number, fillWith) {
 fillWith = fillWith === undefined ? null : fillWith;
 return this.eachSlice(number, function(slice) {
 while(slice.length < number) slice.push(fillWith);
 return slice;
 });
 },

 inject: function(memo, iterator) {
 this.each(function(value, index) {
 memo = iterator(memo, value, index);
 });
 return memo;
 },

 invoke: function(method) {
 var args = $A(arguments).slice(1);
 return this.map(function(value) {
 return value[method].apply(value, args);
 });
 },

 max: function(iterator) {
 var result;
 this.each(function(value, index) {
 value = (iterator || Prototype.K)(value, index);
 if (result == undefined || value >= result)
 result = value;
 });
 return result;
 },

 min: function(iterator) {
 var result;
 this.each(function(value, index) {
 value = (iterator || Prototype.K)(value, index);
 if (result == undefined || value < result)
 result = value;
 });
 return result;
 },

 partition: function(iterator) {
 var trues = [], falses = [];
 this.each(function(value, index) {
 ((iterator || Prototype.K)(value, index) ?
 trues : falses).push(value);
 });
 return [trues, falses];
 },

 pluck: function(property) {
 var results = [];
 this.each(function(value, index) {
 results.push(value[property]);
 });
 return results;
 },

 reject: function(iterator) {
 var results = [];
 this.each(function(value, index) {
 if (!iterator(value, index))
 results.push(value);
 });
 return results;
 },

 sortBy: function(iterator) {
 return this.map(function(value, index) {
 return {value: value, criteria: iterator(value, index)};
 }).sort(function(left, right) {
 var a = left.criteria, b = right.criteria;
 return a < b ? -1 : a > b ? 1 : 0;
 }).pluck('value');
 },

 toArray: function() {
 return this.map();
 },

 zip: function() {
 var iterator = Prototype.K, args = $A(arguments);
 if (typeof args.last() == 'function')
 iterator = args.pop();

 var collections = [this].concat(args).map($A);
 return this.map(function(value, index) {
 return iterator(collections.pluck(index));
 });
 },

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

 inspect: function() {
 return '#<Enumerable:' + this.toArray().inspect() + '>';
 }
}

Object.extend(Enumerable, {
 map: Enumerable.collect,
 find: Enumerable.detect,
 select: Enumerable.findAll,
 member: Enumerable.include,
 entries: Enumerable.toArray
});
var $A = Array.from = function(iterable) {
 if (!iterable) return [];
 if (iterable.toArray) {
 return iterable.toArray();
 } else {
 var results = [];
 for (var i = 0, length = iterable.length; i < length; i++)
 results.push(iterable[i]);
 return results;
 }
}

if (Prototype.Browser.WebKit) {
 $A = Array.from = function(iterable) {
 if (!iterable) return [];
 if (!(typeof iterable == 'function' && iterable == '[object NodeList]') &&
 iterable.toArray) {
 return iterable.toArray();
 } else {
 var results = [];
 for (var i = 0, length = iterable.length; i < length; i++)
 results.push(iterable[i]);
 return results;
 }
 }
}

Object.extend(Array.prototype, Enumerable);

if (!Array.prototype._reverse)
 Array.prototype._reverse = Array.prototype.reverse;

Object.extend(Array.prototype, {
 _each: function(iterator) {
 for (var i = 0, length = this.length; i < length; i++)
 iterator(this[i]);
 },

 clear: function() {
 this.length = 0;
 return this;
 },

 first: function() {
 return this[0];
 },

 last: function() {
 return this[this.length - 1];
 },

 compact: function() {
 return this.select(function(value) {
 return value != null;
 });
 },

 flatten: function() {
 return this.inject([], function(array, value) {
 return array.concat(value && value.constructor == Array ?
 value.flatten() : [value]);
 });
 },

 without: function() {
 var values = $A(arguments);
 return this.select(function(value) {
 return !values.include(value);
 });
 },

 indexOf: function(object) {
 for (var i = 0, length = this.length; i < length; i++)
 if (this[i] == object) return i;
 return -1;
 },

 reverse: function(inline) {
 return (inline !== false ? this : this.toArray())._reverse();
 },

 reduce: function() {
 return this.length > 1 ? this : this[0];
 },

 uniq: function(sorted) {
 return this.inject([], function(array, value, index) {
 if (0 == index || (sorted ? array.last() != value : !array.include(value)))
 array.push(value);
 return array;
 });
 },

 clone: function() {
 return [].concat(this);
 },

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

 inspect: function() {
 return '[' + this.map(Object.inspect).join(', ') + ']';
 },

 toJSON: function() {
 var results = [];
 this.each(function(object) {
 var value = Object.toJSON(object);
 if (value !== undefined) results.push(value);
 });
 return '[' + results.join(', ') + ']';
 }
});

Array.prototype.toArray = Array.prototype.clone;

function $w(string) {
 string = string.strip();
 return string ? string.split(/\s+/) : [];
}

if (Prototype.Browser.Opera){
 Array.prototype.concat = function() {
 var array = [];
 for (var i = 0, length = this.length; i < length; i++) array.push(this[i]);
 for (var i = 0, length = arguments.length; i < length; i++) {
 if (arguments[i].constructor == Array) {
 for (var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)
 array.push(arguments[i][j]);
 } else {
 array.push(arguments[i]);
 }
 }
 return array;
 }
}
var Hash = function(object) {
 if (object instanceof Hash) this.merge(object);
 else Object.extend(this, object || {});
};

Object.extend(Hash, {
 toQueryString: function(obj) {
 var parts = [];
 parts.add = arguments.callee.addPair;

 this.prototype._each.call(obj, function(pair) {
 if (!pair.key) return;
 var value = pair.value;

 if (value && typeof value == 'object') {
 if (value.constructor == Array) value.each(function(value) {
 parts.add(pair.key, value);
 });
 return;
 }
 parts.add(pair.key, value);
 });

 return parts.join('&');
 },

 toJSON: function(object) {
 var results = [];
 this.prototype._each.call(object, function(pair) {
 var value = Object.toJSON(pair.value);
 if (value !== undefined) results.push(pair.key.toJSON() + ': ' + value);
 });
 return '{' + results.join(', ') + '}';
 }
});

Hash.toQueryString.addPair = function(key, value, prefix) {
 key = encodeURIComponent(key);
 if (value === undefined) this.push(key);
 else this.push(key + '=' + (value == null ? '' : encodeURIComponent(value)));
}

Object.extend(Hash.prototype, Enumerable);
Object.extend(Hash.prototype, {
 _each: function(iterator) {
 for (var key in this) {
 var value = this[key];
 if (value && value == Hash.prototype[key]) continue;

 var pair = [key, value];
 pair.key = key;
 pair.value = value;
 iterator(pair);
 }
 },

 keys: function() {
 return this.pluck('key');
 },

 values: function() {
 return this.pluck('value');
 },

 merge: function(hash) {
 return $H(hash).inject(this, function(mergedHash, pair) {
 mergedHash[pair.key] = pair.value;
 return mergedHash;
 });
 },

 remove: function() {
 var result;
 for(var i = 0, length = arguments.length; i < length; i++) {
 var value = this[arguments[i]];
 if (value !== undefined){
 if (result === undefined) result = value;
 else {
 if (result.constructor != Array) result = [result];
 result.push(value)
 }
 }
 delete this[arguments[i]];
 }
 return result;
 },

 toQueryString: function() {
 return Hash.toQueryString(this);
 },

 inspect: function() {
 return '#<Hash:{' + this.map(function(pair) {
 return pair.map(Object.inspect).join(': ');
 }).join(', ') + '}>';
 },

 toJSON: function() {
 return Hash.toJSON(this);
 }
});

function $H(object) {
 if (object instanceof Hash) return object;
 return new Hash(object);
};

// Safari iterates over shadowed properties
if (function() {
 var i = 0, Test = function(value) { this.key = value };
 Test.prototype.key = 'foo';
 for (var property in new Test('bar')) i++;
 return i > 1;
}()) Hash.prototype._each = function(iterator) {
 var cache = [];
 for (var key in this) {
 var value = this[key];
 if ((value && value == Hash.prototype[key]) || cache.include(key)) continue;
 cache.push(key);
 var pair = [key, value];
 pair.key = key;
 pair.value = value;
 iterator(pair);
 }
};
ObjectRange = Class.create();
Object.extend(ObjectRange.prototype, Enumerable);
Object.extend(ObjectRange.prototype, {
 initialize: function(start, end, exclusive) {
 this.start = start;
 this.end = end;
 this.exclusive = exclusive;
 },

 _each: function(iterator) {
 var value = this.start;
 while (this.include(value)) {
 iterator(value);
 value = value.succ();
 }
 },

 include: function(value) {
 if (value < this.start)
 return false;
 if (this.exclusive)
 return value < this.end;
 return value <= this.end;
 }
});

var $R = function(start, end, exclusive) {
 return new ObjectRange(start, end, exclusive);
}

var Ajax = {
 getTransport: function() {
 return Try.these(
 function() {return new XMLHttpRequest()},
 function() {return new ActiveXObject('Msxml2.XMLHTTP')},
 function() {return new ActiveXObject('Microsoft.XMLHTTP')}
 ) || false;
 },

 activeRequestCount: 0
}

Ajax.Responders = {
 responders: [],

 _each: function(iterator) {
 this.responders._each(iterator);
 },

 register: function(responder) {
 if (!this.include(responder))
 this.responders.push(responder);
 },

 unregister: function(responder) {
 this.responders = this.responders.without(responder);
 },

 dispatch: function(callback, request, transport, json) {
 this.each(function(responder) {
 if (typeof responder[callback] == 'function') {
 try {
 responder[callback].apply(responder, [request, transport, json]);
 } catch (e) {}
 }
 });
 }
};

Object.extend(Ajax.Responders, Enumerable);

Ajax.Responders.register({
 onCreate: function() {
 Ajax.activeRequestCount++;
 },
 onComplete: function() {
 Ajax.activeRequestCount--;
 }
});

Ajax.Base = function() {};
Ajax.Base.prototype = {
 setOptions: function(options) {
 this.options = {
 method: 'post',
 asynchronous: true,
 contentType: 'application/x-www-form-urlencoded',
 encoding: 'UTF-8',
 parameters: ''
 }
 Object.extend(this.options, options || {});

 this.options.method = this.options.method.toLowerCase();
 if (typeof this.options.parameters == 'string')
 this.options.parameters = this.options.parameters.toQueryParams();
 }
}

Ajax.Request = Class.create();
Ajax.Request.Events =
 ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];

Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
 _complete: false,

 initialize: function(url, options) {
 this.transport = Ajax.getTransport();
 this.setOptions(options);
 this.request(url);
 },

 request: function(url) {
 this.url = url;
 this.method = this.options.method;
 var params = Object.clone(this.options.parameters);

 if (!['get', 'post'].include(this.method)) {
 // simulate other verbs over post
 params['_method'] = this.method;
 this.method = 'post';
 }

 this.parameters = params;

 if (params = Hash.toQueryString(params)) {
 // when GET, append parameters to URL
 if (this.method == 'get')
 this.url += (this.url.include('?') ? '&' : '?') + params;
 else if (/Konqueror|Safari|KHTML/.test(navigator.userAgent))
 params += '&_=';
 }

 try {
 if (this.options.onCreate) this.options.onCreate(this.transport);
 Ajax.Responders.dispatch('onCreate', this, this.transport);

 this.transport.open(this.method.toUpperCase(), this.url,
 this.options.asynchronous);

 if (this.options.asynchronous)
 setTimeout(function() { this.respondToReadyState(1) }.bind(this), 10);

 this.transport.onreadystatechange = this.onStateChange.bind(this);
 this.setRequestHeaders();

 this.body = this.method == 'post' ? (this.options.postBody || params) : null;
 this.transport.send(this.body);

 /* Force Firefox to handle ready state 4 for synchronous requests */
 if (!this.options.asynchronous && this.transport.overrideMimeType)
 this.onStateChange();

 }
 catch (e) {
 this.dispatchException(e);
 }
 },

 onStateChange: function() {
 var readyState = this.transport.readyState;
 if (readyState > 1 && !((readyState == 4) && this._complete))
 this.respondToReadyState(this.transport.readyState);
 },

 setRequestHeaders: function() {
 var headers = {
 'X-Requested-With': 'XMLHttpRequest',
 'X-Prototype-Version': Prototype.Version,
 'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
 };

 if (this.method == 'post') {
 headers['Content-type'] = this.options.contentType +
 (this.options.encoding ? '; charset=' + this.options.encoding : '');

 /* Force "Connection: close" for older Mozilla browsers to work
 * around a bug where XMLHttpRequest sends an incorrect
 * Content-length header. See Mozilla Bugzilla #246651.
 */
 if (this.transport.overrideMimeType &&
 (navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
 headers['Connection'] = 'close';
 }

 // user-defined headers
 if (typeof this.options.requestHeaders == 'object') {
 var extras = this.options.requestHeaders;

 if (typeof extras.push == 'function')
 for (var i = 0, length = extras.length; i < length; i += 2)
 headers[extras[i]] = extras[i+1];
 else
 $H(extras).each(function(pair) { headers[pair.key] = pair.value });
 }

 for (var name in headers)
 this.transport.setRequestHeader(name, headers[name]);
 },

 success: function() {
 return !this.transport.status
 || (this.transport.status >= 200 && this.transport.status < 300);
 },

 respondToReadyState: function(readyState) {
 var state = Ajax.Request.Events[readyState];
 var transport = this.transport, json = this.evalJSON();

 if (state == 'Complete') {
 try {
 this._complete = true;
 (this.options['on' + this.transport.status]
 || this.options['on' + (this.success() ? 'Success' : 'Failure')]
 || Prototype.emptyFunction)(transport, json);
 } catch (e) {
 this.dispatchException(e);
 }

 var contentType = this.getHeader('Content-type');
 if (contentType && contentType.strip().
 match(/^(text|application)\/(x-)?(java|ecma)script(;.*)?$/i))
 this.evalResponse();
 }

 try {
 (this.options['on' + state] || Prototype.emptyFunction)(transport, json);
 Ajax.Responders.dispatch('on' + state, this, transport, json);
 } catch (e) {
 this.dispatchException(e);
 }

 if (state == 'Complete') {
 // avoid memory leak in MSIE: clean up
 this.transport.onreadystatechange = Prototype.emptyFunction;
 }
 },

 getHeader: function(name) {
 try {
 return this.transport.getResponseHeader(name);
 } catch (e) { return null }
 },

 evalJSON: function() {
 try {
 var json = this.getHeader('X-JSON');
 return json ? json.evalJSON() : null;
 } catch (e) { return null }
 },

 evalResponse: function() {
 try {
 return eval((this.transport.responseText || '').unfilterJSON());
 } catch (e) {
 this.dispatchException(e);
 }
 },

 dispatchException: function(exception) {
 (this.options.onException || Prototype.emptyFunction)(this, exception);
 Ajax.Responders.dispatch('onException', this, exception);
 }
});

Ajax.Updater = Class.create();

Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), {
 initialize: function(container, url, options) {
 this.container = {
 success: (container.success || container),
 failure: (container.failure || (container.success ? null : container))
 }

 this.transport = Ajax.getTransport();
 this.setOptions(options);

 var onComplete = this.options.onComplete || Prototype.emptyFunction;
 this.options.onComplete = (function(transport, param) {
 this.updateContent();
 onComplete(transport, param);
 }).bind(this);

 this.request(url);
 },

 updateContent: function() {
 var receiver = this.container[this.success() ? 'success' : 'failure'];
 var response = this.transport.responseText;

 if (!this.options.evalScripts) response = response.stripScripts();

 if (receiver = $(receiver)) {
 if (this.options.insertion)
 new this.options.insertion(receiver, response);
 else
 receiver.update(response);
 }

 if (this.success()) {
 if (this.onComplete)
 setTimeout(this.onComplete.bind(this), 10);
 }
 }
});

Ajax.PeriodicalUpdater = Class.create();
Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), {
 initialize: function(container, url, options) {
 this.setOptions(options);
 this.onComplete = this.options.onComplete;

 this.frequency = (this.options.frequency || 2);
 this.decay = (this.options.decay || 1);

 this.updater = {};
 this.container = container;
 this.url = url;

 this.start();
 },

 start: function() {
 this.options.onComplete = this.updateComplete.bind(this);
 this.onTimerEvent();
 },

 stop: function() {
 this.updater.options.onComplete = undefined;
 clearTimeout(this.timer);
 (this.onComplete || Prototype.emptyFunction).apply(this, arguments);
 },

 updateComplete: function(request) {
 if (this.options.decay) {
 this.decay = (request.responseText == this.lastText ?
 this.decay * this.options.decay : 1);

 this.lastText = request.responseText;
 }
 this.timer = setTimeout(this.onTimerEvent.bind(this),
 this.decay * this.frequency * 1000);
 },

 onTimerEvent: function() {
 this.updater = new Ajax.Updater(this.container, this.url, this.options);
 }
});
function $(element) {
 if (arguments.length > 1) {
 for (var i = 0, elements = [], length = arguments.length; i < length; i++)
 elements.push($(arguments[i]));
 return elements;
 }
 if (typeof element == 'string')
 element = document.getElementById(element);
 return Element.extend(element);
}

if (Prototype.BrowserFeatures.XPath) {
 document._getElementsByXPath = function(expression, parentElement) {
 var results = [];
 var query = document.evaluate(expression, $(parentElement) || document,
 null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
 for (var i = 0, length = query.snapshotLength; i < length; i++)
 results.push(query.snapshotItem(i));
 return results;
 };

 document.getElementsByClassName = function(className, parentElement) {
 var q = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
 return document._getElementsByXPath(q, parentElement);
 }

} else document.getElementsByClassName = function(className, parentElement) {
 var children = ($(parentElement) || document.body).getElementsByTagName('*');
 var elements = [], child, pattern = new RegExp("(^|\\s)" + className + "(\\s|$)");
 for (var i = 0, length = children.length; i < length; i++) {
 child = children[i];
 var elementClassName = child.className;
 if (elementClassName.length == 0) continue;
 if (elementClassName == className || elementClassName.match(pattern))
 elements.push(Element.extend(child));
 }
 return elements;
};

/*--------------------------------------------------------------------------*/

if (!window.Element) var Element = {};

Element.extend = function(element) {
 var F = Prototype.BrowserFeatures;
 if (!element || !element.tagName || element.nodeType == 3 ||
 element._extended || F.SpecificElementExtensions || element == window)
 return element;

 var methods = {}, tagName = element.tagName, cache = Element.extend.cache,
 T = Element.Methods.ByTag;

 // extend methods for all tags (Safari doesn't need this)
 if (!F.ElementExtensions) {
 Object.extend(methods, Element.Methods),
 Object.extend(methods, Element.Methods.Simulated);
 }

 // extend methods for specific tags
 if (T[tagName]) Object.extend(methods, T[tagName]);

 for (var property in methods) {
 var value = methods[property];
 if (typeof value == 'function' && !(property in element))
 element[property] = cache.findOrStore(value);
 }

 element._extended = Prototype.emptyFunction;
 return element;
};

Element.extend.cache = {
 findOrStore: function(value) {
 return this[value] = this[value] || function() {
 return value.apply(null, [this].concat($A(arguments)));
 }
 }
};

Element.Methods = {
 visible: function(element) {
 return $(element).style.display != 'none';
 },

 toggle: function(element) {
 element = $(element);
 Element[Element.visible(element) ? 'hide' : 'show'](element);
 return element;
 },

 hide: function(element) {
 $(element).style.display = 'none';
 return element;
 },

 show: function(element) {
 $(element).style.display = '';
 return element;
 },

 remove: function(element) {
 element = $(element);
 element.parentNode.removeChild(element);
 return element;
 },

 update: function(element, html) {
 html = typeof html == 'undefined' ? '' : html.toString();
 $(element).innerHTML = html.stripScripts();
 setTimeout(function() {html.evalScripts()}, 10);
 return element;
 },

 replace: function(element, html) {
 element = $(element);
 html = typeof html == 'undefined' ? '' : html.toString();
 if (element.outerHTML) {
 element.outerHTML = html.stripScripts();
 } else {
 var range = element.ownerDocument.createRange();
 range.selectNodeContents(element);
 element.parentNode.replaceChild(
 range.createContextualFragment(html.stripScripts()), element);
 }
 setTimeout(function() {html.evalScripts()}, 10);
 return element;
 },

 inspect: function(element) {
 element = $(element);
 var result = '<' + element.tagName.toLowerCase();
 $H({'id': 'id', 'className': 'class'}).each(function(pair) {
 var property = pair.first(), attribute = pair.last();
 var value = (element[property] || '').toString();
 if (value) result += ' ' + attribute + '=' + value.inspect(true);
 });
 return result + '>';
 },

 recursivelyCollect: function(element, property) {
 element = $(element);
 var elements = [];
 while (element = element[property])
 if (element.nodeType == 1)
 elements.push(Element.extend(element));
 return elements;
 },

 ancestors: function(element) {
 return $(element).recursivelyCollect('parentNode');
 },

 descendants: function(element) {
 return $A($(element).getElementsByTagName('*')).each(Element.extend);
 },

 firstDescendant: function(element) {
 element = $(element).firstChild;
 while (element && element.nodeType != 1) element = element.nextSibling;
 return $(element);
 },

 immediateDescendants: function(element) {
 if (!(element = $(element).firstChild)) return [];
 while (element && element.nodeType != 1) element = element.nextSibling;
 if (element) return [element].concat($(element).nextSiblings());
 return [];
 },

 previousSiblings: function(element) {
 return $(element).recursivelyCollect('previousSibling');
 },

 nextSiblings: function(element) {
 return $(element).recursivelyCollect('nextSibling');
 },

 siblings: function(element) {
 element = $(element);
 return element.previousSiblings().reverse().concat(element.nextSiblings());
 },

 match: function(element, selector) {
 if (typeof selector == 'string')
 selector = new Selector(selector);
 return selector.match($(element));
 },

 up: function(element, expression, index) {
 element = $(element);
 if (arguments.length == 1) return $(element.parentNode);
 var ancestors = element.ancestors();
 return expression ? Selector.findElement(ancestors, expression, index) :
 ancestors[index || 0];
 },

 down: function(element, expression, index) {
 element = $(element);
 if (arguments.length == 1) return element.firstDescendant();
 var descendants = element.descendants();
 return expression ? Selector.findElement(descendants, expression, index) :
 descendants[index || 0];
 },

 previous: function(element, expression, index) {
 element = $(element);
 if (arguments.length == 1) return $(Selector.handlers.previousElementSibling(element));
 var previousSiblings = element.previousSiblings();
 return expression ? Selector.findElement(previousSiblings, expression, index) :
 previousSiblings[index || 0];
 },

 next: function(element, expression, index) {
 element = $(element);
 if (arguments.length == 1) return $(Selector.handlers.nextElementSibling(element));
 var nextSiblings = element.nextSiblings();
 return expression ? Selector.findElement(nextSiblings, expression, index) :
 nextSiblings[index || 0];
 },

 getElementsBySelector: function() {
 var args = $A(arguments), element = $(args.shift());
 return Selector.findChildElements(element, args);
 },

 getElementsByClassName: function(element, className) {
 return document.getElementsByClassName(className, element);
 },

 readAttribute: function(element, name) {
 element = $(element);
 if (Prototype.Browser.IE) {
 if (!element.attributes) return null;
 var t = Element._attributeTranslations;
 if (t.values[name]) return t.values[name](element, name);
 if (t.names[name]) name = t.names[name];
 var attribute = element.attributes[name];
 return attribute ? attribute.nodeValue : null;
 }
 return element.getAttribute(name);
 },

 getHeight: function(element) {
 return $(element).getDimensions().height;
 },

 getWidth: function(element) {
 return $(element).getDimensions().width;
 },

 classNames: function(element) {
 return new Element.ClassNames(element);
 },

 hasClassName: function(element, className) {
 if (!(element = $(element))) return;
 var elementClassName = element.className;
 if (elementClassName.length == 0) return false;
 if (elementClassName == className ||
 elementClassName.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
 return true;
 return false;
 },

 addClassName: function(element, className) {
 if (!(element = $(element))) return;
 Element.classNames(element).add(className);
 return element;
 },

 removeClassName: function(element, className) {
 if (!(element = $(element))) return;
 Element.classNames(element).remove(className);
 return element;
 },

 toggleClassName: function(element, className) {
 if (!(element = $(element))) return;
 Element.classNames(element)[element.hasClassName(className) ? 'remove' : 'add'](className);
 return element;
 },

 observe: function() {
 Event.observe.apply(Event, arguments);
 return $A(arguments).first();
 },

 stopObserving: function() {
 Event.stopObserving.apply(Event, arguments);
 return $A(arguments).first();
 },

 // removes whitespace-only text node children
 cleanWhitespace: function(element) {
 element = $(element);
 var node = element.firstChild;
 while (node) {
 var nextNode = node.nextSibling;
 if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
 element.removeChild(node);
 node = nextNode;
 }
 return element;
 },

 empty: function(element) {
 return $(element).innerHTML.blank();
 },

 descendantOf: function(element, ancestor) {
 element = $(element), ancestor = $(ancestor);
 while (element = element.parentNode)
 if (element == ancestor) return true;
 return false;
 },

 scrollTo: function(element) {
 element = $(element);
 var pos = Position.cumulativeOffset(element);
 window.scrollTo(pos[0], pos[1]);
 return element;
 },

 getStyle: function(element, style) {
 element = $(element);
 style = style == 'float' ? 'cssFloat' : style.camelize();
 var value = element.style[style];
 if (!value) {
 var css = document.defaultView.getComputedStyle(element, null);
 value = css ? css[style] : null;
 }
 if (style == 'opacity') return value ? parseFloat(value) : 1.0;
 return value == 'auto' ? null : value;
 },

 getOpacity: function(element) {
 return $(element).getStyle('opacity');
 },

 setStyle: function(element, styles, camelized) {
 element = $(element);
 var elementStyle = element.style;

 for (var property in styles)
 if (property == 'opacity') element.setOpacity(styles[property])
 else
 elementStyle[(property == 'float' || property == 'cssFloat') ?
 (elementStyle.styleFloat === undefined ? 'cssFloat' : 'styleFloat') :
 (camelized ? property : property.camelize())] = styles[property];

 return element;
 },

 setOpacity: function(element, value) {
 element = $(element);
 element.style.opacity = (value == 1 || value === '') ? '' :
 (value < 0.00001) ? 0 : value;
 return element;
 },

 getDimensions: function(element) {
 element = $(element);
 var display = $(element).getStyle('display');
 if (display != 'none' && display != null) // Safari bug
 return {width: element.offsetWidth, height: element.offsetHeight};

 // All *Width and *Height properties give 0 on elements with display none,
 // so enable the element temporarily
 var els = element.style;
 var originalVisibility = els.visibility;
 var originalPosition = els.position;
 var originalDisplay = els.display;
 els.visibility = 'hidden';
 els.position = 'absolute';
 els.display = 'block';
 var originalWidth = element.clientWidth;
 var originalHeight = element.clientHeight;
 els.display = originalDisplay;
 els.position = originalPosition;
 els.visibility = originalVisibility;
 return {width: originalWidth, height: originalHeight};
 },

 makePositioned: function(element) {
 element = $(element);
 var pos = Element.getStyle(element, 'position');
 if (pos == 'static' || !pos) {
 element._madePositioned = true;
 element.style.position = 'relative';
 // Opera returns the offset relative to the positioning context, when an
 // element is position relative but top and left have not been defined
 if (window.opera) {
 element.style.top = 0;
 element.style.left = 0;
 }
 }
 return element;
 },

 undoPositioned: function(element) {
 element = $(element);
 if (element._madePositioned) {
 element._madePositioned = undefined;
 element.style.position =
 element.style.top =
 element.style.left =
 element.style.bottom =
 element.style.right = '';
 }
 return element;
 },

 makeClipping: function(element) {
 element = $(element);
 if (element._overflow) return element;
 element._overflow = element.style.overflow || 'auto';
 if ((Element.getStyle(element, 'overflow') || 'visible') != 'hidden')
 element.style.overflow = 'hidden';
 return element;
 },

 undoClipping: function(element) {
 element = $(element);
 if (!element._overflow) return element;
 element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
 element._overflow = null;
 return element;
 }
};

Object.extend(Element.Methods, {
 childOf: Element.Methods.descendantOf,
 childElements: Element.Methods.immediateDescendants
});

if (Prototype.Browser.Opera) {
 Element.Methods._getStyle = Element.Methods.getStyle;
 Element.Methods.getStyle = function(element, style) {
 switch(style) {
 case 'left':
 case 'top':
 case 'right':
 case 'bottom':
 if (Element._getStyle(element, 'position') == 'static') return null;
 default: return Element._getStyle(element, style);
 }
 };
}
else if (Prototype.Browser.IE) {
 Element.Methods.getStyle = function(element, style) {
 element = $(element);
 style = (style == 'float' || style == 'cssFloat') ? 'styleFloat' : style.camelize();
 var value = element.style[style];
 if (!value && element.currentStyle) value = element.currentStyle[style];

 if (style == 'opacity') {
 if (value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
 if (value[1]) return parseFloat(value[1]) / 100;
 return 1.0;
 }

 if (value == 'auto') {
 if ((style == 'width' || style == 'height') && (element.getStyle('display') != 'none'))
 return element['offset'+style.capitalize()] + 'px';
 return null;
 }
 return value;
 };

 Element.Methods.setOpacity = function(element, value) {
 element = $(element);
 var filter = element.getStyle('filter'), style = element.style;
 if (value == 1 || value === '') {
 style.filter = filter.replace(/alpha\([^\)]*\)/gi,'');
 return element;
 } else if (value < 0.00001) value = 0;
 style.filter = filter.replace(/alpha\([^\)]*\)/gi, '') +
 'alpha(opacity=' + (value * 100) + ')';
 return element;
 };

 // IE is missing .innerHTML support for TABLE-related elements
 Element.Methods.update = function(element, html) {
 element = $(element);
 html = typeof html == 'undefined' ? '' : html.toString();
 var tagName = element.tagName.toUpperCase();
 if (['THEAD','TBODY','TR','TD'].include(tagName)) {
 var div = document.createElement('div');
 switch (tagName) {
 case 'THEAD':
 case 'TBODY':
 div.innerHTML = '<table><tbody>' + html.stripScripts() + '</tbody></table>';
 depth = 2;
 break;
 case 'TR':
 div.innerHTML = '<table><tbody><tr>' + html.stripScripts() + '</tr></tbody></table>';
 depth = 3;
 break;
 case 'TD':
 div.innerHTML = '<table><tbody><tr><td>' + html.stripScripts() + '</td></tr></tbody></table>';
 depth = 4;
 }
 $A(element.childNodes).each(function(node) { element.removeChild(node) });
 depth.times(function() { div = div.firstChild });
 $A(div.childNodes).each(function(node) { element.appendChild(node) });
 } else {
 element.innerHTML = html.stripScripts();
 }
 setTimeout(function() { html.evalScripts() }, 10);
 return element;
 }
}
else if (Prototype.Browser.Gecko) {
 Element.Methods.setOpacity = function(element, value) {
 element = $(element);
 element.style.opacity = (value == 1) ? 0.999999 :
 (value === '') ? '' : (value < 0.00001) ? 0 : value;
 return element;
 };
}

Element._attributeTranslations = {
 names: {
 colspan: "colSpan",
 rowspan: "rowSpan",
 valign: "vAlign",
 datetime: "dateTime",
 accesskey: "accessKey",
 tabindex: "tabIndex",
 enctype: "encType",
 maxlength: "maxLength",
 readonly: "readOnly",
 longdesc: "longDesc"
 },
 values: {
 _getAttr: function(element, attribute) {
 return element.getAttribute(attribute, 2);
 },
 _flag: function(element, attribute) {
 return $(element).hasAttribute(attribute) ? attribute : null;
 },
 style: function(element) {
 return element.style.cssText.toLowerCase();
 },
 title: function(element) {
 var node = element.getAttributeNode('title');
 return node.specified ? node.nodeValue : null;
 }
 }
};

(function() {
 Object.extend(this, {
 href: this._getAttr,
 src: this._getAttr,
 type: this._getAttr,
 disabled: this._flag,
 checked: this._flag,
 readonly: this._flag,
 multiple: this._flag
 });
}).call(Element._attributeTranslations.values);

Element.Methods.Simulated = {
 hasAttribute: function(element, attribute) {
 var t = Element._attributeTranslations, node;
 attribute = t.names[attribute] || attribute;
 node = $(element).getAttributeNode(attribute);
 return node && node.specified;
 }
};

Element.Methods.ByTag = {};

Object.extend(Element, Element.Methods);

if (!Prototype.BrowserFeatures.ElementExtensions &&
 document.createElement('div').__proto__) {
 window.HTMLElement = {};
 window.HTMLElement.prototype = document.createElement('div').__proto__;
 Prototype.BrowserFeatures.ElementExtensions = true;
}

Element.hasAttribute = function(element, attribute) {
 if (element.hasAttribute) return element.hasAttribute(attribute);
 return Element.Methods.Simulated.hasAttribute(element, attribute);
};

Element.addMethods = function(methods) {
 var F = Prototype.BrowserFeatures, T = Element.Methods.ByTag;

 if (!methods) {
 Object.extend(Form, Form.Methods);
 Object.extend(Form.Element, Form.Element.Methods);
 Object.extend(Element.Methods.ByTag, {
 "FORM": Object.clone(Form.Methods),
 "INPUT": Object.clone(Form.Element.Methods),
 "SELECT": Object.clone(Form.Element.Methods),
 "TEXTAREA": Object.clone(Form.Element.Methods)
 });
 }

 if (arguments.length == 2) {
 var tagName = methods;
 methods = arguments[1];
 }

 if (!tagName) Object.extend(Element.Methods, methods || {});
 else {
 if (tagName.constructor == Array) tagName.each(extend);
 else extend(tagName);
 }

 function extend(tagName) {
 tagName = tagName.toUpperCase();
 if (!Element.Methods.ByTag[tagName])
 Element.Methods.ByTag[tagName] = {};
 Object.extend(Element.Methods.ByTag[tagName], methods);
 }

 function copy(methods, destination, onlyIfAbsent) {
 onlyIfAbsent = onlyIfAbsent || false;
 var cache = Element.extend.cache;
 for (var property in methods) {
 var value = methods[property];
 if (!onlyIfAbsent || !(property in destination))
 destination[property] = cache.findOrStore(value);
 }
 }

 function findDOMClass(tagName) {
 var klass;
 var trans = {
 "OPTGROUP": "OptGroup", "TEXTAREA": "TextArea", "P": "Paragraph",
 "FIELDSET": "FieldSet", "UL": "UList", "OL": "OList", "DL": "DList",
 "DIR": "Directory", "H1": "Heading", "H2": "Heading", "H3": "Heading",
 "H4": "Heading", "H5": "Heading", "H6": "Heading", "Q": "Quote",
 "INS": "Mod", "DEL": "Mod", "A": "Anchor", "IMG": "Image", "CAPTION":
 "TableCaption", "COL": "TableCol", "COLGROUP": "TableCol", "THEAD":
 "TableSection", "TFOOT": "TableSection", "TBODY": "TableSection", "TR":
 "TableRow", "TH": "TableCell", "TD": "TableCell", "FRAMESET":
 "FrameSet", "IFRAME": "IFrame"
 };
 if (trans[tagName]) klass = 'HTML' + trans[tagName] + 'Element';
 if (window[klass]) return window[klass];
 klass = 'HTML' + tagName + 'Element';
 if (window[klass]) return window[klass];
 klass = 'HTML' + tagName.capitalize() + 'Element';
 if (window[klass]) return window[klass];

 window[klass] = {};
 window[klass].prototype = document.createElement(tagName).__proto__;
 return window[klass];
 }

 if (F.ElementExtensions) {
 copy(Element.Methods, HTMLElement.prototype);
 copy(Element.Methods.Simulated, HTMLElement.prototype, true);
 }

 if (F.SpecificElementExtensions) {
 for (var tag in Element.Methods.ByTag) {
 var klass = findDOMClass(tag);
 if (typeof klass == "undefined") continue;
 copy(T[tag], klass.prototype);
 }
 }

 Object.extend(Element, Element.Methods);
 delete Element.ByTag;
};

var Toggle = { display: Element.toggle };

/*--------------------------------------------------------------------------*/

Abstract.Insertion = function(adjacency) {
 this.adjacency = adjacency;
}

Abstract.Insertion.prototype = {
 initialize: function(element, content) {
 this.element = $(element);
 this.content = content.stripScripts();

 if (this.adjacency && this.element.insertAdjacentHTML) {
 try {
 this.element.insertAdjacentHTML(this.adjacency, this.content);
 } catch (e) {
 var tagName = this.element.tagName.toUpperCase();
 if (['TBODY', 'TR'].include(tagName)) {
 this.insertContent(this.contentFromAnonymousTable());
 } else {
 throw e;
 }
 }
 } else {
 this.range = this.element.ownerDocument.createRange();
 if (this.initializeRange) this.initializeRange();
 this.insertContent([this.range.createContextualFragment(this.content)]);
 }

 setTimeout(function() {content.evalScripts()}, 10);
 },

 contentFromAnonymousTable: function() {
 var div = document.createElement('div');
 div.innerHTML = '<table><tbody>' + this.content + '</tbody></table>';
 return $A(div.childNodes[0].childNodes[0].childNodes);
 }
}

var Insertion = new Object();

Insertion.Before = Class.create();
Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), {
 initializeRange: function() {
 this.range.setStartBefore(this.element);
 },

 insertContent: function(fragments) {
 fragments.each((function(fragment) {
 this.element.parentNode.insertBefore(fragment, this.element);
 }).bind(this));
 }
});

Insertion.Top = Class.create();
Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), {
 initializeRange: function() {
 this.range.selectNodeContents(this.element);
 this.range.collapse(true);
 },

 insertContent: function(fragments) {
 fragments.reverse(false).each((function(fragment) {
 this.element.insertBefore(fragment, this.element.firstChild);
 }).bind(this));
 }
});

Insertion.Bottom = Class.create();
Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), {
 initializeRange: function() {
 this.range.selectNodeContents(this.element);
 this.range.collapse(this.element);
 },

 insertContent: function(fragments) {
 fragments.each((function(fragment) {
 this.element.appendChild(fragment);
 }).bind(this));
 }
});

Insertion.After = Class.create();
Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), {
 initializeRange: function() {
 this.range.setStartAfter(this.element);
 },

 insertContent: function(fragments) {
 fragments.each((function(fragment) {
 this.element.parentNode.insertBefore(fragment,
 this.element.nextSibling);
 }).bind(this));
 }
});

/*--------------------------------------------------------------------------*/

Element.ClassNames = Class.create();
Element.ClassNames.prototype = {
 initialize: function(element) {
 this.element = $(element);
 },

 _each: function(iterator) {
 this.element.className.split(/\s+/).select(function(name) {
 return name.length > 0;
 })._each(iterator);
 },

 set: function(className) {
 this.element.className = className;
 },

 add: function(classNameToAdd) {
 if (this.include(classNameToAdd)) return;
 this.set($A(this).concat(classNameToAdd).join(' '));
 },

 remove: function(classNameToRemove) {
 if (!this.include(classNameToRemove)) return;
 this.set($A(this).without(classNameToRemove).join(' '));
 },

 toString: function() {
 return $A(this).join(' ');
 }
};

Object.extend(Element.ClassNames.prototype, Enumerable);
/* Portions of the Selector class are derived from Jack Slocum’s DomQuery,
 * part of YUI-Ext version 0.40, distributed under the terms of an MIT-style
 * license. Please see http://www.yui-ext.com/ for more information. */

var Selector = Class.create();

Selector.prototype = {
 initialize: function(expression) {
 this.expression = expression.strip();
 this.compileMatcher();
 },

 compileMatcher: function() {
 // Selectors with namespaced attributes can't use the XPath version
 if (Prototype.BrowserFeatures.XPath && !(/\[[\w-]*?:/).test(this.expression))
 return this.compileXPathMatcher();

 var e = this.expression, ps = Selector.patterns, h = Selector.handlers,
 c = Selector.criteria, le, p, m;

 if (Selector._cache[e]) {
 this.matcher = Selector._cache[e]; return;
 }
 this.matcher = ["this.matcher = function(root) {",
 "var r = root, h = Selector.handlers, c = false, n;"];

 while (e && le != e && (/\S/).test(e)) {
 le = e;
 for (var i in ps) {
 p = ps[i];
 if (m = e.match(p)) {
 this.matcher.push(typeof c[i] == 'function' ? c[i](m) :
 new Template(c[i]).evaluate(m));
 e = e.replace(m[0], '');
 break;
 }
 }
 }

 this.matcher.push("return h.unique(n);\n}");
 eval(this.matcher.join('\n'));
 Selector._cache[this.expression] = this.matcher;
 },

 compileXPathMatcher: function() {
 var e = this.expression, ps = Selector.patterns,
 x = Selector.xpath, le, m;

 if (Selector._cache[e]) {
 this.xpath = Selector._cache[e]; return;
 }

 this.matcher = ['.//*'];
 while (e && le != e && (/\S/).test(e)) {
 le = e;
 for (var i in ps) {
 if (m = e.match(ps[i])) {
 this.matcher.push(typeof x[i] == 'function' ? x[i](m) :
 new Template(x[i]).evaluate(m));
 e = e.replace(m[0], '');
 break;
 }
 }
 }

 this.xpath = this.matcher.join('');
 Selector._cache[this.expression] = this.xpath;
 },

 findElements: function(root) {
 root = root || document;
 if (this.xpath) return document._getElementsByXPath(this.xpath, root);
 return this.matcher(root);
 },

 match: function(element) {
 return this.findElements(document).include(element);
 },

 toString: function() {
 return this.expression;
 },

 inspect: function() {
 return "#<Selector:" + this.expression.inspect() + ">";
 }
};

Object.extend(Selector, {
 _cache: {},

 xpath: {
 descendant: "//*",
 child: "/*",
 adjacent: "/following-sibling::*[1]",
 laterSibling: '/following-sibling::*',
 tagName: function(m) {
 if (m[1] == '*') return '';
 return "[local-name()='" + m[1].toLowerCase() +
 "' or local-name()='" + m[1].toUpperCase() + "']";
 },
 className: "[contains(concat(' ', @class, ' '), ' #{1} ')]",
 id: "[@id='#{1}']",
 attrPresence: "[@#{1}]",
 attr: function(m) {
 m[3] = m[5] || m[6];
 return new Template(Selector.xpath.operators[m[2]]).evaluate(m);
 },
 pseudo: function(m) {
 var h = Selector.xpath.pseudos[m[1]];
 if (!h) return '';
 if (typeof h === 'function') return h(m);
 return new Template(Selector.xpath.pseudos[m[1]]).evaluate(m);
 },
 operators: {
 '=': "[@#{1}='#{3}']",
 '!=': "[@#{1}!='#{3}']",
 '^=': "[starts-with(@#{1}, '#{3}')]",
 '$=': "[substring(@#{1}, (string-length(@#{1}) - string-length('#{3}') + 1))='#{3}']",
 '*=': "[contains(@#{1}, '#{3}')]",
 '~=': "[contains(concat(' ', @#{1}, ' '), ' #{3} ')]",
 '|=': "[contains(concat('-', @#{1}, '-'), '-#{3}-')]"
 },
 pseudos: {
 'first-child': '[not(preceding-sibling::*)]',
 'last-child': '[not(following-sibling::*)]',
 'only-child': '[not(preceding-sibling::* or following-sibling::*)]',
 'empty': "[count(*) = 0 and (count(text()) = 0 or translate(text(), ' \t\r\n', '') = '')]",
 'checked': "[@checked]",
 'disabled': "[@disabled]",
 'enabled': "[not(@disabled)]",
 'not': function(m) {
 var e = m[6], p = Selector.patterns,
 x = Selector.xpath, le, m, v;

 var exclusion = [];
 while (e && le != e && (/\S/).test(e)) {
 le = e;
 for (var i in p) {
 if (m = e.match(p[i])) {
 v = typeof x[i] == 'function' ? x[i](m) : new Template(x[i]).evaluate(m);
 exclusion.push("(" + v.substring(1, v.length - 1) + ")");
 e = e.replace(m[0], '');
 break;
 }
 }
 }
 return "[not(" + exclusion.join(" and ") + ")]";
 },
 'nth-child': function(m) {
 return Selector.xpath.pseudos.nth("(count(./preceding-sibling::*) + 1) ", m);
 },
 'nth-last-child': function(m) {
 return Selector.xpath.pseudos.nth("(count(./following-sibling::*) + 1) ", m);
 },
 'nth-of-type': function(m) {
 return Selector.xpath.pseudos.nth("position() ", m);
 },
 'nth-last-of-type': function(m) {
 return Selector.xpath.pseudos.nth("(last() + 1 - position()) ", m);
 },
 'first-of-type': function(m) {
 m[6] = "1"; return Selector.xpath.pseudos['nth-of-type'](m);
 },
 'last-of-type': function(m) {
 m[6] = "1"; return Selector.xpath.pseudos['nth-last-of-type'](m);
 },
 'only-of-type': function(m) {
 var p = Selector.xpath.pseudos; return p['first-of-type'](m) + p['last-of-type'](m);
 },
 nth: function(fragment, m) {
 var mm, formula = m[6], predicate;
 if (formula == 'even') formula = '2n+0';
 if (formula == 'odd') formula = '2n+1';
 if (mm = formula.match(/^(\d+)$/)) // digit only
 return '[' + fragment + "= " + mm[1] + ']';
 if (mm = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
 if (mm[1] == "-") mm[1] = -1;
 var a = mm[1] ? Number(mm[1]) : 1;
 var b = mm[2] ? Number(mm[2]) : 0;
 predicate = "[((#{fragment} - #{b}) mod #{a} = 0) and " +
 "((#{fragment} - #{b}) div #{a} >= 0)]";
 return new Template(predicate).evaluate({
 fragment: fragment, a: a, b: b });
 }
 }
 }
 },

 criteria: {
 tagName: 'n = h.tagName(n, r, "#{1}", c); c = false;',
 className: 'n = h.className(n, r, "#{1}", c); c = false;',
 id: 'n = h.id(n, r, "#{1}", c); c = false;',
 attrPresence: 'n = h.attrPresence(n, r, "#{1}"); c = false;',
 attr: function(m) {
 m[3] = (m[5] || m[6]);
 return new Template('n = h.attr(n, r, "#{1}", "#{3}", "#{2}"); c = false;').evaluate(m);
 },
 pseudo: function(m) {
 if (m[6]) m[6] = m[6].replace(/"/g, '\\"');
 return new Template('n = h.pseudo(n, "#{1}", "#{6}", r, c); c = false;').evaluate(m);
 },
 descendant: 'c = "descendant";',
 child: 'c = "child";',
 adjacent: 'c = "adjacent";',
 laterSibling: 'c = "laterSibling";'
 },

 patterns: {
 // combinators must be listed first
 // (and descendant needs to be last combinator)
 laterSibling: /^\s*~\s*/,
 child: /^\s*>\s*/,
 adjacent: /^\s*\+\s*/,
 descendant: /^\s/,

 // selectors follow
 tagName: /^\s*(\*|[\w\-]+)(\b|$)?/,
 id: /^#([\w\-\*]+)(\b|$)/,
 className: /^\.([\w\-\*]+)(\b|$)/,
 pseudo: /^:((first|last|nth|nth-last|only)(-child|-of-type)|empty|checked|(en|dis)abled|not)(\((.*?)\))?(\b|$|\s|(?=:))/,
 attrPresence: /^\[([\w]+)\]/,
 attr: /\[((?:[\w-]*:)?[\w-]+)\s*(?:([!^$*~|]?=)\s*((['"])([^\]]*?)\4|([^'"][^\]]*?)))?\]/
 },

 handlers: {
 // UTILITY FUNCTIONS
 // joins two collections
 concat: function(a, b) {
 for (var i = 0, node; node = b[i]; i++)
 a.push(node);
 return a;
 },

 // marks an array of nodes for counting
 mark: function(nodes) {
 for (var i = 0, node; node = nodes[i]; i++)
 node._counted = true;
 return nodes;
 },

 unmark: function(nodes) {
 for (var i = 0, node; node = nodes[i]; i++)
 node._counted = undefined;
 return nodes;
 },

 // mark each child node with its position (for nth calls)
 // "ofType" flag indicates whether we're indexing for nth-of-type
 // rather than nth-child
 index: function(parentNode, reverse, ofType) {
 parentNode._counted = true;
 if (reverse) {
 for (var nodes = parentNode.childNodes, i = nodes.length - 1, j = 1; i >= 0; i--) {
 node = nodes[i];
 if (node.nodeType == 1 && (!ofType || node._counted)) node.nodeIndex = j++;
 }
 } else {
 for (var i = 0, j = 1, nodes = parentNode.childNodes; node = nodes[i]; i++)
 if (node.nodeType == 1 && (!ofType || node._counted)) node.nodeIndex = j++;
 }
 },

 // filters out duplicates and extends all nodes
 unique: function(nodes) {
 if (nodes.length == 0) return nodes;
 var results = [], n;
 for (var i = 0, l = nodes.length; i < l; i++)
 if (!(n = nodes[i])._counted) {
 n._counted = true;
 results.push(Element.extend(n));
 }
 return Selector.handlers.unmark(results);
 },

 // COMBINATOR FUNCTIONS
 descendant: function(nodes) {
 var h = Selector.handlers;
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 h.concat(results, node.getElementsByTagName('*'));
 return results;
 },

 child: function(nodes) {
 var h = Selector.handlers;
 for (var i = 0, results = [], node; node = nodes[i]; i++) {
 for (var j = 0, children = [], child; child = node.childNodes[j]; j++)
 if (child.nodeType == 1 && child.tagName != '!') results.push(child);
 }
 return results;
 },

 adjacent: function(nodes) {
 for (var i = 0, results = [], node; node = nodes[i]; i++) {
 var next = this.nextElementSibling(node);
 if (next) results.push(next);
 }
 return results;
 },

 laterSibling: function(nodes) {
 var h = Selector.handlers;
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 h.concat(results, Element.nextSiblings(node));
 return results;
 },

 nextElementSibling: function(node) {
 while (node = node.nextSibling)
 if (node.nodeType == 1) return node;
 return null;
 },

 previousElementSibling: function(node) {
 while (node = node.previousSibling)
 if (node.nodeType == 1) return node;
 return null;
 },

 // TOKEN FUNCTIONS
 tagName: function(nodes, root, tagName, combinator) {
 tagName = tagName.toUpperCase();
 var results = [], h = Selector.handlers;
 if (nodes) {
 if (combinator) {
 // fastlane for ordinary descendant combinators
 if (combinator == "descendant") {
 for (var i = 0, node; node = nodes[i]; i++)
 h.concat(results, node.getElementsByTagName(tagName));
 return results;
 } else nodes = this[combinator](nodes);
 if (tagName == "*") return nodes;
 }
 for (var i = 0, node; node = nodes[i]; i++)
 if (node.tagName.toUpperCase() == tagName) results.push(node);
 return results;
 } else return root.getElementsByTagName(tagName);
 },

 id: function(nodes, root, id, combinator) {
 var targetNode = $(id), h = Selector.handlers;
 if (!nodes && root == document) return targetNode ? [targetNode] : [];
 if (nodes) {
 if (combinator) {
 if (combinator == 'child') {
 for (var i = 0, node; node = nodes[i]; i++)
 if (targetNode.parentNode == node) return [targetNode];
 } else if (combinator == 'descendant') {
 for (var i = 0, node; node = nodes[i]; i++)
 if (Element.descendantOf(targetNode, node)) return [targetNode];
 } else if (combinator == 'adjacent') {
 for (var i = 0, node; node = nodes[i]; i++)
 if (Selector.handlers.previousElementSibling(targetNode) == node)
 return [targetNode];
 } else nodes = h[combinator](nodes);
 }
 for (var i = 0, node; node = nodes[i]; i++)
 if (node == targetNode) return [targetNode];
 return [];
 }
 return (targetNode && Element.descendantOf(targetNode, root)) ? [targetNode] : [];
 },

 className: function(nodes, root, className, combinator) {
 if (nodes && combinator) nodes = this[combinator](nodes);
 return Selector.handlers.byClassName(nodes, root, className);
 },

 byClassName: function(nodes, root, className) {
 if (!nodes) nodes = Selector.handlers.descendant([root]);
 var needle = ' ' + className + ' ';
 for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
 nodeClassName = node.className;
 if (nodeClassName.length == 0) continue;
 if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
 results.push(node);
 }
 return results;
 },

 attrPresence: function(nodes, root, attr) {
 var results = [];
 for (var i = 0, node; node = nodes[i]; i++)
 if (Element.hasAttribute(node, attr)) results.push(node);
 return results;
 },

 attr: function(nodes, root, attr, value, operator) {
 if (!nodes) nodes = root.getElementsByTagName("*");
 var handler = Selector.operators[operator], results = [];
 for (var i = 0, node; node = nodes[i]; i++) {
 var nodeValue = Element.readAttribute(node, attr);
 if (nodeValue === null) continue;
 if (handler(nodeValue, value)) results.push(node);
 }
 return results;
 },

 pseudo: function(nodes, name, value, root, combinator) {
 if (nodes && combinator) nodes = this[combinator](nodes);
 if (!nodes) nodes = root.getElementsByTagName("*");
 return Selector.pseudos[name](nodes, value, root);
 }
 },

 pseudos: {
 'first-child': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++) {
 if (Selector.handlers.previousElementSibling(node)) continue;
 results.push(node);
 }
 return results;
 },
 'last-child': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++) {
 if (Selector.handlers.nextElementSibling(node)) continue;
 results.push(node);
 }
 return results;
 },
 'only-child': function(nodes, value, root) {
 var h = Selector.handlers;
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 if (!h.previousElementSibling(node) && !h.nextElementSibling(node))
 results.push(node);
 return results;
 },
 'nth-child': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, formula, root);
 },
 'nth-last-child': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, formula, root, true);
 },
 'nth-of-type': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, formula, root, false, true);
 },
 'nth-last-of-type': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, formula, root, true, true);
 },
 'first-of-type': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, "1", root, false, true);
 },
 'last-of-type': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, "1", root, true, true);
 },
 'only-of-type': function(nodes, formula, root) {
 var p = Selector.pseudos;
 return p['last-of-type'](p['first-of-type'](nodes, formula, root), formula, root);
 },

 // handles the an+b logic
 getIndices: function(a, b, total) {
 if (a == 0) return b > 0 ? [b] : [];
 return $R(1, total).inject([], function(memo, i) {
 if (0 == (i - b) % a && (i - b) / a >= 0) memo.push(i);
 return memo;
 });
 },

 // handles nth(-last)-child, nth(-last)-of-type, and (first|last)-of-type
 nth: function(nodes, formula, root, reverse, ofType) {
 if (nodes.length == 0) return [];
 if (formula == 'even') formula = '2n+0';
 if (formula == 'odd') formula = '2n+1';
 var h = Selector.handlers, results = [], indexed = [], m;
 h.mark(nodes);
 for (var i = 0, node; node = nodes[i]; i++) {
 if (!node.parentNode._counted) {
 h.index(node.parentNode, reverse, ofType);
 indexed.push(node.parentNode);
 }
 }
 if (formula.match(/^\d+$/)) { // just a number
 formula = Number(formula);
 for (var i = 0, node; node = nodes[i]; i++)
 if (node.nodeIndex == formula) results.push(node);
 } else if (m = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
 if (m[1] == "-") m[1] = -1;
 var a = m[1] ? Number(m[1]) : 1;
 var b = m[2] ? Number(m[2]) : 0;
 var indices = Selector.pseudos.getIndices(a, b, nodes.length);
 for (var i = 0, node, l = indices.length; node = nodes[i]; i++) {
 for (var j = 0; j < l; j++)
 if (node.nodeIndex == indices[j]) results.push(node);
 }
 }
 h.unmark(nodes);
 h.unmark(indexed);
 return results;
 },

 'empty': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++) {
 // IE treats comments as element nodes
 if (node.tagName == '!' || (node.firstChild && !node.innerHTML.match(/^\s*$/))) continue;
 results.push(node);
 }
 return results;
 },

 'not': function(nodes, selector, root) {
 var h = Selector.handlers, selectorType, m;
 var exclusions = new Selector(selector).findElements(root);
 h.mark(exclusions);
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 if (!node._counted) results.push(node);
 h.unmark(exclusions);
 return results;
 },

 'enabled': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 if (!node.disabled) results.push(node);
 return results;
 },

 'disabled': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 if (node.disabled) results.push(node);
 return results;
 },

 'checked': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 if (node.checked) results.push(node);
 return results;
 }
 },

 operators: {
 '=': function(nv, v) { return nv == v; },
 '!=': function(nv, v) { return nv != v; },
 '^=': function(nv, v) { return nv.startsWith(v); },
 '$=': function(nv, v) { return nv.endsWith(v); },
 '*=': function(nv, v) { return nv.include(v); },
 '~=': function(nv, v) { return (' ' + nv + ' ').include(' ' + v + ' '); },
 '|=': function(nv, v) { return ('-' + nv.toUpperCase() + '-').include('-' + v.toUpperCase() + '-'); }
 },

 matchElements: function(elements, expression) {
 var matches = new Selector(expression).findElements(), h = Selector.handlers;
 h.mark(matches);
 for (var i = 0, results = [], element; element = elements[i]; i++)
 if (element._counted) results.push(element);
 h.unmark(matches);
 return results;
 },

 findElement: function(elements, expression, index) {
 if (typeof expression == 'number') {
 index = expression; expression = false;
 }
 return Selector.matchElements(elements, expression || '*')[index || 0];
 },

 findChildElements: function(element, expressions) {
 var exprs = expressions.join(','), expressions = [];
 exprs.scan(/(([\w#:.~>+()\s-]+|\*|\[.*?\])+)\s*(,|$)/, function(m) {
 expressions.push(m[1].strip());
 });
 var results = [], h = Selector.handlers;
 for (var i = 0, l = expressions.length, selector; i < l; i++) {
 selector = new Selector(expressions[i].strip());
 h.concat(results, selector.findElements(element));
 }
 return (l > 1) ? h.unique(results) : results;
 }
});

function $$() {
 return Selector.findChildElements(document, $A(arguments));
}
var Form = {
 reset: function(form) {
 $(form).reset();
 return form;
 },

 serializeElements: function(elements, getHash) {
 var data = elements.inject({}, function(result, element) {
 if (!element.disabled && element.name) {
 var key = element.name, value = $(element).getValue();
 if (value != null) {
 if (key in result) {
 if (result[key].constructor != Array) result[key] = [result[key]];
 result[key].push(value);
 }
 else result[key] = value;
 }
 }
 return result;
 });

 return getHash ? data : Hash.toQueryString(data);
 }
};

Form.Methods = {
 serialize: function(form, getHash) {
 return Form.serializeElements(Form.getElements(form), getHash);
 },

 getElements: function(form) {
 return $A($(form).getElementsByTagName('*')).inject([],
 function(elements, child) {
 if (Form.Element.Serializers[child.tagName.toLowerCase()])
 elements.push(Element.extend(child));
 return elements;
 }
 );
 },

 getInputs: function(form, typeName, name) {
 form = $(form);
 var inputs = form.getElementsByTagName('input');

 if (!typeName && !name) return $A(inputs).map(Element.extend);

 for (var i = 0, matchingInputs = [], length = inputs.length; i < length; i++) {
 var input = inputs[i];
 if ((typeName && input.type != typeName) || (name && input.name != name))
 continue;
 matchingInputs.push(Element.extend(input));
 }

 return matchingInputs;
 },

 disable: function(form) {
 form = $(form);
 Form.getElements(form).invoke('disable');
 return form;
 },

 enable: function(form) {
 form = $(form);
 Form.getElements(form).invoke('enable');
 return form;
 },

 findFirstElement: function(form) {
 return $(form).getElements().find(function(element) {
 return element.type != 'hidden' && !element.disabled &&
 ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
 });
 },

 focusFirstElement: function(form) {
 form = $(form);
 form.findFirstElement().activate();
 return form;
 },

 request: function(form, options) {
 form = $(form), options = Object.clone(options || {});

 var params = options.parameters;
 options.parameters = form.serialize(true);

 if (params) {
 if (typeof params == 'string') params = params.toQueryParams();
 Object.extend(options.parameters, params);
 }

 if (form.hasAttribute('method') && !options.method)
 options.method = form.method;

 return new Ajax.Request(form.readAttribute('action'), options);
 }
}

/*--------------------------------------------------------------------------*/

Form.Element = {
 focus: function(element) {
 $(element).focus();
 return element;
 },

 select: function(element) {
 $(element).select();
 return element;
 }
}

Form.Element.Methods = {
 serialize: function(element) {
 element = $(element);
 if (!element.disabled && element.name) {
 var value = element.getValue();
 if (value != undefined) {
 var pair = {};
 pair[element.name] = value;
 return Hash.toQueryString(pair);
 }
 }
 return '';
 },

 getValue: function(element) {
 element = $(element);
 var method = element.tagName.toLowerCase();
 return Form.Element.Serializers[method](element);
 },

 clear: function(element) {
 $(element).value = '';
 return element;
 },

 present: function(element) {
 return $(element).value != '';
 },

 activate: function(element) {
 element = $(element);
 try {
 element.focus();
 if (element.select && (element.tagName.toLowerCase() != 'input' ||
 !['button', 'reset', 'submit'].include(element.type)))
 element.select();
 } catch (e) {}
 return element;
 },

 disable: function(element) {
 element = $(element);
 element.blur();
 element.disabled = true;
 return element;
 },

 enable: function(element) {
 element = $(element);
 element.disabled = false;
 return element;
 }
}

/*--------------------------------------------------------------------------*/

var Field = Form.Element;
var $F = Form.Element.Methods.getValue;

/*--------------------------------------------------------------------------*/

Form.Element.Serializers = {
 input: function(element) {
 switch (element.type.toLowerCase()) {
 case 'checkbox':
 case 'radio':
 return Form.Element.Serializers.inputSelector(element);
 default:
 return Form.Element.Serializers.textarea(element);
 }
 },

 inputSelector: function(element) {
 return element.checked ? element.value : null;
 },

 textarea: function(element) {
 return element.value;
 },

 select: function(element) {
 return this[element.type == 'select-one' ?
 'selectOne' : 'selectMany'](element);
 },

 selectOne: function(element) {
 var index = element.selectedIndex;
 return index >= 0 ? this.optionValue(element.options[index]) : null;
 },

 selectMany: function(element) {
 var values, length = element.length;
 if (!length) return null;

 for (var i = 0, values = []; i < length; i++) {
 var opt = element.options[i];
 if (opt.selected) values.push(this.optionValue(opt));
 }
 return values;
 },

 optionValue: function(opt) {
 // extend element because hasAttribute may not be native
 return Element.extend(opt).hasAttribute('value') ? opt.value : opt.text;
 }
}

/*--------------------------------------------------------------------------*/

Abstract.TimedObserver = function() {}
Abstract.TimedObserver.prototype = {
 initialize: function(element, frequency, callback) {
 this.frequency = frequency;
 this.element = $(element);
 this.callback = callback;

 this.lastValue = this.getValue();
 this.registerCallback();
 },

 registerCallback: function() {
 setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
 },

 onTimerEvent: function() {
 var value = this.getValue();
 var changed = ('string' == typeof this.lastValue && 'string' == typeof value
 ? this.lastValue != value : String(this.lastValue) != String(value));
 if (changed) {
 this.callback(this.element, value);
 this.lastValue = value;
 }
 }
}

Form.Element.Observer = Class.create();
Form.Element.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
 getValue: function() {
 return Form.Element.getValue(this.element);
 }
});

Form.Observer = Class.create();
Form.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
 getValue: function() {
 return Form.serialize(this.element);
 }
});

/*--------------------------------------------------------------------------*/

Abstract.EventObserver = function() {}
Abstract.EventObserver.prototype = {
 initialize: function(element, callback) {
 this.element = $(element);
 this.callback = callback;

 this.lastValue = this.getValue();
 if (this.element.tagName.toLowerCase() == 'form')
 this.registerFormCallbacks();
 else
 this.registerCallback(this.element);
 },

 onElementEvent: function() {
 var value = this.getValue();
 if (this.lastValue != value) {
 this.callback(this.element, value);
 this.lastValue = value;
 }
 },

 registerFormCallbacks: function() {
 Form.getElements(this.element).each(this.registerCallback.bind(this));
 },

 registerCallback: function(element) {
 if (element.type) {
 switch (element.type.toLowerCase()) {
 case 'checkbox':
 case 'radio':
 Event.observe(element, 'click', this.onElementEvent.bind(this));
 break;
 default:
 Event.observe(element, 'change', this.onElementEvent.bind(this));
 break;
 }
 }
 }
}

Form.Element.EventObserver = Class.create();
Form.Element.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
 getValue: function() {
 return Form.Element.getValue(this.element);
 }
});

Form.EventObserver = Class.create();
Form.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
 getValue: function() {
 return Form.serialize(this.element);
 }
});
if (!window.Event) {
 var Event = new Object();
}

Object.extend(Event, {
 KEY_BACKSPACE: 8,
 KEY_TAB: 9,
 KEY_RETURN: 13,
 KEY_ESC: 27,
 KEY_LEFT: 37,
 KEY_UP: 38,
 KEY_RIGHT: 39,
 KEY_DOWN: 40,
 KEY_DELETE: 46,
 KEY_HOME: 36,
 KEY_END: 35,
 KEY_PAGEUP: 33,
 KEY_PAGEDOWN: 34,

 element: function(event) {
 return $(event.target || event.srcElement);
 },

 isLeftClick: function(event) {
 return (((event.which) && (event.which == 1)) ||
 ((event.button) && (event.button == 1)));
 },

 pointerX: function(event) {
 return event.pageX || (event.clientX +
 (document.documentElement.scrollLeft || document.body.scrollLeft));
 },

 pointerY: function(event) {
 return event.pageY || (event.clientY +
 (document.documentElement.scrollTop || document.body.scrollTop));
 },

 stop: function(event) {
 if (event.preventDefault) {
 event.preventDefault();
 event.stopPropagation();
 } else {
 event.returnValue = false;
 event.cancelBubble = true;
 }
 },

 // find the first node with the given tagName, starting from the
 // node the event was triggered on; traverses the DOM upwards
 findElement: function(event, tagName) {
 var element = Event.element(event);
 while (element.parentNode && (!element.tagName ||
 (element.tagName.toUpperCase() != tagName.toUpperCase())))
 element = element.parentNode;
 return element;
 },

 observers: false,

 _observeAndCache: function(element, name, observer, useCapture) {
 if (!this.observers) this.observers = [];
 if (element.addEventListener) {
 this.observers.push([element, name, observer, useCapture]);
 element.addEventListener(name, observer, useCapture);
 } else if (element.attachEvent) {
 this.observers.push([element, name, observer, useCapture]);
 element.attachEvent('on' + name, observer);
 }
 },

 unloadCache: function() {
 if (!Event.observers) return;
 for (var i = 0, length = Event.observers.length; i < length; i++) {
 Event.stopObserving.apply(this, Event.observers[i]);
 Event.observers[i][0] = null;
 }
 Event.observers = false;
 },

 observe: function(element, name, observer, useCapture) {
 element = $(element);
 useCapture = useCapture || false;

 if (name == 'keypress' &&
 (Prototype.Browser.WebKit || element.attachEvent))
 name = 'keydown';

 Event._observeAndCache(element, name, observer, useCapture);
 },

 stopObserving: function(element, name, observer, useCapture) {
 element = $(element);
 useCapture = useCapture || false;

 if (name == 'keypress' &&
 (Prototype.Browser.WebKit || element.attachEvent))
 name = 'keydown';

 if (element.removeEventListener) {
 element.removeEventListener(name, observer, useCapture);
 } else if (element.detachEvent) {
 try {
 element.detachEvent('on' + name, observer);
 } catch (e) {}
 }
 }
});

/* prevent memory leaks in IE */
if (Prototype.Browser.IE)
 Event.observe(window, 'unload', Event.unloadCache, false);
var Position = {
 // set to true if needed, warning: firefox performance problems
 // NOT neeeded for page scrolling, only if draggable contained in
 // scrollable elements
 includeScrollOffsets: false,

 // must be called before calling withinIncludingScrolloffset, every time the
 // page is scrolled
 prepare: function() {
 this.deltaX = window.pageXOffset
 || document.documentElement.scrollLeft
 || document.body.scrollLeft
 || 0;
 this.deltaY = window.pageYOffset
 || document.documentElement.scrollTop
 || document.body.scrollTop
 || 0;
 },

 realOffset: function(element) {
 var valueT = 0, valueL = 0;
 do {
 valueT += element.scrollTop || 0;
 valueL += element.scrollLeft || 0;
 element = element.parentNode;
 } while (element);
 return [valueL, valueT];
 },

 cumulativeOffset: function(element) {
 var valueT = 0, valueL = 0;
 do {
 valueT += element.offsetTop || 0;
 valueL += element.offsetLeft || 0;
 element = element.offsetParent;
 } while (element);
 return [valueL, valueT];
 },

 positionedOffset: function(element) {
 var valueT = 0, valueL = 0;
 do {
 valueT += element.offsetTop || 0;
 valueL += element.offsetLeft || 0;
 element = element.offsetParent;
 if (element) {
 if(element.tagName=='BODY') break;
 var p = Element.getStyle(element, 'position');
 if (p == 'relative' || p == 'absolute') break;
 }
 } while (element);
 return [valueL, valueT];
 },

 offsetParent: function(element) {
 if (element.offsetParent) return element.offsetParent;
 if (element == document.body) return element;

 while ((element = element.parentNode) && element != document.body)
 if (Element.getStyle(element, 'position') != 'static')
 return element;

 return document.body;
 },

 // caches x/y coordinate pair to use with overlap
 within: function(element, x, y) {
 if (this.includeScrollOffsets)
 return this.withinIncludingScrolloffsets(element, x, y);
 this.xcomp = x;
 this.ycomp = y;
 this.offset = this.cumulativeOffset(element);

 return (y >= this.offset[1] &&
 y < this.offset[1] + element.offsetHeight &&
 x >= this.offset[0] &&
 x < this.offset[0] + element.offsetWidth);
 },

 withinIncludingScrolloffsets: function(element, x, y) {
 var offsetcache = this.realOffset(element);

 this.xcomp = x + offsetcache[0] - this.deltaX;
 this.ycomp = y + offsetcache[1] - this.deltaY;
 this.offset = this.cumulativeOffset(element);

 return (this.ycomp >= this.offset[1] &&
 this.ycomp < this.offset[1] + element.offsetHeight &&
 this.xcomp >= this.offset[0] &&
 this.xcomp < this.offset[0] + element.offsetWidth);
 },

 // within must be called directly before
 overlap: function(mode, element) {
 if (!mode) return 0;
 if (mode == 'vertical')
 return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
 element.offsetHeight;
 if (mode == 'horizontal')
 return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
 element.offsetWidth;
 },

 page: function(forElement) {
 var valueT = 0, valueL = 0;

 var element = forElement;
 do {
 valueT += element.offsetTop || 0;
 valueL += element.offsetLeft || 0;

 // Safari fix
 if (element.offsetParent == document.body)
 if (Element.getStyle(element,'position')=='absolute') break;

 } while (element = element.offsetParent);

 element = forElement;
 do {
 if (!window.opera || element.tagName=='BODY') {
 valueT -= element.scrollTop || 0;
 valueL -= element.scrollLeft || 0;
 }
 } while (element = element.parentNode);

 return [valueL, valueT];
 },

 clone: function(source, target) {
 var options = Object.extend({
 setLeft: true,
 setTop: true,
 setWidth: true,
 setHeight: true,
 offsetTop: 0,
 offsetLeft: 0
 }, arguments[2] || {})

 // find page position of source
 source = $(source);
 var p = Position.page(source);

 // find coordinate system to use
 target = $(target);
 var delta = [0, 0];
 var parent = null;
 // delta [0,0] will do fine with position: fixed elements,
 // position:absolute needs offsetParent deltas
 if (Element.getStyle(target,'position') == 'absolute') {
 parent = Position.offsetParent(target);
 delta = Position.page(parent);
 }

 // correct by body offsets (fixes Safari)
 if (parent == document.body) {
 delta[0] -= document.body.offsetLeft;
 delta[1] -= document.body.offsetTop;
 }

 // set position
 if(options.setLeft) target.style.left = (p[0] - delta[0] + options.offsetLeft) + 'px';
 if(options.setTop) target.style.top = (p[1] - delta[1] + options.offsetTop) + 'px';
 if(options.setWidth) target.style.width = source.offsetWidth + 'px';
 if(options.setHeight) target.style.height = source.offsetHeight + 'px';
 },

 absolutize: function(element) {
 element = $(element);
 if (element.style.position == 'absolute') return;
 Position.prepare();

 var offsets = Position.positionedOffset(element);
 var top = offsets[1];
 var left = offsets[0];
 var width = element.clientWidth;
 var height = element.clientHeight;

 element._originalLeft = left - parseFloat(element.style.left || 0);
 element._originalTop = top - parseFloat(element.style.top || 0);
 element._originalWidth = element.style.width;
 element._originalHeight = element.style.height;

 element.style.position = 'absolute';
 element.style.top = top + 'px';
 element.style.left = left + 'px';
 element.style.width = width + 'px';
 element.style.height = height + 'px';
 },

 relativize: function(element) {
 element = $(element);
 if (element.style.position == 'relative') return;
 Position.prepare();

 element.style.position = 'relative';
 var top = parseFloat(element.style.top || 0) - (element._originalTop || 0);
 var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);

 element.style.top = top + 'px';
 element.style.left = left + 'px';
 element.style.height = element._originalHeight;
 element.style.width = element._originalWidth;
 }
}

// Safari returns margins on body which is incorrect if the child is absolutely
// positioned. For performance reasons, redefine Position.cumulativeOffset for
// KHTML/WebKit only.
if (Prototype.Browser.WebKit) {
 Position.cumulativeOffset = function(element) {
 var valueT = 0, valueL = 0;
 do {
 valueT += element.offsetTop || 0;
 valueL += element.offsetLeft || 0;
 if (element.offsetParent == document.body)
 if (Element.getStyle(element, 'position') == 'absolute') break;

 element = element.offsetParent;
 } while (element);

 return [valueL, valueT];
 }
}

Element.addMethods();/*
* Really easy field validation with Prototype
* http://tetlaw.id.au/view/javascript/really-easy-field-validation
* Andrew Tetlaw
* Version 1.5.4.1 (2007-01-05)
*
* Copyright (c) 2007 Andrew Tetlaw
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
var Validator = Class.create();

Validator.prototype = {
 initialize : function(className, error, test, options) {
 if(typeof test == 'function'){
 this.options = $H(options);
 this._test = test;
 } else {
 this.options = $H(test);
 this._test = function(){return true};
 }
 this.error = error || 'Validation failed.';
 this.className = className;
 },
 test : function(v, elm) {
 return (this._test(v,elm) && this.options.all(function(p){
 return Validator.methods[p.key] ? Validator.methods[p.key](v,elm,p.value) : true;
 }));
 }
}
Validator.methods = {
 pattern : function(v,elm,opt) {return Validation.get('IsEmpty').test(v) || opt.test(v)},
 minLength : function(v,elm,opt) {return v.length >= opt},
 maxLength : function(v,elm,opt) {return v.length <= opt},
 min : function(v,elm,opt) {return v >= parseFloat(opt)},
 max : function(v,elm,opt) {return v <= parseFloat(opt)},
 notOneOf : function(v,elm,opt) {return $A(opt).all(function(value) {
 return v != value;
 })},
 oneOf : function(v,elm,opt) {return $A(opt).any(function(value) {
 return v == value;
 })},
 is : function(v,elm,opt) {return v == opt},
 isNot : function(v,elm,opt) {return v != opt},
 equalToField : function(v,elm,opt) {return v == $F(opt)},
 notEqualToField : function(v,elm,opt) {return v != $F(opt)},
 include : function(v,elm,opt) {return $A(opt).all(function(value) {
 return Validation.get(value).test(v,elm);
 })}
}

var Validation = Class.create();

Validation.prototype = {
 initialize : function(form, options){
 this.form = $(form);
 if (!this.form) {
 return;
 }
 this.options = Object.extend({
 onSubmit : true,
 stopOnFirst : false,
 immediate : false,
 focusOnError : true,
 useTitles : false,
 onFormValidate : function(result, form) {},
 onElementValidate : function(result, elm) {}
 }, options || {});
 if(this.options.onSubmit) Event.observe(this.form,'submit',this.onSubmit.bind(this),false);
 if(this.options.immediate) {
 var useTitles = this.options.useTitles;
 var callback = this.options.onElementValidate;
 Form.getElements(this.form).each(function(input) { // Thanks Mike!
 Event.observe(input, 'blur', function(ev) { Validation.validate(Event.element(ev),{useTitle : useTitles, onElementValidate : callback}); });
 });
 }
 },
 onSubmit : function(ev){
 if(!this.validate()) Event.stop(ev);
 },
 validate : function() {
 var result = false;
 var useTitles = this.options.useTitles;
 var callback = this.options.onElementValidate;
 try {
 if(this.options.stopOnFirst) {
 result = Form.getElements(this.form).all(function(elm) { return Validation.validate(elm,{useTitle : useTitles, onElementValidate : callback}); });
 } else {
 result = Form.getElements(this.form).collect(function(elm) { return Validation.validate(elm,{useTitle : useTitles, onElementValidate : callback}); }).all();
 }
 } catch (e) {

 }
 if(!result && this.options.focusOnError) {
 try{
 Form.getElements(this.form).findAll(function(elm){return $(elm).hasClassName('validation-failed')}).first().focus()
 }
 catch(e){

 }
 }
 this.options.onFormValidate(result, this.form);
 return result;
 },
 reset : function() {
 Form.getElements(this.form).each(Validation.reset);
 }
}

Object.extend(Validation, {
 validate : function(elm, options){
 options = Object.extend({
 useTitle : false,
 onElementValidate : function(result, elm) {}
 }, options || {});
 elm = $(elm);
 var cn = elm.classNames();
 return result = cn.all(function(value) {
 var test = Validation.test(value,elm,options.useTitle);
 options.onElementValidate(test, elm);
 return test;
 });
 },
 insertAdvice : function(elm, advice){
 var container = $(elm).up('.field-row');
 if(container){
 new Insertion.After(container, advice);
 }
 else if (elm.advaiceContainer && $(elm.advaiceContainer)) {
 $(elm.advaiceContainer).update(advice);
 }
 else {
 switch (elm.type.toLowerCase()) {
 case 'checkbox':
 case 'radio':
 var p = elm.parentNode;
 if(p) {
 new Insertion.Bottom(p, advice);
 } else {
 new Insertion.After(elm, advice);
 }
 break;
 default:
 new Insertion.After(elm, advice);
 }
 }
 },
 showAdvice : function(elm, advice, adviceName){
 if(!elm.advices){
 elm.advices = new Hash();
 }
 else{
 elm.advices.each(function(pair){
 this.hideAdvice(elm, pair.value);
 }.bind(this));
 }
 elm.advices[adviceName] = advice;
 if(typeof Effect == 'undefined') {
 advice.style.display = 'block';
 } else {
 if(!advice._adviceAbsolutize) {
 new Effect.Appear(advice, {duration : 1 });
 } else {
 Position.absolutize(advice);
 advice.show();
 advice.setStyle({
 'top':advice._adviceTop,
 'left': advice._adviceLeft,
 'width': advice._adviceWidth,
 'z-index': 1000
 });
 advice.addClassName('advice-absolute');
 }
 }
 },
 hideAdvice : function(elm, advice){
 if(advice != null) advice.hide();
 },
 updateCallback : function(elm, status) {
 if (typeof elm.callbackFunction != 'undefined') {
 eval(elm.callbackFunction+'(\''+elm.id+'\',\''+status+'\')');
 }
 },
 ajaxError : function(elm, errorMsg) {
 var name = 'validate-ajax';
 var advice = Validation.getAdvice(name, elm);
 if (advice == null) {
 advice = this.createAdvice(name, elm, false, errorMsg);
 }
 this.showAdvice(elm, advice, 'validate-ajax');
 this.updateCallback(elm, 'failed');

 elm.addClassName('validation-failed');
 elm.addClassName('validate-ajax');
 },
 test : function(name, elm, useTitle) {
 var v = Validation.get(name);
 var prop = '__advice'+name.camelize();
 try {
 if(Validation.isVisible(elm) && !v.test($F(elm), elm)) {
 //if(!elm[prop]) {
 var advice = Validation.getAdvice(name, elm);
 if (advice == null) {
 advice = this.createAdvice(name, elm, useTitle);
 }
 this.showAdvice(elm, advice, name);
 this.updateCallback(elm, 'failed');
 //}
 elm[prop] = 1;
 if (!elm.advaiceContainer) {
 elm.removeClassName('validation-passed');
 elm.addClassName('validation-failed');
 }
 return false;
 } else {
 var advice = Validation.getAdvice(name, elm);
 this.hideAdvice(elm, advice);
 this.updateCallback(elm, 'passed');
 elm[prop] = '';
 elm.removeClassName('validation-failed');
 elm.addClassName('validation-passed');
 return true;
 }
 } catch(e) {
 throw(e)
 }
 },
 isVisible : function(elm) {
 while(elm.tagName != 'BODY') {
 if(!$(elm).visible()) return false;
 elm = elm.parentNode;
 }
 return true;
 },
 getAdvice : function(name, elm) {
 return $('advice-' + name + '-' + Validation.getElmID(elm)) || $('advice-' + Validation.getElmID(elm));
 },
 createAdvice : function(name, elm, useTitle, customError) {
 var v = Validation.get(name);
 var errorMsg = useTitle ? ((elm && elm.title) ? elm.title : v.error) : v.error;
 if (customError) {
 errorMsg = customError;
 }
 try {
 if (Translator){
 errorMsg = Translator.translate(errorMsg);
 }
 }
 catch(e){}

 advice = '<div class="validation-advice" id="advice-' + name + '-' + Validation.getElmID(elm) +'" style="display:none">' + errorMsg + '</div>'


 Validation.insertAdvice(elm, advice);
 advice = Validation.getAdvice(name, elm);
 if($(elm).hasClassName('absolute-advice')) {
 var dimensions = $(elm).getDimensions();
 var originalPosition = Position.cumulativeOffset(elm);

 advice._adviceTop = (originalPosition[1] + dimensions.height) + 'px';
 advice._adviceLeft = (originalPosition[0]) + 'px';
 advice._adviceWidth = (dimensions.width) + 'px';
 advice._adviceAbsolutize = true;
 }
 return advice;
 },
 getElmID : function(elm) {
 return elm.id ? elm.id : elm.name;
 },
 reset : function(elm) {
 elm = $(elm);
 var cn = elm.classNames();
 cn.each(function(value) {
 var prop = '__advice'+value.camelize();
 if(elm[prop]) {
 var advice = Validation.getAdvice(value, elm);
 advice.hide();
 elm[prop] = '';
 }
 elm.removeClassName('validation-failed');
 elm.removeClassName('validation-passed');
 });
 },
 add : function(className, error, test, options) {
 var nv = {};
 nv[className] = new Validator(className, error, test, options);
 Object.extend(Validation.methods, nv);
 },
 addAllThese : function(validators) {
 var nv = {};
 $A(validators).each(function(value) {
 nv[value[0]] = new Validator(value[0], value[1], value[2], (value.length > 3 ? value[3] : {}));
 });
 Object.extend(Validation.methods, nv);
 },
 get : function(name) {
 return Validation.methods[name] ? Validation.methods[name] : Validation.methods['_LikeNoIDIEverSaw_'];
 },
 methods : {
 '_LikeNoIDIEverSaw_' : new Validator('_LikeNoIDIEverSaw_','',{})
 }
});

Validation.add('IsEmpty', '', function(v) {
 return (v == '' || (v == null) || (v.length == 0) || /^\s+$/.test(v)); // || /^\s+$/.test(v));
});

Validation.addAllThese([
 ['validate-select', 'Please select an option.', function(v) {
 return ((v != "none") && (v != null) && (v.length != 0));
 }],
 ['required-entry', 'This is a required field.', function(v) {
 return !Validation.get('IsEmpty').test(v);
 }],
 ['validate-number', 'Please enter a valid number in this field.', function(v) {
 return Validation.get('IsEmpty').test(v) || (!isNaN(parseNumber(v)) && !/^\s+$/.test(parseNumber(v)));
 }],
 ['validate-digits', 'Please use numbers only in this field. please avoid spaces or other characters such as dots or commas.', function(v) {
 return Validation.get('IsEmpty').test(v) || !/[^\d]/.test(v);
 }],
 ['validate-alpha', 'Please use letters only (a-z or A-Z) in this field.', function (v) {
 return Validation.get('IsEmpty').test(v) || /^[a-zA-Z]+$/.test(v)
 }],
 ['validate-code', 'Please use only letters (a-z), numbers (0-9) or underscore(_) in this field, first character should be a letter.', function (v) {
 return Validation.get('IsEmpty').test(v) || /^[a-z]+[a-z0-9_]+$/.test(v)
 }],
 ['validate-alphanum', 'Please use only letters (a-z or A-Z) or numbers (0-9) only in this field. No spaces or other characters are allowed.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^[a-zA-Z0-9]+$/.test(v) /*!/\W/.test(v)*/
 }],
 ['validate-street', 'Please use only letters (a-z or A-Z) or numbers (0-9) or spaces and # only in this field.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^[ \w]{3,}([A-Za-z]\.)?([ \w]*\#\d+)?(\r\n| )[ \w]{3,}/.test(v)
 }],
 ['validate-phoneStrict', 'Please enter a valid phone number. For example (123) 456-7890 or 123-456-7890.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^(\()?\d{3}(\))?(-|\s)?\d{3}(-|\s)\d{4}$/.test(v);
 }],
 ['validate-phoneLax', 'Please enter a valid phone number. For example (123) 456-7890 or 123-456-7890.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^((\d[-. ]?)?((\(\d{3}\))|\d{3}))?[-. ]?\d{3}[-. ]?\d{4}$/.test(v);
 }],
 ['validate-fax', 'Please enter a valid fax number. For example (123) 456-7890 or 123-456-7890.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^(\()?\d{3}(\))?(-|\s)?\d{3}(-|\s)\d{4}$/.test(v);
 }],
 ['validate-date', 'Please enter a valid date.', function(v) {
 var test = new Date(v);
 return Validation.get('IsEmpty').test(v) || !isNaN(test);
 }],
 ['validate-email', 'Please enter a valid email address. For example johndoe@domain.com.', function (v) {
 //return Validation.get('IsEmpty').test(v) || /\w{1,}[@][\w\-]{1,}([.]([\w\-]{1,})){1,3}$/.test(v)
 //return Validation.get('IsEmpty').test(v) || /^[\!\#$%\*/?|\^\{\}`~&\'\+\-=_a-z0-9][\!\#$%\*/?|\^\{\}`~&\'\+\-=_a-z0-9\.]{1,30}[\!\#$%\*/?|\^\{\}`~&\'\+\-=_a-z0-9]@([a-z0-9_-]{1,30}\.){1,5}[a-z]{2,4}$/i.test(v)
 return Validation.get('IsEmpty').test(v) || /^[a-z0-9,!\#\$%&'\*\+/=\?\^_`\{\|}~-]+(\.[a-z0-9,!#\$%&'\*\+/=\?\^_`\{\|}~-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*\.([a-z]{2,})/i.test(v)
 }],
 ['validate-password', 'Please enter 6 or more characters. Leading or trailing spaces will be ignored.', function(v) {
 var pass=v.strip(); /*strip leading and trailing spaces*/
 return !(pass.length>0 && pass.length < 6);
 }],
 ['validate-cpassword', 'Please make sure your passwords match.', function(v) {
 var pass = $('password') ? $('password') : $$('.validate-password')[0];
 var conf = $('confirmation') ? $('confirmation') : $$('.validate-cpassword')[0];
 return (pass.value == conf.value);
 }],
 ['validate-url', 'Please enter a valid URL. http:// is required', function (v) {
 return Validation.get('IsEmpty').test(v) || /^(http|https|ftp):\/\/(([A-Z0-9][A-Z0-9_-]*)(\.[A-Z0-9][A-Z0-9_-]*)+)(:(\d+))?\/?/i.test(v)
 }],
 ['validate-clean-url', 'Please enter a valid URL. For example http://www.example.com or www.example.com', function (v) {
 return Validation.get('IsEmpty').test(v) || /^(http|https|ftp):\/\/(([A-Z0-9][A-Z0-9_-]*)(\.[A-Z0-9][A-Z0-9_-]*)+.(com|org|net|dk|at|us|tv|info|uk|co.uk|biz|se)$)(:(\d+))?\/?/i.test(v) || /^(www)((\.[A-Z0-9][A-Z0-9_-]*)+.(com|org|net|dk|at|us|tv|info|uk|co.uk|biz|se)$)(:(\d+))?\/?/i.test(v)
 }],
 ['validate-identifier', 'Please enter a valid Identifier. For example example-page, example-page.html or anotherlevel/example-page', function (v) {
 return Validation.get('IsEmpty').test(v) || /^[A-Z0-9][A-Z0-9_\/-]+(\.[A-Z0-9_-]+)*$/i.test(v)
 }],
 ['validate-xml-identifier', 'Please enter a valid XML-identifier. For example something_1, block5, id-4', function (v) {
 return Validation.get('IsEmpty').test(v) || /^[A-Z][A-Z0-9_\/-]*$/i.test(v)
 }],
 ['validate-ssn', 'Please enter a valid social security number. For example 123-45-6789.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^\d{3}-?\d{2}-?\d{4}$/.test(v);
 }],
 ['validate-zip', 'Please enter a valid zip code. For example 90602 or 90602-1234.', function(v) {
 return Validation.get('IsEmpty').test(v) || /(^\d{5}$)|(^\d{5}-\d{4}$)/.test(v);
 }],
 ['validate-zip-international', 'Please enter a valid zip code.', function(v) {
 //return Validation.get('IsEmpty').test(v) || /(^[A-z0-9]{2,10}([\s]{0,1}|[\-]{0,1})[A-z0-9]{2,10}$)/.test(v);
 return true;
 }],
 ['validate-date-au', 'Please use this date format: dd/mm/yyyy. For example 17/03/2006 for the 17th of March, 2006.', function(v) {
 if(Validation.get('IsEmpty').test(v)) return true;
 var regex = /^(\d{2})\/(\d{2})\/(\d{4})$/;
 if(!regex.test(v)) return false;
 var d = new Date(v.replace(regex, '$2/$1/$3'));
 return ( parseInt(RegExp.$2, 10) == (1+d.getMonth()) ) &&
 (parseInt(RegExp.$1, 10) == d.getDate()) &&
 (parseInt(RegExp.$3, 10) == d.getFullYear() );
 }],
 ['validate-currency-dollar', 'Please enter a valid $ amount. For example $100.00.', function(v) {
 // [$]1[##][,###]+[.##]
 // [$]1###+[.##]
 // [$]0.##
 // [$].##
 return Validation.get('IsEmpty').test(v) || /^\$?\-?([1-9]{1}[0-9]{0,2}(\,[0-9]{3})*(\.[0-9]{0,2})?|[1-9]{1}\d*(\.[0-9]{0,2})?|0(\.[0-9]{0,2})?|(\.[0-9]{1,2})?)$/.test(v)
 }],
 ['validate-one-required', 'Please select one of the above options.', function (v,elm) {
 var p = elm.parentNode;
 var options = p.getElementsByTagName('INPUT');
 return $A(options).any(function(elm) {
 return $F(elm);
 });
 }],
 ['validate-one-required-by-name', 'Please select one of the options.', function (v,elm) {
 var inputs = $$('input');
 var error = 1;
 for( i in inputs ) {
 if( inputs[i].checked == true && inputs[i].name == elm.name ) {
 error = 0;
 }
 }

 if( error == 0 ) {
 return true;
 } else {
 return false;
 }
 }],
 ['validate-not-negative-number', 'Please enter a valid number in this field.', function(v) {
 v = parseNumber(v);
 return (!isNaN(v) && v>=0);
 }],
 ['validate-state', 'Please select State/Province.', function(v) {
 return (v!=0 || v == '');
 }],

 ['validate-new-password', 'Please enter 6 or more characters. Leading or trailing spaces will be ignored.', function(v) {
 if (!Validation.get('validate-password').test(v)) return false;
 if (Validation.get('IsEmpty').test(v) && v != '') return false;
 return true;
 }],
 ['validate-greater-than-zero', 'Please enter a number greater than 0 in this field.', function(v) {
 if(v.length)
 return parseFloat(v) > 0;
 else
 return true;
 }],
 ['validate-zero-or-greater', 'Please enter a number 0 or greater in this field.', function(v) {
 if(v.length)
 return parseFloat(v) >= 0;
 else
 return true;
 }],
 ['validate-cc-number', 'Please enter a valid credit card number.', function(v, elm) {
 // remove non-numerics
 var ccTypeContainer = $(elm.id.substr(0,elm.id.indexOf('_cc_number')) + '_cc_type');
 if (ccTypeContainer && typeof Validation.creditCartTypes[ccTypeContainer.value] != 'undefined'
 && Validation.creditCartTypes[ccTypeContainer.value][2] == false) {
 if (!Validation.get('IsEmpty').test(v) && Validation.get('validate-digits').test(v)) {
 return true;
 } else {
 return false;
 }
 }
 return validateCreditCard(v);
 }],
 ['validate-cc-type', 'Credit card number doesn\'t match credit card type', function(v, elm) {
 // remove credit card number delimiters such as "-" and space
 elm.value = removeDelimiters(elm.value);
 v = removeDelimiters(v);

 var ccTypeContainer = $(elm.id.substr(0,elm.id.indexOf('_cc_number')) + '_cc_type');
 if (!ccTypeContainer) {
 return true;
 }
 var ccType = ccTypeContainer.value;

 if (typeof Validation.creditCartTypes[ccType] == 'undefined') {
 return false;
 }

 // Other card type or switch or solo card
 if (Validation.creditCartTypes[ccType][0]==false) {
 return true;
 }

 // Matched credit card type
 var ccMatchedType = '';

 Validation.creditCartTypes.each(function (pair) {
 if (pair.value[0] && v.match(pair.value[0])) {
 ccMatchedType = pair.key;
 throw $break;
 }
 });

 if(ccMatchedType != ccType) {
 return false;
 }

 return true;
 }],
 ['validate-cc-type-select', 'Card type doesn\'t match credit card number', function(v, elm) {
 var ccNumberContainer = $(elm.id.substr(0,elm.id.indexOf('_cc_type')) + '_cc_number');
 return Validation.get('validate-cc-type').test(ccNumberContainer.value, ccNumberContainer);
 }],
 ['validate-cc-exp', 'Incorrect credit card expiration date', function(v, elm) {
 var ccExpMonth = v;
 var ccExpYear = $('ccsave_expiration_yr').value;
 var currentTime = new Date();
 var currentMonth = currentTime.getMonth() + 1;
 var currentYear = currentTime.getFullYear();
 if (ccExpMonth < currentMonth && ccExpYear == currentYear) {
 return false;
 }
 return true;
 }],
 ['validate-cc-cvn', 'Please enter a valid credit card verification number.', function(v, elm) {
 var ccTypeContainer = $(elm.id.substr(0,elm.id.indexOf('_cc_cid')) + '_cc_type');
 if (!ccTypeContainer) {
 return true;
 }
 var ccType = ccTypeContainer.value;

 if (typeof Validation.creditCartTypes[ccType] == 'undefined') {
 return false;
 }

 var re = Validation.creditCartTypes[ccType][1];

 if (v.match(re)) {
 return true;
 }

 return false;
 }],
 ['validate-ajax', '', function(v, elm) { return true; }],
 ['validate-data', 'Please use only letters (a-z or A-Z), numbers (0-9) or underscore(_) in this field, first character should be a letter.', function (v) {
 if(v != '' && v) {
 return /^[A-Za-z]+[A-Za-z0-9_]+$/.test(v);
 }
 return true;
 }],
 ['validate-css-length', 'Please input a valid CSS-length. For example 100px or 77pt or 20em or .5ex or 50%', function (v) {
 if (v != '' && v) {
 return /^[0-9\.]+(px|pt|em|ex|%)?$/.test(v) && (!(/\..*\./.test(v))) && !(/\.$/.test(v));
 }
 return true;
 }]
]);


// Credit Card Validation Javascript
// copyright 12th May 2003, by Stephen Chapman, Felgall Pty Ltd

// You have permission to copy and use this javascript provided that
// the content of the script is not changed in any way.

function validateCreditCard(s) {
 // remove non-numerics
 var v = "0123456789";
 var w = "";
 for (i=0; i < s.length; i++) {
 x = s.charAt(i);
 if (v.indexOf(x,0) != -1)
 w += x;
 }
 // validate number
 j = w.length / 2;
 k = Math.floor(j);
 m = Math.ceil(j) - k;
 c = 0;
 for (i=0; i<k; i++) {
 a = w.charAt(i*2+m) * 2;
 c += a > 9 ? Math.floor(a/10 + a%10) : a;
 }
 for (i=0; i<k+m; i++) c += w.charAt(i*2+1-m) * 1;
 return (c%10 == 0);
}

function removeDelimiters (v) {
 v = v.replace(/\s/g, '');
 v = v.replace(/\-/g, '');
 return v;
}

function parseNumber(v)
{
 if (typeof v != 'string') {
 return parseFloat(v);
 }

 var isDot = v.indexOf('.');
 var isComa = v.indexOf(',');

 if (isDot != -1 && isComa != -1) {
 if (isComa > isDot) {
 v = v.replace('.', '').replace(',', '.');
 }
 else {
 v = v.replace(',', '');
 }
 }
 else if (isComa != -1) {
 v = v.replace(',', '.');
 }

 return parseFloat(v);
}

/**
 * Hash with credit card types wich can be simply extended in payment modules
 * 0 - regexp for card number
 * 1 - regexp for cvn
 * 2 - check or not credit card number trough Luhn algorithm by
 * function validateCreditCard wich you can find above in this file
 */
Validation.creditCartTypes = $H({
 'VI': [new RegExp('^4[0-9]{12}([0-9]{3})?$'), new RegExp('^[0-9]{3}$'), true],
 'MC': [new RegExp('^5[1-5][0-9]{14}$'), new RegExp('^[0-9]{3}$'), true],
 'AE': [new RegExp('^3[47][0-9]{13}$'), new RegExp('^[0-9]{4}$'), true],
 'DI': [new RegExp('^6011[0-9]{12}$'), new RegExp('^[0-9]{3}$'), true],
 'SS': [new RegExp('^((6759[0-9]{12})|(49[013][1356][0-9]{13})|(633[34][0-9]{12})|(633110[0-9]{10})|(564182[0-9]{10}))([0-9]{2,3})?$'), new RegExp('^([0-9]{3}|[0-9]{4})?$'), true],
 'OT': [false, new RegExp('^([0-9]{3}|[0-9]{4})?$'), false]
});
// script.aculo.us builder.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007

// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
//
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

var Builder = {
 NODEMAP: {
 AREA: 'map',
 CAPTION: 'table',
 COL: 'table',
 COLGROUP: 'table',
 LEGEND: 'fieldset',
 OPTGROUP: 'select',
 OPTION: 'select',
 PARAM: 'object',
 TBODY: 'table',
 TD: 'table',
 TFOOT: 'table',
 TH: 'table',
 THEAD: 'table',
 TR: 'table'
 },
 // note: For Firefox < 1.5, OPTION and OPTGROUP tags are currently broken,
 // due to a Firefox bug
 node: function(elementName) {
 elementName = elementName.toUpperCase();
 
 // try innerHTML approach
 var parentTag = this.NODEMAP[elementName] || 'div';
 var parentElement = document.createElement(parentTag);
 try { // prevent IE "feature": http://dev.rubyonrails.org/ticket/2707
 parentElement.innerHTML = "<" + elementName + "></" + elementName + ">";
 } catch(e) {}
 var element = parentElement.firstChild || null;
 
 // see if browser added wrapping tags
 if(element && (element.tagName.toUpperCase() != elementName))
 element = element.getElementsByTagName(elementName)[0];
 
 // fallback to createElement approach
 if(!element) element = document.createElement(elementName);
 
 // abort if nothing could be created
 if(!element) return;

 // attributes (or text)
 if(arguments[1])
 if(this._isStringOrNumber(arguments[1]) ||
 (arguments[1] instanceof Array) ||
 arguments[1].tagName) {
 this._children(element, arguments[1]);
 } else {
 var attrs = this._attributes(arguments[1]);
 if(attrs.length) {
 try { // prevent IE "feature": http://dev.rubyonrails.org/ticket/2707
 parentElement.innerHTML = "<" +elementName + " " +
 attrs + "></" + elementName + ">";
 } catch(e) {}
 element = parentElement.firstChild || null;
 // workaround firefox 1.0.X bug
 if(!element) {
 element = document.createElement(elementName);
 for(attr in arguments[1]) 
 element[attr == 'class' ? 'className' : attr] = arguments[1][attr];
 }
 if(element.tagName.toUpperCase() != elementName)
 element = parentElement.getElementsByTagName(elementName)[0];
 }
 } 

 // text, or array of children
 if(arguments[2])
 this._children(element, arguments[2]);

 return element;
 },
 _text: function(text) {
 return document.createTextNode(text);
 },

 ATTR_MAP: {
 'className': 'class',
 'htmlFor': 'for'
 },

 _attributes: function(attributes) {
 var attrs = [];
 for(attribute in attributes)
 attrs.push((attribute in this.ATTR_MAP ? this.ATTR_MAP[attribute] : attribute) +
 '="' + attributes[attribute].toString().escapeHTML().gsub(/"/,'&quot;') + '"');
 return attrs.join(" ");
 },
 _children: function(element, children) {
 if(children.tagName) {
 element.appendChild(children);
 return;
 }
 if(typeof children=='object') { // array can hold nodes and text
 children.flatten().each( function(e) {
 if(typeof e=='object')
 element.appendChild(e)
 else
 if(Builder._isStringOrNumber(e))
 element.appendChild(Builder._text(e));
 });
 } else
 if(Builder._isStringOrNumber(children))
 element.appendChild(Builder._text(children));
 },
 _isStringOrNumber: function(param) {
 return(typeof param=='string' || typeof param=='number');
 },
 build: function(html) {
 var element = this.node('div');
 $(element).update(html.strip());
 return element.down();
 },
 dump: function(scope) { 
 if(typeof scope != 'object' && typeof scope != 'function') scope = window; //global scope 
 
 var tags = ("A ABBR ACRONYM ADDRESS APPLET AREA B BASE BASEFONT BDO BIG BLOCKQUOTE BODY " +
 "BR BUTTON CAPTION CENTER CITE CODE COL COLGROUP DD DEL DFN DIR DIV DL DT EM FIELDSET " +
 "FONT FORM FRAME FRAMESET H1 H2 H3 H4 H5 H6 HEAD HR HTML I IFRAME IMG INPUT INS ISINDEX "+
 "KBD LABEL LEGEND LI LINK MAP MENU META NOFRAMES NOSCRIPT OBJECT OL OPTGROUP OPTION P "+
 "PARAM PRE Q S SAMP SCRIPT SELECT SMALL SPAN STRIKE STRONG STYLE SUB SUP TABLE TBODY TD "+
 "TEXTAREA TFOOT TH THEAD TITLE TR TT U UL VAR").split(/\s+/);
 
 tags.each( function(tag){ 
 scope[tag] = function() { 
 return Builder.node.apply(Builder, [tag].concat($A(arguments))); 
 } 
 });
 }
}
// script.aculo.us effects.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007

// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// Contributors:
// Justin Palmer (http://encytemedia.com/)
// Mark Pilgrim (http://diveintomark.org/)
// Martin Bialasinki
// 
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/ 

// converts rgb() and #xxx to #xxxxxx format, 
// returns self (or first argument) if not convertable 
String.prototype.parseColor = function() { 
 var color = '#';
 if(this.slice(0,4) == 'rgb(') { 
 var cols = this.slice(4,this.length-1).split(','); 
 var i=0; do { color += parseInt(cols[i]).toColorPart() } while (++i<3); 
 } else { 
 if(this.slice(0,1) == '#') { 
 if(this.length==4) for(var i=1;i<4;i++) color += (this.charAt(i) + this.charAt(i)).toLowerCase(); 
 if(this.length==7) color = this.toLowerCase(); 
 } 
 } 
 return(color.length==7 ? color : (arguments[0] || this)); 
}

/*--------------------------------------------------------------------------*/

Element.collectTextNodes = function(element) { 
 return $A($(element).childNodes).collect( function(node) {
 return (node.nodeType==3 ? node.nodeValue : 
 (node.hasChildNodes() ? Element.collectTextNodes(node) : ''));
 }).flatten().join('');
}

Element.collectTextNodesIgnoreClass = function(element, className) { 
 return $A($(element).childNodes).collect( function(node) {
 return (node.nodeType==3 ? node.nodeValue : 
 ((node.hasChildNodes() && !Element.hasClassName(node,className)) ? 
 Element.collectTextNodesIgnoreClass(node, className) : ''));
 }).flatten().join('');
}

Element.setContentZoom = function(element, percent) {
 element = $(element); 
 element.setStyle({fontSize: (percent/100) + 'em'}); 
 if(Prototype.Browser.WebKit) window.scrollBy(0,0);
 return element;
}

Element.getInlineOpacity = function(element){
 return $(element).style.opacity || '';
}

Element.forceRerendering = function(element) {
 try {
 element = $(element);
 var n = document.createTextNode(' ');
 element.appendChild(n);
 element.removeChild(n);
 } catch(e) { }
};

/*--------------------------------------------------------------------------*/

Array.prototype.call = function() {
 var args = arguments;
 this.each(function(f){ f.apply(this, args) });
}

/*--------------------------------------------------------------------------*/

var Effect = {
 _elementDoesNotExistError: {
 name: 'ElementDoesNotExistError',
 message: 'The specified DOM element does not exist, but is required for this effect to operate'
 },
 tagifyText: function(element) {
 if(typeof Builder == 'undefined')
 throw("Effect.tagifyText requires including script.aculo.us' builder.js library");
 
 var tagifyStyle = 'position:relative';
 if(Prototype.Browser.IE) tagifyStyle += ';zoom:1';
 
 element = $(element);
 $A(element.childNodes).each( function(child) {
 if(child.nodeType==3) {
 child.nodeValue.toArray().each( function(character) {
 element.insertBefore(
 Builder.node('span',{style: tagifyStyle},
 character == ' ' ? String.fromCharCode(160) : character), 
 child);
 });
 Element.remove(child);
 }
 });
 },
 multiple: function(element, effect) {
 var elements;
 if(((typeof element == 'object') || 
 (typeof element == 'function')) && 
 (element.length))
 elements = element;
 else
 elements = $(element).childNodes;
 
 var options = Object.extend({
 speed: 0.1,
 delay: 0.0
 }, arguments[2] || {});
 var masterDelay = options.delay;

 $A(elements).each( function(element, index) {
 new effect(element, Object.extend(options, { delay: index * options.speed + masterDelay }));
 });
 },
 PAIRS: {
 'slide': ['SlideDown','SlideUp'],
 'blind': ['BlindDown','BlindUp'],
 'appear': ['Appear','Fade']
 },
 toggle: function(element, effect) {
 element = $(element);
 effect = (effect || 'appear').toLowerCase();
 var options = Object.extend({
 queue: { position:'end', scope:(element.id || 'global'), limit: 1 }
 }, arguments[2] || {});
 Effect[element.visible() ? 
 Effect.PAIRS[effect][1] : Effect.PAIRS[effect][0]](element, options);
 }
};

var Effect2 = Effect; // deprecated

/* ------------- transitions ------------- */

Effect.Transitions = {
 linear: Prototype.K,
 sinoidal: function(pos) {
 return (-Math.cos(pos*Math.PI)/2) + 0.5;
 },
 reverse: function(pos) {
 return 1-pos;
 },
 flicker: function(pos) {
 var pos = ((-Math.cos(pos*Math.PI)/4) + 0.75) + Math.random()/4;
 return (pos > 1 ? 1 : pos);
 },
 wobble: function(pos) {
 return (-Math.cos(pos*Math.PI*(9*pos))/2) + 0.5;
 },
 pulse: function(pos, pulses) { 
 pulses = pulses || 5; 
 return (
 Math.round((pos % (1/pulses)) * pulses) == 0 ? 
 ((pos * pulses * 2) - Math.floor(pos * pulses * 2)) : 
 1 - ((pos * pulses * 2) - Math.floor(pos * pulses * 2))
 );
 },
 none: function(pos) {
 return 0;
 },
 full: function(pos) {
 return 1;
 }
};

/* ------------- core effects ------------- */

Effect.ScopedQueue = Class.create();
Object.extend(Object.extend(Effect.ScopedQueue.prototype, Enumerable), {
 initialize: function() {
 this.effects = [];
 this.interval = null; 
 },
 _each: function(iterator) {
 this.effects._each(iterator);
 },
 add: function(effect) {
 var timestamp = new Date().getTime();
 
 var position = (typeof effect.options.queue == 'string') ? 
 effect.options.queue : effect.options.queue.position;
 
 switch(position) {
 case 'front':
 // move unstarted effects after this effect 
 this.effects.findAll(function(e){ return e.state=='idle' }).each( function(e) {
 e.startOn += effect.finishOn;
 e.finishOn += effect.finishOn;
 });
 break;
 case 'with-last':
 timestamp = this.effects.pluck('startOn').max() || timestamp;
 break;
 case 'end':
 // start effect after last queued effect has finished
 timestamp = this.effects.pluck('finishOn').max() || timestamp;
 break;
 }
 
 effect.startOn += timestamp;
 effect.finishOn += timestamp;

 if(!effect.options.queue.limit || (this.effects.length < effect.options.queue.limit))
 this.effects.push(effect);
 
 if(!this.interval)
 this.interval = setInterval(this.loop.bind(this), 15);
 },
 remove: function(effect) {
 this.effects = this.effects.reject(function(e) { return e==effect });
 if(this.effects.length == 0) {
 clearInterval(this.interval);
 this.interval = null;
 }
 },
 loop: function() {
 var timePos = new Date().getTime();
 for(var i=0, len=this.effects.length;i<len;i++) 
 this.effects[i] && this.effects[i].loop(timePos);
 }
});

Effect.Queues = {
 instances: $H(),
 get: function(queueName) {
 if(typeof queueName != 'string') return queueName;
 
 if(!this.instances[queueName])
 this.instances[queueName] = new Effect.ScopedQueue();
 
 return this.instances[queueName];
 }
}
Effect.Queue = Effect.Queues.get('global');

Effect.DefaultOptions = {
 transition: Effect.Transitions.sinoidal,
 duration: 1.0, // seconds
 fps: 100, // 100= assume 66fps max.
 sync: false, // true for combining
 from: 0.0,
 to: 1.0,
 delay: 0.0,
 queue: 'parallel'
}

Effect.Base = function() {};
Effect.Base.prototype = {
 position: null,
 start: function(options) {
 function codeForEvent(options,eventName){
 return (
 (options[eventName+'Internal'] ? 'this.options.'+eventName+'Internal(this);' : '') +
 (options[eventName] ? 'this.options.'+eventName+'(this);' : '')
 );
 }
 if(options.transition === false) options.transition = Effect.Transitions.linear;
 this.options = Object.extend(Object.extend({},Effect.DefaultOptions), options || {});
 this.currentFrame = 0;
 this.state = 'idle';
 this.startOn = this.options.delay*1000;
 this.finishOn = this.startOn+(this.options.duration*1000);
 this.fromToDelta = this.options.to-this.options.from;
 this.totalTime = this.finishOn-this.startOn;
 this.totalFrames = this.options.fps*this.options.duration;
 
 eval('this.render = function(pos){ '+
 'if(this.state=="idle"){this.state="running";'+
 codeForEvent(options,'beforeSetup')+
 (this.setup ? 'this.setup();':'')+ 
 codeForEvent(options,'afterSetup')+
 '};if(this.state=="running"){'+
 'pos=this.options.transition(pos)*'+this.fromToDelta+'+'+this.options.from+';'+
 'this.position=pos;'+
 codeForEvent(options,'beforeUpdate')+
 (this.update ? 'this.update(pos);':'')+
 codeForEvent(options,'afterUpdate')+
 '}}');
 
 this.event('beforeStart');
 if(!this.options.sync)
 Effect.Queues.get(typeof this.options.queue == 'string' ? 
 'global' : this.options.queue.scope).add(this);
 },
 loop: function(timePos) {
 if(timePos >= this.startOn) {
 if(timePos >= this.finishOn) {
 this.render(1.0);
 this.cancel();
 this.event('beforeFinish');
 if(this.finish) this.finish(); 
 this.event('afterFinish');
 return; 
 }
 var pos = (timePos - this.startOn) / this.totalTime,
 frame = Math.round(pos * this.totalFrames);
 if(frame > this.currentFrame) {
 this.render(pos);
 this.currentFrame = frame;
 }
 }
 },
 cancel: function() {
 if(!this.options.sync)
 Effect.Queues.get(typeof this.options.queue == 'string' ? 
 'global' : this.options.queue.scope).remove(this);
 this.state = 'finished';
 },
 event: function(eventName) {
 if(this.options[eventName + 'Internal']) this.options[eventName + 'Internal'](this);
 if(this.options[eventName]) this.options[eventName](this);
 },
 inspect: function() {
 var data = $H();
 for(property in this)
 if(typeof this[property] != 'function') data[property] = this[property];
 return '#<Effect:' + data.inspect() + ',options:' + $H(this.options).inspect() + '>';
 }
}

Effect.Parallel = Class.create();
Object.extend(Object.extend(Effect.Parallel.prototype, Effect.Base.prototype), {
 initialize: function(effects) {
 this.effects = effects || [];
 this.start(arguments[1]);
 },
 update: function(position) {
 this.effects.invoke('render', position);
 },
 finish: function(position) {
 this.effects.each( function(effect) {
 effect.render(1.0);
 effect.cancel();
 effect.event('beforeFinish');
 if(effect.finish) effect.finish(position);
 effect.event('afterFinish');
 });
 }
});

Effect.Event = Class.create();
Object.extend(Object.extend(Effect.Event.prototype, Effect.Base.prototype), {
 initialize: function() {
 var options = Object.extend({
 duration: 0
 }, arguments[0] || {});
 this.start(options);
 },
 update: Prototype.emptyFunction
});

Effect.Opacity = Class.create();
Object.extend(Object.extend(Effect.Opacity.prototype, Effect.Base.prototype), {
 initialize: function(element) {
 this.element = $(element);
 if(!this.element) throw(Effect._elementDoesNotExistError);
 // make this work on IE on elements without 'layout'
 if(Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
 this.element.setStyle({zoom: 1});
 var options = Object.extend({
 from: this.element.getOpacity() || 0.0,
 to: 1.0
 }, arguments[1] || {});
 this.start(options);
 },
 update: function(position) {
 this.element.setOpacity(position);
 }
});

Effect.Move = Class.create();
Object.extend(Object.extend(Effect.Move.prototype, Effect.Base.prototype), {
 initialize: function(element) {
 this.element = $(element);
 if(!this.element) throw(Effect._elementDoesNotExistError);
 var options = Object.extend({
 x: 0,
 y: 0,
 mode: 'relative'
 }, arguments[1] || {});
 this.start(options);
 },
 setup: function() {
 // Bug in Opera: Opera returns the "real" position of a static element or
 // relative element that does not have top/left explicitly set.
 // ==> Always set top and left for position relative elements in your stylesheets 
 // (to 0 if you do not need them) 
 this.element.makePositioned();
 this.originalLeft = parseFloat(this.element.getStyle('left') || '0');
 this.originalTop = parseFloat(this.element.getStyle('top') || '0');
 if(this.options.mode == 'absolute') {
 // absolute movement, so we need to calc deltaX and deltaY
 this.options.x = this.options.x - this.originalLeft;
 this.options.y = this.options.y - this.originalTop;
 }
 },
 update: function(position) {
 this.element.setStyle({
 left: Math.round(this.options.x * position + this.originalLeft) + 'px',
 top: Math.round(this.options.y * position + this.originalTop) + 'px'
 });
 }
});

// for backwards compatibility
Effect.MoveBy = function(element, toTop, toLeft) {
 return new Effect.Move(element, 
 Object.extend({ x: toLeft, y: toTop }, arguments[3] || {}));
};

Effect.Scale = Class.create();
Object.extend(Object.extend(Effect.Scale.prototype, Effect.Base.prototype), {
 initialize: function(element, percent) {
 this.element = $(element);
 if(!this.element) throw(Effect._elementDoesNotExistError);
 var options = Object.extend({
 scaleX: true,
 scaleY: true,
 scaleContent: true,
 scaleFromCenter: false,
 scaleMode: 'box', // 'box' or 'contents' or {} with provided values
 scaleFrom: 100.0,
 scaleTo: percent
 }, arguments[2] || {});
 this.start(options);
 },
 setup: function() {
 this.restoreAfterFinish = this.options.restoreAfterFinish || false;
 this.elementPositioning = this.element.getStyle('position');
 
 this.originalStyle = {};
 ['top','left','width','height','fontSize'].each( function(k) {
 this.originalStyle[k] = this.element.style[k];
 }.bind(this));
 
 this.originalTop = this.element.offsetTop;
 this.originalLeft = this.element.offsetLeft;
 
 var fontSize = this.element.getStyle('font-size') || '100%';
 ['em','px','%','pt'].each( function(fontSizeType) {
 if(fontSize.indexOf(fontSizeType)>0) {
 this.fontSize = parseFloat(fontSize);
 this.fontSizeType = fontSizeType;
 }
 }.bind(this));
 
 this.factor = (this.options.scaleTo - this.options.scaleFrom)/100;
 
 this.dims = null;
 if(this.options.scaleMode=='box')
 this.dims = [this.element.offsetHeight, this.element.offsetWidth];
 if(/^content/.test(this.options.scaleMode))
 this.dims = [this.element.scrollHeight, this.element.scrollWidth];
 if(!this.dims)
 this.dims = [this.options.scaleMode.originalHeight,
 this.options.scaleMode.originalWidth];
 },
 update: function(position) {
 var currentScale = (this.options.scaleFrom/100.0) + (this.factor * position);
 if(this.options.scaleContent && this.fontSize)
 this.element.setStyle({fontSize: this.fontSize * currentScale + this.fontSizeType });
 this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);
 },
 finish: function(position) {
 if(this.restoreAfterFinish) this.element.setStyle(this.originalStyle);
 },
 setDimensions: function(height, width) {
 var d = {};
 if(this.options.scaleX) d.width = Math.round(width) + 'px';
 if(this.options.scaleY) d.height = Math.round(height) + 'px';
 if(this.options.scaleFromCenter) {
 var topd = (height - this.dims[0])/2;
 var leftd = (width - this.dims[1])/2;
 if(this.elementPositioning == 'absolute') {
 if(this.options.scaleY) d.top = this.originalTop-topd + 'px';
 if(this.options.scaleX) d.left = this.originalLeft-leftd + 'px';
 } else {
 if(this.options.scaleY) d.top = -topd + 'px';
 if(this.options.scaleX) d.left = -leftd + 'px';
 }
 }
 this.element.setStyle(d);
 }
});

Effect.Highlight = Class.create();
Object.extend(Object.extend(Effect.Highlight.prototype, Effect.Base.prototype), {
 initialize: function(element) {
 this.element = $(element);
 if(!this.element) throw(Effect._elementDoesNotExistError);
 var options = Object.extend({ startcolor: '#ffff99' }, arguments[1] || {});
 this.start(options);
 },
 setup: function() {
 // Prevent executing on elements not in the layout flow
 if(this.element.getStyle('display')=='none') { this.cancel(); return; }
 // Disable background image during the effect
 this.oldStyle = {};
 if (!this.options.keepBackgroundImage) {
 this.oldStyle.backgroundImage = this.element.getStyle('background-image');
 this.element.setStyle({backgroundImage: 'none'});
 }
 if(!this.options.endcolor)
 this.options.endcolor = this.element.getStyle('background-color').parseColor('#ffffff');
 if(!this.options.restorecolor)
 this.options.restorecolor = this.element.getStyle('background-color');
 // init color calculations
 this._base = $R(0,2).map(function(i){ return parseInt(this.options.startcolor.slice(i*2+1,i*2+3),16) }.bind(this));
 this._delta = $R(0,2).map(function(i){ return parseInt(this.options.endcolor.slice(i*2+1,i*2+3),16)-this._base[i] }.bind(this));
 },
 update: function(position) {
 this.element.setStyle({backgroundColor: $R(0,2).inject('#',function(m,v,i){
 return m+(Math.round(this._base[i]+(this._delta[i]*position)).toColorPart()); }.bind(this)) });
 },
 finish: function() {
 this.element.setStyle(Object.extend(this.oldStyle, {
 backgroundColor: this.options.restorecolor
 }));
 }
});

Effect.ScrollTo = Class.create();
Object.extend(Object.extend(Effect.ScrollTo.prototype, Effect.Base.prototype), {
 initialize: function(element) {
 this.element = $(element);
 this.start(arguments[1] || {});
 },
 setup: function() {
 Position.prepare();
 var offsets = Position.cumulativeOffset(this.element);
 if(this.options.offset) offsets[1] += this.options.offset;
 var max = window.innerHeight ? 
 window.height - window.innerHeight :
 document.body.scrollHeight - 
 (document.documentElement.clientHeight ? 
 document.documentElement.clientHeight : document.body.clientHeight);
 this.scrollStart = Position.deltaY;
 this.delta = (offsets[1] > max ? max : offsets[1]) - this.scrollStart;
 },
 update: function(position) {
 Position.prepare();
 window.scrollTo(Position.deltaX, 
 this.scrollStart + (position*this.delta));
 }
});

/* ------------- combination effects ------------- */

Effect.Fade = function(element) {
 element = $(element);
 var oldOpacity = element.getInlineOpacity();
 var options = Object.extend({
 from: element.getOpacity() || 1.0,
 to: 0.0,
 afterFinishInternal: function(effect) { 
 if(effect.options.to!=0) return;
 effect.element.hide().setStyle({opacity: oldOpacity}); 
 }}, arguments[1] || {});
 return new Effect.Opacity(element,options);
}

Effect.Appear = function(element) {
 element = $(element);
 var options = Object.extend({
 from: (element.getStyle('display') == 'none' ? 0.0 : element.getOpacity() || 0.0),
 to: 1.0,
 // force Safari to render floated elements properly
 afterFinishInternal: function(effect) {
 effect.element.forceRerendering();
 },
 beforeSetup: function(effect) {
 effect.element.setOpacity(effect.options.from).show(); 
 }}, arguments[1] || {});
 return new Effect.Opacity(element,options);
}

Effect.Puff = function(element) {
 element = $(element);
 var oldStyle = { 
 opacity: element.getInlineOpacity(), 
 position: element.getStyle('position'),
 top: element.style.top,
 left: element.style.left,
 width: element.style.width,
 height: element.style.height
 };
 return new Effect.Parallel(
 [ new Effect.Scale(element, 200, 
 { sync: true, scaleFromCenter: true, scaleContent: true, restoreAfterFinish: true }), 
 new Effect.Opacity(element, { sync: true, to: 0.0 } ) ], 
 Object.extend({ duration: 1.0, 
 beforeSetupInternal: function(effect) {
 Position.absolutize(effect.effects[0].element)
 },
 afterFinishInternal: function(effect) {
 effect.effects[0].element.hide().setStyle(oldStyle); }
 }, arguments[1] || {})
 );
}

Effect.BlindUp = function(element) {
 element = $(element);
 element.makeClipping();
 return new Effect.Scale(element, 0,
 Object.extend({ scaleContent: false, 
 scaleX: false, 
 restoreAfterFinish: true,
 afterFinishInternal: function(effect) {
 effect.element.hide().undoClipping();
 } 
 }, arguments[1] || {})
 );
}

Effect.BlindDown = function(element) {
 element = $(element);
 var elementDimensions = element.getDimensions();
 return new Effect.Scale(element, 100, Object.extend({ 
 scaleContent: false, 
 scaleX: false,
 scaleFrom: 0,
 scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
 restoreAfterFinish: true,
 afterSetup: function(effect) {
 effect.element.makeClipping().setStyle({height: '0px'}).show(); 
 }, 
 afterFinishInternal: function(effect) {
 effect.element.undoClipping();
 }
 }, arguments[1] || {}));
}

Effect.SwitchOff = function(element) {
 element = $(element);
 var oldOpacity = element.getInlineOpacity();
 return new Effect.Appear(element, Object.extend({
 duration: 0.4,
 from: 0,
 transition: Effect.Transitions.flicker,
 afterFinishInternal: function(effect) {
 new Effect.Scale(effect.element, 1, { 
 duration: 0.3, scaleFromCenter: true,
 scaleX: false, scaleContent: false, restoreAfterFinish: true,
 beforeSetup: function(effect) { 
 effect.element.makePositioned().makeClipping();
 },
 afterFinishInternal: function(effect) {
 effect.element.hide().undoClipping().undoPositioned().setStyle({opacity: oldOpacity});
 }
 })
 }
 }, arguments[1] || {}));
}

Effect.DropOut = function(element) {
 element = $(element);
 var oldStyle = {
 top: element.getStyle('top'),
 left: element.getStyle('left'),
 opacity: element.getInlineOpacity() };
 return new Effect.Parallel(
 [ new Effect.Move(element, {x: 0, y: 100, sync: true }), 
 new Effect.Opacity(element, { sync: true, to: 0.0 }) ],
 Object.extend(
 { duration: 0.5,
 beforeSetup: function(effect) {
 effect.effects[0].element.makePositioned(); 
 },
 afterFinishInternal: function(effect) {
 effect.effects[0].element.hide().undoPositioned().setStyle(oldStyle);
 } 
 }, arguments[1] || {}));
}

Effect.Shake = function(element) {
 element = $(element);
 var oldStyle = {
 top: element.getStyle('top'),
 left: element.getStyle('left') };
 return new Effect.Move(element, 
 { x: 20, y: 0, duration: 0.05, afterFinishInternal: function(effect) {
 new Effect.Move(effect.element,
 { x: -40, y: 0, duration: 0.1, afterFinishInternal: function(effect) {
 new Effect.Move(effect.element,
 { x: 40, y: 0, duration: 0.1, afterFinishInternal: function(effect) {
 new Effect.Move(effect.element,
 { x: -40, y: 0, duration: 0.1, afterFinishInternal: function(effect) {
 new Effect.Move(effect.element,
 { x: 40, y: 0, duration: 0.1, afterFinishInternal: function(effect) {
 new Effect.Move(effect.element,
 { x: -20, y: 0, duration: 0.05, afterFinishInternal: function(effect) {
 effect.element.undoPositioned().setStyle(oldStyle);
 }}) }}) }}) }}) }}) }});
}

Effect.SlideDown = function(element) {
 element = $(element).cleanWhitespace();
 // SlideDown need to have the content of the element wrapped in a container element with fixed height!
 var oldInnerBottom = element.down().getStyle('bottom');
 var elementDimensions = element.getDimensions();
 return new Effect.Scale(element, 100, Object.extend({ 
 scaleContent: false, 
 scaleX: false, 
 scaleFrom: window.opera ? 0 : 1,
 scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
 restoreAfterFinish: true,
 afterSetup: function(effect) {
 effect.element.makePositioned();
 effect.element.down().makePositioned();
 if(window.opera) effect.element.setStyle({top: ''});
 effect.element.makeClipping().setStyle({height: '0px'}).show(); 
 },
 afterUpdateInternal: function(effect) {
 effect.element.down().setStyle({bottom:
 (effect.dims[0] - effect.element.clientHeight) + 'px' }); 
 },
 afterFinishInternal: function(effect) {
 effect.element.undoClipping().undoPositioned();
 effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom}); }
 }, arguments[1] || {})
 );
}

Effect.SlideUp = function(element) {
 element = $(element).cleanWhitespace();
 var oldInnerBottom = element.down().getStyle('bottom');
 return new Effect.Scale(element, window.opera ? 0 : 1,
 Object.extend({ scaleContent: false, 
 scaleX: false, 
 scaleMode: 'box',
 scaleFrom: 100,
 restoreAfterFinish: true,
 beforeStartInternal: function(effect) {
 effect.element.makePositioned();
 effect.element.down().makePositioned();
 if(window.opera) effect.element.setStyle({top: ''});
 effect.element.makeClipping().show();
 }, 
 afterUpdateInternal: function(effect) {
 effect.element.down().setStyle({bottom:
 (effect.dims[0] - effect.element.clientHeight) + 'px' });
 },
 afterFinishInternal: function(effect) {
 effect.element.hide().undoClipping().undoPositioned().setStyle({bottom: oldInnerBottom});
 effect.element.down().undoPositioned();
 }
 }, arguments[1] || {})
 );
}

// Bug in opera makes the TD containing this element expand for a instance after finish 
Effect.Squish = function(element) {
 return new Effect.Scale(element, window.opera ? 1 : 0, { 
 restoreAfterFinish: true,
 beforeSetup: function(effect) {
 effect.element.makeClipping(); 
 }, 
 afterFinishInternal: function(effect) {
 effect.element.hide().undoClipping(); 
 }
 });
}

Effect.Grow = function(element) {
 element = $(element);
 var options = Object.extend({
 direction: 'center',
 moveTransition: Effect.Transitions.sinoidal,
 scaleTransition: Effect.Transitions.sinoidal,
 opacityTransition: Effect.Transitions.full
 }, arguments[1] || {});
 var oldStyle = {
 top: element.style.top,
 left: element.style.left,
 height: element.style.height,
 width: element.style.width,
 opacity: element.getInlineOpacity() };

 var dims = element.getDimensions(); 
 var initialMoveX, initialMoveY;
 var moveX, moveY;
 
 switch (options.direction) {
 case 'top-left':
 initialMoveX = initialMoveY = moveX = moveY = 0; 
 break;
 case 'top-right':
 initialMoveX = dims.width;
 initialMoveY = moveY = 0;
 moveX = -dims.width;
 break;
 case 'bottom-left':
 initialMoveX = moveX = 0;
 initialMoveY = dims.height;
 moveY = -dims.height;
 break;
 case 'bottom-right':
 initialMoveX = dims.width;
 initialMoveY = dims.height;
 moveX = -dims.width;
 moveY = -dims.height;
 break;
 case 'center':
 initialMoveX = dims.width / 2;
 initialMoveY = dims.height / 2;
 moveX = -dims.width / 2;
 moveY = -dims.height / 2;
 break;
 }
 
 return new Effect.Move(element, {
 x: initialMoveX,
 y: initialMoveY,
 duration: 0.01, 
 beforeSetup: function(effect) {
 effect.element.hide().makeClipping().makePositioned();
 },
 afterFinishInternal: function(effect) {
 new Effect.Parallel(
 [ new Effect.Opacity(effect.element, { sync: true, to: 1.0, from: 0.0, transition: options.opacityTransition }),
 new Effect.Move(effect.element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition }),
 new Effect.Scale(effect.element, 100, {
 scaleMode: { originalHeight: dims.height, originalWidth: dims.width }, 
 sync: true, scaleFrom: window.opera ? 1 : 0, transition: options.scaleTransition, restoreAfterFinish: true})
 ], Object.extend({
 beforeSetup: function(effect) {
 effect.effects[0].element.setStyle({height: '0px'}).show(); 
 },
 afterFinishInternal: function(effect) {
 effect.effects[0].element.undoClipping().undoPositioned().setStyle(oldStyle); 
 }
 }, options)
 )
 }
 });
}

Effect.Shrink = function(element) {
 element = $(element);
 var options = Object.extend({
 direction: 'center',
 moveTransition: Effect.Transitions.sinoidal,
 scaleTransition: Effect.Transitions.sinoidal,
 opacityTransition: Effect.Transitions.none
 }, arguments[1] || {});
 var oldStyle = {
 top: element.style.top,
 left: element.style.left,
 height: element.style.height,
 width: element.style.width,
 opacity: element.getInlineOpacity() };

 var dims = element.getDimensions();
 var moveX, moveY;
 
 switch (options.direction) {
 case 'top-left':
 moveX = moveY = 0;
 break;
 case 'top-right':
 moveX = dims.width;
 moveY = 0;
 break;
 case 'bottom-left':
 moveX = 0;
 moveY = dims.height;
 break;
 case 'bottom-right':
 moveX = dims.width;
 moveY = dims.height;
 break;
 case 'center': 
 moveX = dims.width / 2;
 moveY = dims.height / 2;
 break;
 }
 
 return new Effect.Parallel(
 [ new Effect.Opacity(element, { sync: true, to: 0.0, from: 1.0, transition: options.opacityTransition }),
 new Effect.Scale(element, window.opera ? 1 : 0, { sync: true, transition: options.scaleTransition, restoreAfterFinish: true}),
 new Effect.Move(element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition })
 ], Object.extend({ 
 beforeStartInternal: function(effect) {
 effect.effects[0].element.makePositioned().makeClipping(); 
 },
 afterFinishInternal: function(effect) {
 effect.effects[0].element.hide().undoClipping().undoPositioned().setStyle(oldStyle); }
 }, options)
 );
}

Effect.Pulsate = function(element) {
 element = $(element);
 var options = arguments[1] || {};
 var oldOpacity = element.getInlineOpacity();
 var transition = options.transition || Effect.Transitions.sinoidal;
 var reverser = function(pos){ return transition(1-Effect.Transitions.pulse(pos, options.pulses)) };
 reverser.bind(transition);
 return new Effect.Opacity(element, 
 Object.extend(Object.extend({ duration: 2.0, from: 0,
 afterFinishInternal: function(effect) { effect.element.setStyle({opacity: oldOpacity}); }
 }, options), {transition: reverser}));
}

Effect.Fold = function(element) {
 element = $(element);
 var oldStyle = {
 top: element.style.top,
 left: element.style.left,
 width: element.style.width,
 height: element.style.height };
 element.makeClipping();
 return new Effect.Scale(element, 5, Object.extend({ 
 scaleContent: false,
 scaleX: false,
 afterFinishInternal: function(effect) {
 new Effect.Scale(element, 1, { 
 scaleContent: false, 
 scaleY: false,
 afterFinishInternal: function(effect) {
 effect.element.hide().undoClipping().setStyle(oldStyle);
 } });
 }}, arguments[1] || {}));
};

Effect.Morph = Class.create();
Object.extend(Object.extend(Effect.Morph.prototype, Effect.Base.prototype), {
 initialize: function(element) {
 this.element = $(element);
 if(!this.element) throw(Effect._elementDoesNotExistError);
 var options = Object.extend({
 style: {}
 }, arguments[1] || {});
 if (typeof options.style == 'string') {
 if(options.style.indexOf(':') == -1) {
 var cssText = '', selector = '.' + options.style;
 $A(document.styleSheets).reverse().each(function(styleSheet) {
 if (styleSheet.cssRules) cssRules = styleSheet.cssRules;
 else if (styleSheet.rules) cssRules = styleSheet.rules;
 $A(cssRules).reverse().each(function(rule) {
 if (selector == rule.selectorText) {
 cssText = rule.style.cssText;
 throw $break;
 }
 });
 if (cssText) throw $break;
 });
 this.style = cssText.parseStyle();
 options.afterFinishInternal = function(effect){
 effect.element.addClassName(effect.options.style);
 effect.transforms.each(function(transform) {
 if(transform.style != 'opacity')
 effect.element.style[transform.style] = '';
 });
 }
 } else this.style = options.style.parseStyle();
 } else this.style = $H(options.style)
 this.start(options);
 },
 setup: function(){
 function parseColor(color){
 if(!color || ['rgba(0, 0, 0, 0)','transparent'].include(color)) color = '#ffffff';
 color = color.parseColor();
 return $R(0,2).map(function(i){
 return parseInt( color.slice(i*2+1,i*2+3), 16 ) 
 });
 }
 this.transforms = this.style.map(function(pair){
 var property = pair[0], value = pair[1], unit = null;

 if(value.parseColor('#zzzzzz') != '#zzzzzz') {
 value = value.parseColor();
 unit = 'color';
 } else if(property == 'opacity') {
 value = parseFloat(value);
 if(Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
 this.element.setStyle({zoom: 1});
 } else if(Element.CSS_LENGTH.test(value)) {
 var components = value.match(/^([\+\-]?[0-9\.]+)(.*)$/);
 value = parseFloat(components[1]);
 unit = (components.length == 3) ? components[2] : null;
 }

 var originalValue = this.element.getStyle(property);
 return { 
 style: property.camelize(), 
 originalValue: unit=='color' ? parseColor(originalValue) : parseFloat(originalValue || 0), 
 targetValue: unit=='color' ? parseColor(value) : value,
 unit: unit
 };
 }.bind(this)).reject(function(transform){
 return (
 (transform.originalValue == transform.targetValue) ||
 (
 transform.unit != 'color' &&
 (isNaN(transform.originalValue) || isNaN(transform.targetValue))
 )
 )
 });
 },
 update: function(position) {
 var style = {}, transform, i = this.transforms.length;
 while(i--)
 style[(transform = this.transforms[i]).style] = 
 transform.unit=='color' ? '#'+
 (Math.round(transform.originalValue[0]+
 (transform.targetValue[0]-transform.originalValue[0])*position)).toColorPart() +
 (Math.round(transform.originalValue[1]+
 (transform.targetValue[1]-transform.originalValue[1])*position)).toColorPart() +
 (Math.round(transform.originalValue[2]+
 (transform.targetValue[2]-transform.originalValue[2])*position)).toColorPart() :
 transform.originalValue + Math.round(
 ((transform.targetValue - transform.originalValue) * position) * 1000)/1000 + transform.unit;
 this.element.setStyle(style, true);
 }
});

Effect.Transform = Class.create();
Object.extend(Effect.Transform.prototype, {
 initialize: function(tracks){
 this.tracks = [];
 this.options = arguments[1] || {};
 this.addTracks(tracks);
 },
 addTracks: function(tracks){
 tracks.each(function(track){
 var data = $H(track).values().first();
 this.tracks.push($H({
 ids: $H(track).keys().first(),
 effect: Effect.Morph,
 options: { style: data }
 }));
 }.bind(this));
 return this;
 },
 play: function(){
 return new Effect.Parallel(
 this.tracks.map(function(track){
 var elements = [$(track.ids) || $$(track.ids)].flatten();
 return elements.map(function(e){ return new track.effect(e, Object.extend({ sync:true }, track.options)) });
 }).flatten(),
 this.options
 );
 }
});

Element.CSS_PROPERTIES = $w(
 'backgroundColor backgroundPosition borderBottomColor borderBottomStyle ' + 
 'borderBottomWidth borderLeftColor borderLeftStyle borderLeftWidth ' +
 'borderRightColor borderRightStyle borderRightWidth borderSpacing ' +
 'borderTopColor borderTopStyle borderTopWidth bottom clip color ' +
 'fontSize fontWeight height left letterSpacing lineHeight ' +
 'marginBottom marginLeft marginRight marginTop markerOffset maxHeight '+
 'maxWidth minHeight minWidth opacity outlineColor outlineOffset ' +
 'outlineWidth paddingBottom paddingLeft paddingRight paddingTop ' +
 'right textIndent top width wordSpacing zIndex');
 
Element.CSS_LENGTH = /^(([\+\-]?[0-9\.]+)(em|ex|px|in|cm|mm|pt|pc|\%))|0$/;

String.prototype.parseStyle = function(){
 var element = document.createElement('div');
 element.innerHTML = '<div style="' + this + '"></div>';
 var style = element.childNodes[0].style, styleRules = $H();
 
 Element.CSS_PROPERTIES.each(function(property){
 if(style[property]) styleRules[property] = style[property]; 
 });
 if(Prototype.Browser.IE && this.indexOf('opacity') > -1) {
 styleRules.opacity = this.match(/opacity:\s*((?:0|1)?(?:\.\d*)?)/)[1];
 }
 return styleRules;
};

Element.morph = function(element, style) {
 new Effect.Morph(element, Object.extend({ style: style }, arguments[2] || {}));
 return element;
};

['getInlineOpacity','forceRerendering','setContentZoom',
 'collectTextNodes','collectTextNodesIgnoreClass','morph'].each( 
 function(f) { Element.Methods[f] = Element[f]; }
);

Element.Methods.visualEffect = function(element, effect, options) {
 s = effect.dasherize().camelize();
 effect_class = s.charAt(0).toUpperCase() + s.substring(1);
 new Effect[effect_class](element, options);
 return $(element);
};

Element.addMethods();// script.aculo.us dragdrop.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007

// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// (c) 2005-2007 Sammi Williams (http://www.oriontransfer.co.nz, sammi@oriontransfer.co.nz)
// 
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

if(typeof Effect == 'undefined')
 throw("dragdrop.js requires including script.aculo.us' effects.js library");

var Droppables = {
 drops: [],

 remove: function(element) {
 this.drops = this.drops.reject(function(d) { return d.element==$(element) });
 },

 add: function(element) {
 element = $(element);
 var options = Object.extend({
 greedy: true,
 hoverclass: null,
 tree: false
 }, arguments[1] || {});

 // cache containers
 if(options.containment) {
 options._containers = [];
 var containment = options.containment;
 if((typeof containment == 'object') && 
 (containment.constructor == Array)) {
 containment.each( function(c) { options._containers.push($(c)) });
 } else {
 options._containers.push($(containment));
 }
 }
 
 if(options.accept) options.accept = [options.accept].flatten();

 Element.makePositioned(element); // fix IE
 options.element = element;

 this.drops.push(options);
 },
 
 findDeepestChild: function(drops) {
 deepest = drops[0];
 
 for (i = 1; i < drops.length; ++i)
 if (Element.isParent(drops[i].element, deepest.element))
 deepest = drops[i];
 
 return deepest;
 },

 isContained: function(element, drop) {
 var containmentNode;
 if(drop.tree) {
 containmentNode = element.treeNode; 
 } else {
 containmentNode = element.parentNode;
 }
 return drop._containers.detect(function(c) { return containmentNode == c });
 },
 
 isAffected: function(point, element, drop) {
 return (
 (drop.element!=element) &&
 ((!drop._containers) ||
 this.isContained(element, drop)) &&
 ((!drop.accept) ||
 (Element.classNames(element).detect( 
 function(v) { return drop.accept.include(v) } ) )) &&
 Position.within(drop.element, point[0], point[1]) );
 },

 deactivate: function(drop) {
 if(drop.hoverclass)
 Element.removeClassName(drop.element, drop.hoverclass);
 this.last_active = null;
 },

 activate: function(drop) {
 if(drop.hoverclass)
 Element.addClassName(drop.element, drop.hoverclass);
 this.last_active = drop;
 },

 show: function(point, element) {
 if(!this.drops.length) return;
 var affected = [];
 
 if(this.last_active) this.deactivate(this.last_active);
 this.drops.each( function(drop) {
 if(Droppables.isAffected(point, element, drop))
 affected.push(drop);
 });
 
 if(affected.length>0) {
 drop = Droppables.findDeepestChild(affected);
 Position.within(drop.element, point[0], point[1]);
 if(drop.onHover)
 drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
 
 Droppables.activate(drop);
 }
 },

 fire: function(event, element) {
 if(!this.last_active) return;
 Position.prepare();

 if (this.isAffected([Event.pointerX(event), Event.pointerY(event)], element, this.last_active))
 if (this.last_active.onDrop) {
 this.last_active.onDrop(element, this.last_active.element, event); 
 return true; 
 }
 },

 reset: function() {
 if(this.last_active)
 this.deactivate(this.last_active);
 }
}

var Draggables = {
 drags: [],
 observers: [],
 
 register: function(draggable) {
 if(this.drags.length == 0) {
 this.eventMouseUp = this.endDrag.bindAsEventListener(this);
 this.eventMouseMove = this.updateDrag.bindAsEventListener(this);
 this.eventKeypress = this.keyPress.bindAsEventListener(this);
 
 Event.observe(document, "mouseup", this.eventMouseUp);
 Event.observe(document, "mousemove", this.eventMouseMove);
 Event.observe(document, "keypress", this.eventKeypress);
 }
 this.drags.push(draggable);
 },
 
 unregister: function(draggable) {
 this.drags = this.drags.reject(function(d) { return d==draggable });
 if(this.drags.length == 0) {
 Event.stopObserving(document, "mouseup", this.eventMouseUp);
 Event.stopObserving(document, "mousemove", this.eventMouseMove);
 Event.stopObserving(document, "keypress", this.eventKeypress);
 }
 },
 
 activate: function(draggable) {
 if(draggable.options.delay) { 
 this._timeout = setTimeout(function() { 
 Draggables._timeout = null; 
 window.focus(); 
 Draggables.activeDraggable = draggable; 
 }.bind(this), draggable.options.delay); 
 } else {
 window.focus(); // allows keypress events if window isn't currently focused, fails for Safari
 this.activeDraggable = draggable;
 }
 },
 
 deactivate: function() {
 this.activeDraggable = null;
 },
 
 updateDrag: function(event) {
 if(!this.activeDraggable) return;
 var pointer = [Event.pointerX(event), Event.pointerY(event)];
 // Mozilla-based browsers fire successive mousemove events with
 // the same coordinates, prevent needless redrawing (moz bug?)
 if(this._lastPointer && (this._lastPointer.inspect() == pointer.inspect())) return;
 this._lastPointer = pointer;
 
 this.activeDraggable.updateDrag(event, pointer);
 },
 
 endDrag: function(event) {
 if(this._timeout) { 
 clearTimeout(this._timeout); 
 this._timeout = null; 
 }
 if(!this.activeDraggable) return;
 this._lastPointer = null;
 this.activeDraggable.endDrag(event);
 this.activeDraggable = null;
 },
 
 keyPress: function(event) {
 if(this.activeDraggable)
 this.activeDraggable.keyPress(event);
 },
 
 addObserver: function(observer) {
 this.observers.push(observer);
 this._cacheObserverCallbacks();
 },
 
 removeObserver: function(element) { // element instead of observer fixes mem leaks
 this.observers = this.observers.reject( function(o) { return o.element==element });
 this._cacheObserverCallbacks();
 },
 
 notify: function(eventName, draggable, event) { // 'onStart', 'onEnd', 'onDrag'
 if(this[eventName+'Count'] > 0)
 this.observers.each( function(o) {
 if(o[eventName]) o[eventName](eventName, draggable, event);
 });
 if(draggable.options[eventName]) draggable.options[eventName](draggable, event);
 },
 
 _cacheObserverCallbacks: function() {
 ['onStart','onEnd','onDrag'].each( function(eventName) {
 Draggables[eventName+'Count'] = Draggables.observers.select(
 function(o) { return o[eventName]; }
 ).length;
 });
 }
}

/*--------------------------------------------------------------------------*/

var Draggable = Class.create();
Draggable._dragging = {};

Draggable.prototype = {
 initialize: function(element) {
 var defaults = {
 handle: false,
 reverteffect: function(element, top_offset, left_offset) {
 var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
 new Effect.Move(element, { x: -left_offset, y: -top_offset, duration: dur,
 queue: {scope:'_draggable', position:'end'}
 });
 },
 endeffect: function(element) {
 var toOpacity = typeof element._opacity == 'number' ? element._opacity : 1.0;
 new Effect.Opacity(element, {duration:0.2, from:0.7, to:toOpacity, 
 queue: {scope:'_draggable', position:'end'},
 afterFinish: function(){ 
 Draggable._dragging[element] = false 
 }
 }); 
 },
 zindex: 1000,
 revert: false,
 quiet: false,
 scroll: false,
 scrollSensitivity: 20,
 scrollSpeed: 15,
 snap: false, // false, or xy or [x,y] or function(x,y){ return [x,y] }
 delay: 0
 };
 
 if(!arguments[1] || typeof arguments[1].endeffect == 'undefined')
 Object.extend(defaults, {
 starteffect: function(element) {
 element._opacity = Element.getOpacity(element);
 Draggable._dragging[element] = true;
 new Effect.Opacity(element, {duration:0.2, from:element._opacity, to:0.7}); 
 }
 });
 
 var options = Object.extend(defaults, arguments[1] || {});

 this.element = $(element);
 
 if(options.handle && (typeof options.handle == 'string'))
 this.handle = this.element.down('.'+options.handle, 0);
 
 if(!this.handle) this.handle = $(options.handle);
 if(!this.handle) this.handle = this.element;
 
 if(options.scroll && !options.scroll.scrollTo && !options.scroll.outerHTML) {
 options.scroll = $(options.scroll);
 this._isScrollChild = Element.childOf(this.element, options.scroll);
 }

 Element.makePositioned(this.element); // fix IE 

 this.delta = this.currentDelta();
 this.options = options;
 this.dragging = false; 

 this.eventMouseDown = this.initDrag.bindAsEventListener(this);
 Event.observe(this.handle, "mousedown", this.eventMouseDown);
 
 Draggables.register(this);
 },
 
 destroy: function() {
 Event.stopObserving(this.handle, "mousedown", this.eventMouseDown);
 Draggables.unregister(this);
 },
 
 currentDelta: function() {
 return([
 parseInt(Element.getStyle(this.element,'left') || '0'),
 parseInt(Element.getStyle(this.element,'top') || '0')]);
 },
 
 initDrag: function(event) {
 if(typeof Draggable._dragging[this.element] != 'undefined' &&
 Draggable._dragging[this.element]) return;
 if(Event.isLeftClick(event)) { 
 // abort on form elements, fixes a Firefox issue
 var src = Event.element(event);
 if((tag_name = src.tagName.toUpperCase()) && (
 tag_name=='INPUT' ||
 tag_name=='SELECT' ||
 tag_name=='OPTION' ||
 tag_name=='BUTTON' ||
 tag_name=='TEXTAREA')) return;
 
 var pointer = [Event.pointerX(event), Event.pointerY(event)];
 var pos = Position.cumulativeOffset(this.element);
 this.offset = [0,1].map( function(i) { return (pointer[i] - pos[i]) });
 
 Draggables.activate(this);
 Event.stop(event);
 }
 },
 
 startDrag: function(event) {
 this.dragging = true;
 
 if(this.options.zindex) {
 this.originalZ = parseInt(Element.getStyle(this.element,'z-index') || 0);
 this.element.style.zIndex = this.options.zindex;
 }
 
 if(this.options.ghosting) {
 this._clone = this.element.cloneNode(true);
 Position.absolutize(this.element);
 this.element.parentNode.insertBefore(this._clone, this.element);
 }
 
 if(this.options.scroll) {
 if (this.options.scroll == window) {
 var where = this._getWindowScroll(this.options.scroll);
 this.originalScrollLeft = where.left;
 this.originalScrollTop = where.top;
 } else {
 this.originalScrollLeft = this.options.scroll.scrollLeft;
 this.originalScrollTop = this.options.scroll.scrollTop;
 }
 }
 
 Draggables.notify('onStart', this, event);
 
 if(this.options.starteffect) this.options.starteffect(this.element);
 },
 
 updateDrag: function(event, pointer) {
 if(!this.dragging) this.startDrag(event);
 
 if(!this.options.quiet){
 Position.prepare();
 Droppables.show(pointer, this.element);
 }
 
 Draggables.notify('onDrag', this, event);
 
 this.draw(pointer);
 if(this.options.change) this.options.change(this);
 
 if(this.options.scroll) {
 this.stopScrolling();
 
 var p;
 if (this.options.scroll == window) {
 with(this._getWindowScroll(this.options.scroll)) { p = [ left, top, left+width, top+height ]; }
 } else {
 p = Position.page(this.options.scroll);
 p[0] += this.options.scroll.scrollLeft + Position.deltaX;
 p[1] += this.options.scroll.scrollTop + Position.deltaY;
 p.push(p[0]+this.options.scroll.offsetWidth);
 p.push(p[1]+this.options.scroll.offsetHeight);
 }
 var speed = [0,0];
 if(pointer[0] < (p[0]+this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[0]+this.options.scrollSensitivity);
 if(pointer[1] < (p[1]+this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[1]+this.options.scrollSensitivity);
 if(pointer[0] > (p[2]-this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[2]-this.options.scrollSensitivity);
 if(pointer[1] > (p[3]-this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[3]-this.options.scrollSensitivity);
 this.startScrolling(speed);
 }
 
 // fix AppleWebKit rendering
 if(Prototype.Browser.WebKit) window.scrollBy(0,0);
 
 Event.stop(event);
 },
 
 finishDrag: function(event, success) {
 this.dragging = false;
 
 if(this.options.quiet){
 Position.prepare();
 var pointer = [Event.pointerX(event), Event.pointerY(event)];
 Droppables.show(pointer, this.element);
 }

 if(this.options.ghosting) {
 Position.relativize(this.element);
 Element.remove(this._clone);
 this._clone = null;
 }

 var dropped = false; 
 if(success) { 
 dropped = Droppables.fire(event, this.element); 
 if (!dropped) dropped = false; 
 }
 if(dropped && this.options.onDropped) this.options.onDropped(this.element);
 Draggables.notify('onEnd', this, event);

 var revert = this.options.revert;
 if(revert && typeof revert == 'function') revert = revert(this.element);
 
 var d = this.currentDelta();
 if(revert && this.options.reverteffect) {
 if (dropped == 0 || revert != 'failure')
 this.options.reverteffect(this.element,
 d[1]-this.delta[1], d[0]-this.delta[0]);
 } else {
 this.delta = d;
 }

 if(this.options.zindex)
 this.element.style.zIndex = this.originalZ;

 if(this.options.endeffect) 
 this.options.endeffect(this.element);
 
 Draggables.deactivate(this);
 Droppables.reset();
 },
 
 keyPress: function(event) {
 if(event.keyCode!=Event.KEY_ESC) return;
 this.finishDrag(event, false);
 Event.stop(event);
 },
 
 endDrag: function(event) {
 if(!this.dragging) return;
 this.stopScrolling();
 this.finishDrag(event, true);
 Event.stop(event);
 },
 
 draw: function(point) {
 var pos = Position.cumulativeOffset(this.element);
 if(this.options.ghosting) {
 var r = Position.realOffset(this.element);
 pos[0] += r[0] - Position.deltaX; pos[1] += r[1] - Position.deltaY;
 }
 
 var d = this.currentDelta();
 pos[0] -= d[0]; pos[1] -= d[1];
 
 if(this.options.scroll && (this.options.scroll != window && this._isScrollChild)) {
 pos[0] -= this.options.scroll.scrollLeft-this.originalScrollLeft;
 pos[1] -= this.options.scroll.scrollTop-this.originalScrollTop;
 }
 
 var p = [0,1].map(function(i){ 
 return (point[i]-pos[i]-this.offset[i]) 
 }.bind(this));
 
 if(this.options.snap) {
 if(typeof this.options.snap == 'function') {
 p = this.options.snap(p[0],p[1],this);
 } else {
 if(this.options.snap instanceof Array) {
 p = p.map( function(v, i) {
 return Math.round(v/this.options.snap[i])*this.options.snap[i] }.bind(this))
 } else {
 p = p.map( function(v) {
 return Math.round(v/this.options.snap)*this.options.snap }.bind(this))
 }
 }}
 
 var style = this.element.style;
 if((!this.options.constraint) || (this.options.constraint=='horizontal'))
 style.left = p[0] + "px";
 if((!this.options.constraint) || (this.options.constraint=='vertical'))
 style.top = p[1] + "px";
 
 if(style.visibility=="hidden") style.visibility = ""; // fix gecko rendering
 },
 
 stopScrolling: function() {
 if(this.scrollInterval) {
 clearInterval(this.scrollInterval);
 this.scrollInterval = null;
 Draggables._lastScrollPointer = null;
 }
 },
 
 startScrolling: function(speed) {
 if(!(speed[0] || speed[1])) return;
 this.scrollSpeed = [speed[0]*this.options.scrollSpeed,speed[1]*this.options.scrollSpeed];
 this.lastScrolled = new Date();
 this.scrollInterval = setInterval(this.scroll.bind(this), 10);
 },
 
 scroll: function() {
 var current = new Date();
 var delta = current - this.lastScrolled;
 this.lastScrolled = current;
 if(this.options.scroll == window) {
 with (this._getWindowScroll(this.options.scroll)) {
 if (this.scrollSpeed[0] || this.scrollSpeed[1]) {
 var d = delta / 1000;
 this.options.scroll.scrollTo( left + d*this.scrollSpeed[0], top + d*this.scrollSpeed[1] );
 }
 }
 } else {
 this.options.scroll.scrollLeft += this.scrollSpeed[0] * delta / 1000;
 this.options.scroll.scrollTop += this.scrollSpeed[1] * delta / 1000;
 }
 
 Position.prepare();
 Droppables.show(Draggables._lastPointer, this.element);
 Draggables.notify('onDrag', this);
 if (this._isScrollChild) {
 Draggables._lastScrollPointer = Draggables._lastScrollPointer || $A(Draggables._lastPointer);
 Draggables._lastScrollPointer[0] += this.scrollSpeed[0] * delta / 1000;
 Draggables._lastScrollPointer[1] += this.scrollSpeed[1] * delta / 1000;
 if (Draggables._lastScrollPointer[0] < 0)
 Draggables._lastScrollPointer[0] = 0;
 if (Draggables._lastScrollPointer[1] < 0)
 Draggables._lastScrollPointer[1] = 0;
 this.draw(Draggables._lastScrollPointer);
 }
 
 if(this.options.change) this.options.change(this);
 },
 
 _getWindowScroll: function(w) {
 var T, L, W, H;
 with (w.document) {
 if (w.document.documentElement && documentElement.scrollTop) {
 T = documentElement.scrollTop;
 L = documentElement.scrollLeft;
 } else if (w.document.body) {
 T = body.scrollTop;
 L = body.scrollLeft;
 }
 if (w.innerWidth) {
 W = w.innerWidth;
 H = w.innerHeight;
 } else if (w.document.documentElement && documentElement.clientWidth) {
 W = documentElement.clientWidth;
 H = documentElement.clientHeight;
 } else {
 W = body.offsetWidth;
 H = body.offsetHeight
 }
 }
 return { top: T, left: L, width: W, height: H };
 }
}

/*--------------------------------------------------------------------------*/

var SortableObserver = Class.create();
SortableObserver.prototype = {
 initialize: function(element, observer) {
 this.element = $(element);
 this.observer = observer;
 this.lastValue = Sortable.serialize(this.element);
 },
 
 onStart: function() {
 this.lastValue = Sortable.serialize(this.element);
 },
 
 onEnd: function() {
 Sortable.unmark();
 if(this.lastValue != Sortable.serialize(this.element))
 this.observer(this.element)
 }
}

var Sortable = {
 SERIALIZE_RULE: /^[^_\-](?:[A-Za-z0-9\-\_]*)[_](.*)$/,
 
 sortables: {},
 
 _findRootElement: function(element) {
 while (element.tagName.toUpperCase() != "BODY") { 
 if(element.id && Sortable.sortables[element.id]) return element;
 element = element.parentNode;
 }
 },

 options: function(element) {
 element = Sortable._findRootElement($(element));
 if(!element) return;
 return Sortable.sortables[element.id];
 },
 
 destroy: function(element){
 var s = Sortable.options(element);
 
 if(s) {
 Draggables.removeObserver(s.element);
 s.droppables.each(function(d){ Droppables.remove(d) });
 s.draggables.invoke('destroy');
 
 delete Sortable.sortables[s.element.id];
 }
 },

 create: function(element) {
 element = $(element);
 var options = Object.extend({ 
 element: element,
 tag: 'li', // assumes li children, override with tag: 'tagname'
 dropOnEmpty: false,
 tree: false,
 treeTag: 'ul',
 overlap: 'vertical', // one of 'vertical', 'horizontal'
 constraint: 'vertical', // one of 'vertical', 'horizontal', false
 containment: element, // also takes array of elements (or id's); or false
 handle: false, // or a CSS class
 only: false,
 delay: 0,
 hoverclass: null,
 ghosting: false,
 quiet: false, 
 scroll: false,
 scrollSensitivity: 20,
 scrollSpeed: 15,
 format: this.SERIALIZE_RULE,
 
 // these take arrays of elements or ids and can be 
 // used for better initialization performance
 elements: false,
 handles: false,
 
 onChange: Prototype.emptyFunction,
 onUpdate: Prototype.emptyFunction
 }, arguments[1] || {});

 // clear any old sortable with same element
 this.destroy(element);

 // build options for the draggables
 var options_for_draggable = {
 revert: true,
 quiet: options.quiet,
 scroll: options.scroll,
 scrollSpeed: options.scrollSpeed,
 scrollSensitivity: options.scrollSensitivity,
 delay: options.delay,
 ghosting: options.ghosting,
 constraint: options.constraint,
 handle: options.handle };

 if(options.starteffect)
 options_for_draggable.starteffect = options.starteffect;

 if(options.reverteffect)
 options_for_draggable.reverteffect = options.reverteffect;
 else
 if(options.ghosting) options_for_draggable.reverteffect = function(element) {
 element.style.top = 0;
 element.style.left = 0;
 };

 if(options.endeffect)
 options_for_draggable.endeffect = options.endeffect;

 if(options.zindex)
 options_for_draggable.zindex = options.zindex;

 // build options for the droppables 
 var options_for_droppable = {
 overlap: options.overlap,
 containment: options.containment,
 tree: options.tree,
 hoverclass: options.hoverclass,
 onHover: Sortable.onHover
 }
 
 var options_for_tree = {
 onHover: Sortable.onEmptyHover,
 overlap: options.overlap,
 containment: options.containment,
 hoverclass: options.hoverclass
 }

 // fix for gecko engine
 Element.cleanWhitespace(element); 

 options.draggables = [];
 options.droppables = [];

 // drop on empty handling
 if(options.dropOnEmpty || options.tree) {
 Droppables.add(element, options_for_tree);
 options.droppables.push(element);
 }

 (options.elements || this.findElements(element, options) || []).each( function(e,i) {
 var handle = options.handles ? $(options.handles[i]) :
 (options.handle ? $(e).getElementsByClassName(options.handle)[0] : e); 
 options.draggables.push(
 new Draggable(e, Object.extend(options_for_draggable, { handle: handle })));
 Droppables.add(e, options_for_droppable);
 if(options.tree) e.treeNode = element;
 options.droppables.push(e); 
 });
 
 if(options.tree) {
 (Sortable.findTreeElements(element, options) || []).each( function(e) {
 Droppables.add(e, options_for_tree);
 e.treeNode = element;
 options.droppables.push(e);
 });
 }

 // keep reference
 this.sortables[element.id] = options;

 // for onupdate
 Draggables.addObserver(new SortableObserver(element, options.onUpdate));

 },

 // return all suitable-for-sortable elements in a guaranteed order
 findElements: function(element, options) {
 return Element.findChildren(
 element, options.only, options.tree ? true : false, options.tag);
 },
 
 findTreeElements: function(element, options) {
 return Element.findChildren(
 element, options.only, options.tree ? true : false, options.treeTag);
 },

 onHover: function(element, dropon, overlap) {
 if(Element.isParent(dropon, element)) return;

 if(overlap > .33 && overlap < .66 && Sortable.options(dropon).tree) {
 return;
 } else if(overlap>0.5) {
 Sortable.mark(dropon, 'before');
 if(dropon.previousSibling != element) {
 var oldParentNode = element.parentNode;
 element.style.visibility = "hidden"; // fix gecko rendering
 dropon.parentNode.insertBefore(element, dropon);
 if(dropon.parentNode!=oldParentNode) 
 Sortable.options(oldParentNode).onChange(element);
 Sortable.options(dropon.parentNode).onChange(element);
 }
 } else {
 Sortable.mark(dropon, 'after');
 var nextElement = dropon.nextSibling || null;
 if(nextElement != element) {
 var oldParentNode = element.parentNode;
 element.style.visibility = "hidden"; // fix gecko rendering
 dropon.parentNode.insertBefore(element, nextElement);
 if(dropon.parentNode!=oldParentNode) 
 Sortable.options(oldParentNode).onChange(element);
 Sortable.options(dropon.parentNode).onChange(element);
 }
 }
 },
 
 onEmptyHover: function(element, dropon, overlap) {
 var oldParentNode = element.parentNode;
 var droponOptions = Sortable.options(dropon);
 
 if(!Element.isParent(dropon, element)) {
 var index;
 
 var children = Sortable.findElements(dropon, {tag: droponOptions.tag, only: droponOptions.only});
 var child = null;
 
 if(children) {
 var offset = Element.offsetSize(dropon, droponOptions.overlap) * (1.0 - overlap);
 
 for (index = 0; index < children.length; index += 1) {
 if (offset - Element.offsetSize (children[index], droponOptions.overlap) >= 0) {
 offset -= Element.offsetSize (children[index], droponOptions.overlap);
 } else if (offset - (Element.offsetSize (children[index], droponOptions.overlap) / 2) >= 0) {
 child = index + 1 < children.length ? children[index + 1] : null;
 break;
 } else {
 child = children[index];
 break;
 }
 }
 }
 
 dropon.insertBefore(element, child);
 
 Sortable.options(oldParentNode).onChange(element);
 droponOptions.onChange(element);
 }
 },

 unmark: function() {
 if(Sortable._marker) Sortable._marker.hide();
 },

 mark: function(dropon, position) {
 // mark on ghosting only
 var sortable = Sortable.options(dropon.parentNode);
 if(sortable && !sortable.ghosting) return; 

 if(!Sortable._marker) {
 Sortable._marker = 
 ($('dropmarker') || Element.extend(document.createElement('DIV'))).
 hide().addClassName('dropmarker').setStyle({position:'absolute'});
 document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);
 } 
 var offsets = Position.cumulativeOffset(dropon);
 Sortable._marker.setStyle({left: offsets[0]+'px', top: offsets[1] + 'px'});
 
 if(position=='after')
 if(sortable.overlap == 'horizontal') 
 Sortable._marker.setStyle({left: (offsets[0]+dropon.clientWidth) + 'px'});
 else
 Sortable._marker.setStyle({top: (offsets[1]+dropon.clientHeight) + 'px'});
 
 Sortable._marker.show();
 },
 
 _tree: function(element, options, parent) {
 var children = Sortable.findElements(element, options) || [];
 
 for (var i = 0; i < children.length; ++i) {
 var match = children[i].id.match(options.format);

 if (!match) continue;
 
 var child = {
 id: encodeURIComponent(match ? match[1] : null),
 element: element,
 parent: parent,
 children: [],
 position: parent.children.length,
 container: $(children[i]).down(options.treeTag)
 }
 
 /* Get the element containing the children and recurse over it */
 if (child.container)
 this._tree(child.container, options, child)
 
 parent.children.push (child);
 }

 return parent; 
 },

 tree: function(element) {
 element = $(element);
 var sortableOptions = this.options(element);
 var options = Object.extend({
 tag: sortableOptions.tag,
 treeTag: sortableOptions.treeTag,
 only: sortableOptions.only,
 name: element.id,
 format: sortableOptions.format
 }, arguments[1] || {});
 
 var root = {
 id: null,
 parent: null,
 children: [],
 container: element,
 position: 0
 }
 
 return Sortable._tree(element, options, root);
 },

 /* Construct a [i] index for a particular node */
 _constructIndex: function(node) {
 var index = '';
 do {
 if (node.id) index = '[' + node.position + ']' + index;
 } while ((node = node.parent) != null);
 return index;
 },

 sequence: function(element) {
 element = $(element);
 var options = Object.extend(this.options(element), arguments[1] || {});
 
 return $(this.findElements(element, options) || []).map( function(item) {
 return item.id.match(options.format) ? item.id.match(options.format)[1] : '';
 });
 },

 setSequence: function(element, new_sequence) {
 element = $(element);
 var options = Object.extend(this.options(element), arguments[2] || {});
 
 var nodeMap = {};
 this.findElements(element, options).each( function(n) {
 if (n.id.match(options.format))
 nodeMap[n.id.match(options.format)[1]] = [n, n.parentNode];
 n.parentNode.removeChild(n);
 });
 
 new_sequence.each(function(ident) {
 var n = nodeMap[ident];
 if (n) {
 n[1].appendChild(n[0]);
 delete nodeMap[ident];
 }
 });
 },
 
 serialize: function(element) {
 element = $(element);
 var options = Object.extend(Sortable.options(element), arguments[1] || {});
 var name = encodeURIComponent(
 (arguments[1] && arguments[1].name) ? arguments[1].name : element.id);
 
 if (options.tree) {
 return Sortable.tree(element, arguments[1]).children.map( function (item) {
 return [name + Sortable._constructIndex(item) + "[id]=" + 
 encodeURIComponent(item.id)].concat(item.children.map(arguments.callee));
 }).flatten().join('&');
 } else {
 return Sortable.sequence(element, arguments[1]).map( function(item) {
 return name + "[]=" + encodeURIComponent(item);
 }).join('&');
 }
 }
}

// Returns true if child is contained within element
Element.isParent = function(child, element) {
 if (!child.parentNode || child == element) return false;
 if (child.parentNode == element) return true;
 return Element.isParent(child.parentNode, element);
}

Element.findChildren = function(element, only, recursive, tagName) { 
 if(!element.hasChildNodes()) return null;
 tagName = tagName.toUpperCase();
 if(only) only = [only].flatten();
 var elements = [];
 $A(element.childNodes).each( function(e) {
 if(e.tagName && e.tagName.toUpperCase()==tagName &&
 (!only || (Element.classNames(e).detect(function(v) { return only.include(v) }))))
 elements.push(e);
 if(recursive) {
 var grandchildren = Element.findChildren(e, only, recursive, tagName);
 if(grandchildren) elements.push(grandchildren);
 }
 });

 return (elements.length>0 ? elements.flatten() : []);
}

Element.offsetSize = function (element, type) {
 return element['offset' + ((type=='vertical' || type=='height') ? 'Height' : 'Width')];
}
// script.aculo.us controls.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007

// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// (c) 2005-2007 Ivan Krstic (http://blogs.law.harvard.edu/ivan)
// (c) 2005-2007 Jon Tirsen (http://www.tirsen.com)
// Contributors:
// Richard Livsey
// Rahul Bhargava
// Rob Wills
// 
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

// Autocompleter.Base handles all the autocompletion functionality 
// that's independent of the data source for autocompletion. This
// includes drawing the autocompletion menu, observing keyboard
// and mouse events, and similar.
//
// Specific autocompleters need to provide, at the very least, 
// a getUpdatedChoices function that will be invoked every time
// the text inside the monitored textbox changes. This method 
// should get the text for which to provide autocompletion by
// invoking this.getToken(), NOT by directly accessing
// this.element.value. This is to allow incremental tokenized
// autocompletion. Specific auto-completion logic (AJAX, etc)
// belongs in getUpdatedChoices.
//
// Tokenized incremental autocompletion is enabled automatically
// when an autocompleter is instantiated with the 'tokens' option
// in the options parameter, e.g.:
// new Ajax.Autocompleter('id','upd', '/url/', { tokens: ',' });
// will incrementally autocomplete with a comma as the token.
// Additionally, ',' in the above example can be replaced with
// a token array, e.g. { tokens: [',', '\n'] } which
// enables autocompletion on multiple tokens. This is most 
// useful when one of the tokens is \n (a newline), as it 
// allows smart autocompletion after linebreaks.

if(typeof Effect == 'undefined')
 throw("controls.js requires including script.aculo.us' effects.js library");

var Autocompleter = {}
Autocompleter.Base = function() {};
Autocompleter.Base.prototype = {
 baseInitialize: function(element, update, options) {
 element = $(element)
 this.element = element; 
 this.update = $(update); 
 this.hasFocus = false; 
 this.changed = false; 
 this.active = false; 
 this.index = 0; 
 this.entryCount = 0;

 if(this.setOptions)
 this.setOptions(options);
 else
 this.options = options || {};

 this.options.paramName = this.options.paramName || this.element.name;
 this.options.tokens = this.options.tokens || [];
 this.options.frequency = this.options.frequency || 0.4;
 this.options.minChars = this.options.minChars || 1;
 this.options.onShow = this.options.onShow || 
 function(element, update){ 
 if(!update.style.position || update.style.position=='absolute') {
 update.style.position = 'absolute';
 Position.clone(element, update, {
 setHeight: false, 
 offsetTop: element.offsetHeight
 });
 }
 Effect.Appear(update,{duration:0.15});
 };
 this.options.onHide = this.options.onHide || 
 function(element, update){ new Effect.Fade(update,{duration:0.15}) };

 if(typeof(this.options.tokens) == 'string') 
 this.options.tokens = new Array(this.options.tokens);

 this.observer = null;
 
 this.element.setAttribute('autocomplete','off');

 Element.hide(this.update);

 Event.observe(this.element, 'blur', this.onBlur.bindAsEventListener(this));
 Event.observe(this.element, 'keypress', this.onKeyPress.bindAsEventListener(this));

 // Turn autocomplete back on when the user leaves the page, so that the
 // field's value will be remembered on Mozilla-based browsers.
 Event.observe(window, 'beforeunload', function(){ 
 element.setAttribute('autocomplete', 'on'); 
 });
 },

 show: function() {
 if(Element.getStyle(this.update, 'display')=='none') this.options.onShow(this.element, this.update);
 if(!this.iefix && 
 (Prototype.Browser.IE) &&
 (Element.getStyle(this.update, 'position')=='absolute')) {
 new Insertion.After(this.update, 
 '<iframe id="' + this.update.id + '_iefix" '+
 'style="display:none;position:absolute;filter:progid:DXImageTransform.Microsoft.Alpha(opacity=0);" ' +
 'src="javascript:false;" frameborder="0" scrolling="no"></iframe>');
 this.iefix = $(this.update.id+'_iefix');
 }
 if(this.iefix) setTimeout(this.fixIEOverlapping.bind(this), 50);
 },
 
 fixIEOverlapping: function() {
 Position.clone(this.update, this.iefix, {setTop:(!this.update.style.height)});
 this.iefix.style.zIndex = 1;
 this.update.style.zIndex = 2;
 Element.show(this.iefix);
 },

 hide: function() {
 this.stopIndicator();
 if(Element.getStyle(this.update, 'display')!='none') this.options.onHide(this.element, this.update);
 if(this.iefix) Element.hide(this.iefix);
 },

 startIndicator: function() {
 if(this.options.indicator) Element.show(this.options.indicator);
 },

 stopIndicator: function() {
 if(this.options.indicator) Element.hide(this.options.indicator);
 },

 onKeyPress: function(event) {
 if(this.active)
 switch(event.keyCode) {
 case Event.KEY_TAB:
 case Event.KEY_RETURN:
 this.selectEntry();
 Event.stop(event);
 case Event.KEY_ESC:
 this.hide();
 this.active = false;
 Event.stop(event);
 return;
 case Event.KEY_LEFT:
 case Event.KEY_RIGHT:
 return;
 case Event.KEY_UP:
 this.markPrevious();
 this.render();
 if(Prototype.Browser.WebKit) Event.stop(event);
 return;
 case Event.KEY_DOWN:
 this.markNext();
 this.render();
 if(Prototype.Browser.WebKit) Event.stop(event);
 return;
 }
 else 
 if(event.keyCode==Event.KEY_TAB || event.keyCode==Event.KEY_RETURN || 
 (Prototype.Browser.WebKit > 0 && event.keyCode == 0)) return;

 this.changed = true;
 this.hasFocus = true;

 if(this.observer) clearTimeout(this.observer);
 this.observer = 
 setTimeout(this.onObserverEvent.bind(this), this.options.frequency*1000);
 },

 activate: function() {
 this.changed = false;
 this.hasFocus = true;
 this.getUpdatedChoices();
 },

 onHover: function(event) {
 var element = Event.findElement(event, 'LI');
 if(this.index != element.autocompleteIndex) 
 {
 this.index = element.autocompleteIndex;
 this.render();
 }
 Event.stop(event);
 },
 
 onClick: function(event) {
 var element = Event.findElement(event, 'LI');
 this.index = element.autocompleteIndex;
 this.selectEntry();
 this.hide();
 },
 
 onBlur: function(event) {
 // needed to make click events working
 setTimeout(this.hide.bind(this), 250);
 this.hasFocus = false;
 this.active = false; 
 }, 
 
 render: function() {
 if(this.entryCount > 0) {
 for (var i = 0; i < this.entryCount; i++)
 this.index==i ? 
 Element.addClassName(this.getEntry(i),"selected") : 
 Element.removeClassName(this.getEntry(i),"selected");
 if(this.hasFocus) { 
 this.show();
 this.active = true;
 }
 } else {
 this.active = false;
 this.hide();
 }
 },
 
 markPrevious: function() {
 if(this.index > 0) this.index--
 else this.index = this.entryCount-1;
 this.getEntry(this.index).scrollIntoView(true);
 },
 
 markNext: function() {
 if(this.index < this.entryCount-1) this.index++
 else this.index = 0;
 this.getEntry(this.index).scrollIntoView(false);
 },
 
 getEntry: function(index) {
 return this.update.firstChild.childNodes[index];
 },
 
 getCurrentEntry: function() {
 return this.getEntry(this.index);
 },
 
 selectEntry: function() {
 this.active = false;
 this.updateElement(this.getCurrentEntry());
 },

 updateElement: function(selectedElement) {
 if (this.options.updateElement) {
 this.options.updateElement(selectedElement);
 return;
 }
 var value = '';
 if (this.options.select) {
 var nodes = document.getElementsByClassName(this.options.select, selectedElement) || [];
 if(nodes.length>0) value = Element.collectTextNodes(nodes[0], this.options.select);
 } else
 value = Element.collectTextNodesIgnoreClass(selectedElement, 'informal');
 
 var lastTokenPos = this.findLastToken();
 if (lastTokenPos != -1) {
 var newValue = this.element.value.substr(0, lastTokenPos + 1);
 var whitespace = this.element.value.substr(lastTokenPos + 1).match(/^\s+/);
 if (whitespace)
 newValue += whitespace[0];
 this.element.value = newValue + value;
 } else {
 this.element.value = value;
 }
 this.element.focus();
 
 if (this.options.afterUpdateElement)
 this.options.afterUpdateElement(this.element, selectedElement);
 },

 updateChoices: function(choices) {
 if(!this.changed && this.hasFocus) {
 this.update.innerHTML = choices;
 Element.cleanWhitespace(this.update);
 Element.cleanWhitespace(this.update.down());

 if(this.update.firstChild && this.update.down().childNodes) {
 this.entryCount = 
 this.update.down().childNodes.length;
 for (var i = 0; i < this.entryCount; i++) {
 var entry = this.getEntry(i);
 entry.autocompleteIndex = i;
 this.addObservers(entry);
 }
 } else { 
 this.entryCount = 0;
 }

 this.stopIndicator();
 this.index = 0;
 
 if(this.entryCount==1 && this.options.autoSelect) {
 this.selectEntry();
 this.hide();
 } else {
 this.render();
 }
 }
 },

 addObservers: function(element) {
 Event.observe(element, "mouseover", this.onHover.bindAsEventListener(this));
 Event.observe(element, "click", this.onClick.bindAsEventListener(this));
 },

 onObserverEvent: function() {
 this.changed = false; 
 if(this.getToken().length>=this.options.minChars) {
 this.getUpdatedChoices();
 } else {
 this.active = false;
 this.hide();
 }
 },

 getToken: function() {
 var tokenPos = this.findLastToken();
 if (tokenPos != -1)
 var ret = this.element.value.substr(tokenPos + 1).replace(/^\s+/,'').replace(/\s+$/,'');
 else
 var ret = this.element.value;

 return /\n/.test(ret) ? '' : ret;
 },

 findLastToken: function() {
 var lastTokenPos = -1;

 for (var i=0; i<this.options.tokens.length; i++) {
 var thisTokenPos = this.element.value.lastIndexOf(this.options.tokens[i]);
 if (thisTokenPos > lastTokenPos)
 lastTokenPos = thisTokenPos;
 }
 return lastTokenPos;
 }
}

Ajax.Autocompleter = Class.create();
Object.extend(Object.extend(Ajax.Autocompleter.prototype, Autocompleter.Base.prototype), {
 initialize: function(element, update, url, options) {
 this.baseInitialize(element, update, options);
 this.options.asynchronous = true;
 this.options.onComplete = this.onComplete.bind(this);
 this.options.defaultParams = this.options.parameters || null;
 this.url = url;
 },

 getUpdatedChoices: function() {
 this.startIndicator();
 
 var entry = encodeURIComponent(this.options.paramName) + '=' + 
 encodeURIComponent(this.getToken());

 this.options.parameters = this.options.callback ?
 this.options.callback(this.element, entry) : entry;

 if(this.options.defaultParams) 
 this.options.parameters += '&' + this.options.defaultParams;
 
 new Ajax.Request(this.url, this.options);
 },

 onComplete: function(request) {
 this.updateChoices(request.responseText);
 }

});

// The local array autocompleter. Used when you'd prefer to
// inject an array of autocompletion options into the page, rather
// than sending out Ajax queries, which can be quite slow sometimes.
//
// The constructor takes four parameters. The first two are, as usual,
// the id of the monitored textbox, and id of the autocompletion menu.
// The third is the array you want to autocomplete from, and the fourth
// is the options block.
//
// Extra local autocompletion options:
// - choices - How many autocompletion choices to offer
//
// - partialSearch - If false, the autocompleter will match entered
// text only at the beginning of strings in the 
// autocomplete array. Defaults to true, which will
// match text at the beginning of any *word* in the
// strings in the autocomplete array. If you want to
// search anywhere in the string, additionally set
// the option fullSearch to true (default: off).
//
// - fullSsearch - Search anywhere in autocomplete array strings.
//
// - partialChars - How many characters to enter before triggering
// a partial match (unlike minChars, which defines
// how many characters are required to do any match
// at all). Defaults to 2.
//
// - ignoreCase - Whether to ignore case when autocompleting.
// Defaults to true.
//
// It's possible to pass in a custom function as the 'selector' 
// option, if you prefer to write your own autocompletion logic.
// In that case, the other options above will not apply unless
// you support them.

Autocompleter.Local = Class.create();
Autocompleter.Local.prototype = Object.extend(new Autocompleter.Base(), {
 initialize: function(element, update, array, options) {
 this.baseInitialize(element, update, options);
 this.options.array = array;
 },

 getUpdatedChoices: function() {
 this.updateChoices(this.options.selector(this));
 },

 setOptions: function(options) {
 this.options = Object.extend({
 choices: 10,
 partialSearch: true,
 partialChars: 2,
 ignoreCase: true,
 fullSearch: false,
 selector: function(instance) {
 var ret = []; // Beginning matches
 var partial = []; // Inside matches
 var entry = instance.getToken();
 var count = 0;

 for (var i = 0; i < instance.options.array.length && 
 ret.length < instance.options.choices ; i++) { 

 var elem = instance.options.array[i];
 var foundPos = instance.options.ignoreCase ? 
 elem.toLowerCase().indexOf(entry.toLowerCase()) : 
 elem.indexOf(entry);

 while (foundPos != -1) {
 if (foundPos == 0 && elem.length != entry.length) { 
 ret.push("<li><strong>" + elem.substr(0, entry.length) + "</strong>" + 
 elem.substr(entry.length) + "</li>");
 break;
 } else if (entry.length >= instance.options.partialChars && 
 instance.options.partialSearch && foundPos != -1) {
 if (instance.options.fullSearch || /\s/.test(elem.substr(foundPos-1,1))) {
 partial.push("<li>" + elem.substr(0, foundPos) + "<strong>" +
 elem.substr(foundPos, entry.length) + "</strong>" + elem.substr(
 foundPos + entry.length) + "</li>");
 break;
 }
 }

 foundPos = instance.options.ignoreCase ? 
 elem.toLowerCase().indexOf(entry.toLowerCase(), foundPos + 1) : 
 elem.indexOf(entry, foundPos + 1);

 }
 }
 if (partial.length)
 ret = ret.concat(partial.slice(0, instance.options.choices - ret.length))
 return "<ul>" + ret.join('') + "</ul>";
 }
 }, options || {});
 }
});

// AJAX in-place editor
//
// see documentation on http://wiki.script.aculo.us/scriptaculous/show/Ajax.InPlaceEditor

// Use this if you notice weird scrolling problems on some browsers,
// the DOM might be a bit confused when this gets called so do this
// waits 1 ms (with setTimeout) until it does the activation
Field.scrollFreeActivate = function(field) {
 setTimeout(function() {
 Field.activate(field);
 }, 1);
}

Ajax.InPlaceEditor = Class.create();
Ajax.InPlaceEditor.defaultHighlightColor = "#FFFF99";
Ajax.InPlaceEditor.prototype = {
 initialize: function(element, url, options) {
 this.url = url;
 this.element = $(element);

 this.options = Object.extend({
 paramName: "value",
 okButton: true,
 okLink: false,
 okText: "ok",
 cancelButton: false,
 cancelLink: true,
 cancelText: "cancel",
 textBeforeControls: '',
 textBetweenControls: '',
 textAfterControls: '',
 savingText: "Saving...",
 clickToEditText: "Click to edit",
 okText: "ok",
 rows: 1,
 onComplete: function(transport, element) {
 new Effect.Highlight(element, {startcolor: this.options.highlightcolor});
 },
 onFailure: function(transport) {
 alert("Error communicating with the server: " + transport.responseText.stripTags());
 },
 callback: function(form) {
 return Form.serialize(form);
 },
 handleLineBreaks: true,
 loadingText: 'Loading...',
 savingClassName: 'inplaceeditor-saving',
 loadingClassName: 'inplaceeditor-loading',
 formClassName: 'inplaceeditor-form',
 highlightcolor: Ajax.InPlaceEditor.defaultHighlightColor,
 highlightendcolor: "#FFFFFF",
 externalControl: null,
 submitOnBlur: false,
 ajaxOptions: {},
 evalScripts: false
 }, options || {});

 if(!this.options.formId && this.element.id) {
 this.options.formId = this.element.id + "-inplaceeditor";
 if ($(this.options.formId)) {
 // there's already a form with that name, don't specify an id
 this.options.formId = null;
 }
 }
 
 if (this.options.externalControl) {
 this.options.externalControl = $(this.options.externalControl);
 }
 
 this.originalBackground = Element.getStyle(this.element, 'background-color');
 if (!this.originalBackground) {
 this.originalBackground = "transparent";
 }
 
 this.element.title = this.options.clickToEditText;
 
 this.onclickListener = this.enterEditMode.bindAsEventListener(this);
 this.mouseoverListener = this.enterHover.bindAsEventListener(this);
 this.mouseoutListener = this.leaveHover.bindAsEventListener(this);
 Event.observe(this.element, 'click', this.onclickListener);
 Event.observe(this.element, 'mouseover', this.mouseoverListener);
 Event.observe(this.element, 'mouseout', this.mouseoutListener);
 if (this.options.externalControl) {
 Event.observe(this.options.externalControl, 'click', this.onclickListener);
 Event.observe(this.options.externalControl, 'mouseover', this.mouseoverListener);
 Event.observe(this.options.externalControl, 'mouseout', this.mouseoutListener);
 }
 },
 enterEditMode: function(evt) {
 if (this.saving) return;
 if (this.editing) return;
 this.editing = true;
 this.onEnterEditMode();
 if (this.options.externalControl) {
 Element.hide(this.options.externalControl);
 }
 Element.hide(this.element);
 this.createForm();
 this.element.parentNode.insertBefore(this.form, this.element);
 if (!this.options.loadTextURL) Field.scrollFreeActivate(this.editField);
 // stop the event to avoid a page refresh in Safari
 if (evt) {
 Event.stop(evt);
 }
 return false;
 },
 createForm: function() {
 this.form = document.createElement("form");
 this.form.id = this.options.formId;
 Element.addClassName(this.form, this.options.formClassName)
 this.form.onsubmit = this.onSubmit.bind(this);

 this.createEditField();

 if (this.options.textarea) {
 var br = document.createElement("br");
 this.form.appendChild(br);
 }
 
 if (this.options.textBeforeControls)
 this.form.appendChild(document.createTextNode(this.options.textBeforeControls));

 if (this.options.okButton) {
 var okButton = document.createElement("input");
 okButton.type = "submit";
 okButton.value = this.options.okText;
 okButton.className = 'editor_ok_button';
 this.form.appendChild(okButton);
 }
 
 if (this.options.okLink) {
 var okLink = document.createElement("a");
 okLink.href = "#";
 okLink.appendChild(document.createTextNode(this.options.okText));
 okLink.onclick = this.onSubmit.bind(this);
 okLink.className = 'editor_ok_link';
 this.form.appendChild(okLink);
 }
 
 if (this.options.textBetweenControls && 
 (this.options.okLink || this.options.okButton) && 
 (this.options.cancelLink || this.options.cancelButton))
 this.form.appendChild(document.createTextNode(this.options.textBetweenControls));
 
 if (this.options.cancelButton) {
 var cancelButton = document.createElement("input");
 cancelButton.type = "submit";
 cancelButton.value = this.options.cancelText;
 cancelButton.onclick = this.onclickCancel.bind(this);
 cancelButton.className = 'editor_cancel_button';
 this.form.appendChild(cancelButton);
 }

 if (this.options.cancelLink) {
 var cancelLink = document.createElement("a");
 cancelLink.href = "#";
 cancelLink.appendChild(document.createTextNode(this.options.cancelText));
 cancelLink.onclick = this.onclickCancel.bind(this);
 cancelLink.className = 'editor_cancel editor_cancel_link'; 
 this.form.appendChild(cancelLink);
 }
 
 if (this.options.textAfterControls)
 this.form.appendChild(document.createTextNode(this.options.textAfterControls));
 },
 hasHTMLLineBreaks: function(string) {
 if (!this.options.handleLineBreaks) return false;
 return string.match(/<br/i) || string.match(/<p>/i);
 },
 convertHTMLLineBreaks: function(string) {
 return string.replace(/<br>/gi, "\n").replace(/<br\/>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<p>/gi, "");
 },
 createEditField: function() {
 var text;
 if(this.options.loadTextURL) {
 text = this.options.loadingText;
 } else {
 text = this.getText();
 }

 var obj = this;
 
 if (this.options.rows == 1 && !this.hasHTMLLineBreaks(text)) {
 this.options.textarea = false;
 var textField = document.createElement("input");
 textField.obj = this;
 textField.type = "text";
 textField.name = this.options.paramName;
 textField.value = text;
 textField.style.backgroundColor = this.options.highlightcolor;
 textField.className = 'editor_field';
 var size = this.options.size || this.options.cols || 0;
 if (size != 0) textField.size = size;
 if (this.options.submitOnBlur)
 textField.onblur = this.onSubmit.bind(this);
 this.editField = textField;
 } else {
 this.options.textarea = true;
 var textArea = document.createElement("textarea");
 textArea.obj = this;
 textArea.name = this.options.paramName;
 textArea.value = this.convertHTMLLineBreaks(text);
 textArea.rows = this.options.rows;
 textArea.cols = this.options.cols || 40;
 textArea.className = 'editor_field'; 
 if (this.options.submitOnBlur)
 textArea.onblur = this.onSubmit.bind(this);
 this.editField = textArea;
 }
 
 if(this.options.loadTextURL) {
 this.loadExternalText();
 }
 this.form.appendChild(this.editField);
 },
 getText: function() {
 return this.element.innerHTML;
 },
 loadExternalText: function() {
 Element.addClassName(this.form, this.options.loadingClassName);
 this.editField.disabled = true;
 new Ajax.Request(
 this.options.loadTextURL,
 Object.extend({
 asynchronous: true,
 onComplete: this.onLoadedExternalText.bind(this)
 }, this.options.ajaxOptions)
 );
 },
 onLoadedExternalText: function(transport) {
 Element.removeClassName(this.form, this.options.loadingClassName);
 this.editField.disabled = false;
 this.editField.value = transport.responseText.stripTags();
 Field.scrollFreeActivate(this.editField);
 },
 onclickCancel: function() {
 this.onComplete();
 this.leaveEditMode();
 return false;
 },
 onFailure: function(transport) {
 this.options.onFailure(transport);
 if (this.oldInnerHTML) {
 this.element.innerHTML = this.oldInnerHTML;
 this.oldInnerHTML = null;
 }
 return false;
 },
 onSubmit: function() {
 // onLoading resets these so we need to save them away for the Ajax call
 var form = this.form;
 var value = this.editField.value;
 
 // do this first, sometimes the ajax call returns before we get a chance to switch on Saving...
 // which means this will actually switch on Saving... *after* we've left edit mode causing Saving...
 // to be displayed indefinitely
 this.onLoading();
 
 if (this.options.evalScripts) {
 new Ajax.Request(
 this.url, Object.extend({
 parameters: this.options.callback(form, value),
 onComplete: this.onComplete.bind(this),
 onFailure: this.onFailure.bind(this),
 asynchronous:true, 
 evalScripts:true
 }, this.options.ajaxOptions));
 } else {
 new Ajax.Updater(
 { success: this.element,
 // don't update on failure (this could be an option)
 failure: null }, 
 this.url, Object.extend({
 parameters: this.options.callback(form, value),
 onComplete: this.onComplete.bind(this),
 onFailure: this.onFailure.bind(this)
 }, this.options.ajaxOptions));
 }
 // stop the event to avoid a page refresh in Safari
 if (arguments.length > 1) {
 Event.stop(arguments[0]);
 }
 return false;
 },
 onLoading: function() {
 this.saving = true;
 this.removeForm();
 this.leaveHover();
 this.showSaving();
 },
 showSaving: function() {
 this.oldInnerHTML = this.element.innerHTML;
 this.element.innerHTML = this.options.savingText;
 Element.addClassName(this.element, this.options.savingClassName);
 this.element.style.backgroundColor = this.originalBackground;
 Element.show(this.element);
 },
 removeForm: function() {
 if(this.form) {
 if (this.form.parentNode) Element.remove(this.form);
 this.form = null;
 }
 },
 enterHover: function() {
 if (this.saving) return;
 this.element.style.backgroundColor = this.options.highlightcolor;
 if (this.effect) {
 this.effect.cancel();
 }
 Element.addClassName(this.element, this.options.hoverClassName)
 },
 leaveHover: function() {
 if (this.options.backgroundColor) {
 this.element.style.backgroundColor = this.oldBackground;
 }
 Element.removeClassName(this.element, this.options.hoverClassName)
 if (this.saving) return;
 this.effect = new Effect.Highlight(this.element, {
 startcolor: this.options.highlightcolor,
 endcolor: this.options.highlightendcolor,
 restorecolor: this.originalBackground
 });
 },
 leaveEditMode: function() {
 Element.removeClassName(this.element, this.options.savingClassName);
 this.removeForm();
 this.leaveHover();
 this.element.style.backgroundColor = this.originalBackground;
 Element.show(this.element);
 if (this.options.externalControl) {
 Element.show(this.options.externalControl);
 }
 this.editing = false;
 this.saving = false;
 this.oldInnerHTML = null;
 this.onLeaveEditMode();
 },
 onComplete: function(transport) {
 this.leaveEditMode();
 this.options.onComplete.bind(this)(transport, this.element);
 },
 onEnterEditMode: function() {},
 onLeaveEditMode: function() {},
 dispose: function() {
 if (this.oldInnerHTML) {
 this.element.innerHTML = this.oldInnerHTML;
 }
 this.leaveEditMode();
 Event.stopObserving(this.element, 'click', this.onclickListener);
 Event.stopObserving(this.element, 'mouseover', this.mouseoverListener);
 Event.stopObserving(this.element, 'mouseout', this.mouseoutListener);
 if (this.options.externalControl) {
 Event.stopObserving(this.options.externalControl, 'click', this.onclickListener);
 Event.stopObserving(this.options.externalControl, 'mouseover', this.mouseoverListener);
 Event.stopObserving(this.options.externalControl, 'mouseout', this.mouseoutListener);
 }
 }
};

Ajax.InPlaceCollectionEditor = Class.create();
Object.extend(Ajax.InPlaceCollectionEditor.prototype, Ajax.InPlaceEditor.prototype);
Object.extend(Ajax.InPlaceCollectionEditor.prototype, {
 createEditField: function() {
 if (!this.cached_selectTag) {
 var selectTag = document.createElement("select");
 var collection = this.options.collection || [];
 var optionTag;
 collection.each(function(e,i) {
 optionTag = document.createElement("option");
 optionTag.value = (e instanceof Array) ? e[0] : e;
 if((typeof this.options.value == 'undefined') && 
 ((e instanceof Array) ? this.element.innerHTML == e[1] : e == optionTag.value)) optionTag.selected = true;
 if(this.options.value==optionTag.value) optionTag.selected = true;
 optionTag.appendChild(document.createTextNode((e instanceof Array) ? e[1] : e));
 selectTag.appendChild(optionTag);
 }.bind(this));
 this.cached_selectTag = selectTag;
 }

 this.editField = this.cached_selectTag;
 if(this.options.loadTextURL) this.loadExternalText();
 this.form.appendChild(this.editField);
 this.options.callback = function(form, value) {
 return "value=" + encodeURIComponent(value);
 }
 }
});

// Delayed observer, like Form.Element.Observer, 
// but waits for delay after last key input
// Ideal for live-search fields

Form.Element.DelayedObserver = Class.create();
Form.Element.DelayedObserver.prototype = {
 initialize: function(element, delay, callback) {
 this.delay = delay || 0.5;
 this.element = $(element);
 this.callback = callback;
 this.timer = null;
 this.lastValue = $F(this.element); 
 Event.observe(this.element,'keyup',this.delayedListener.bindAsEventListener(this));
 },
 delayedListener: function(event) {
 if(this.lastValue == $F(this.element)) return;
 if(this.timer) clearTimeout(this.timer);
 this.timer = setTimeout(this.onTimerEvent.bind(this), this.delay * 1000);
 this.lastValue = $F(this.element);
 },
 onTimerEvent: function() {
 this.timer = null;
 this.callback(this.element, $F(this.element));
 }
};
// script.aculo.us slider.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007

// Copyright (c) 2005-2007 Marty Haught, Thomas Fuchs 
//
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

if(!Control) var Control = {};
Control.Slider = Class.create();

// options:
// axis: 'vertical', or 'horizontal' (default)
//
// callbacks:
// onChange(value)
// onSlide(value)
Control.Slider.prototype = {
 initialize: function(handle, track, options) {
 var slider = this;
 
 if(handle instanceof Array) {
 this.handles = handle.collect( function(e) { return $(e) });
 } else {
 this.handles = [$(handle)];
 }
 
 this.track = $(track);
 this.options = options || {};

 this.axis = this.options.axis || 'horizontal';
 this.increment = this.options.increment || 1;
 this.step = parseInt(this.options.step || '1');
 this.range = this.options.range || $R(0,1);
 
 this.value = 0; // assure backwards compat
 this.values = this.handles.map( function() { return 0 });
 this.spans = this.options.spans ? this.options.spans.map(function(s){ return $(s) }) : false;
 this.options.startSpan = $(this.options.startSpan || null);
 this.options.endSpan = $(this.options.endSpan || null);

 this.restricted = this.options.restricted || false;

 this.maximum = this.options.maximum || this.range.end;
 this.minimum = this.options.minimum || this.range.start;

 // Will be used to align the handle onto the track, if necessary
 this.alignX = parseInt(this.options.alignX || '0');
 this.alignY = parseInt(this.options.alignY || '0');
 
 this.trackLength = this.maximumOffset() - this.minimumOffset();

 this.handleLength = this.isVertical() ? 
 (this.handles[0].offsetHeight != 0 ? 
 this.handles[0].offsetHeight : this.handles[0].style.height.replace(/px$/,"")) : 
 (this.handles[0].offsetWidth != 0 ? this.handles[0].offsetWidth : 
 this.handles[0].style.width.replace(/px$/,""));

 this.active = false;
 this.dragging = false;
 this.disabled = false;

 if(this.options.disabled) this.setDisabled();

 // Allowed values array
 this.allowedValues = this.options.values ? this.options.values.sortBy(Prototype.K) : false;
 if(this.allowedValues) {
 this.minimum = this.allowedValues.min();
 this.maximum = this.allowedValues.max();
 }

 this.eventMouseDown = this.startDrag.bindAsEventListener(this);
 this.eventMouseUp = this.endDrag.bindAsEventListener(this);
 this.eventMouseMove = this.update.bindAsEventListener(this);

 // Initialize handles in reverse (make sure first handle is active)
 this.handles.each( function(h,i) {
 i = slider.handles.length-1-i;
 slider.setValue(parseFloat(
 (slider.options.sliderValue instanceof Array ? 
 slider.options.sliderValue[i] : slider.options.sliderValue) || 
 slider.range.start), i);
 Element.makePositioned(h); // fix IE
 Event.observe(h, "mousedown", slider.eventMouseDown);
 });
 
 Event.observe(this.track, "mousedown", this.eventMouseDown);
 Event.observe(document, "mouseup", this.eventMouseUp);
 Event.observe(document, "mousemove", this.eventMouseMove);
 
 this.initialized = true;
 },
 dispose: function() {
 var slider = this; 
 Event.stopObserving(this.track, "mousedown", this.eventMouseDown);
 Event.stopObserving(document, "mouseup", this.eventMouseUp);
 Event.stopObserving(document, "mousemove", this.eventMouseMove);
 this.handles.each( function(h) {
 Event.stopObserving(h, "mousedown", slider.eventMouseDown);
 });
 },
 setDisabled: function(){
 this.disabled = true;
 },
 setEnabled: function(){
 this.disabled = false;
 }, 
 getNearestValue: function(value){
 if(this.allowedValues){
 if(value >= this.allowedValues.max()) return(this.allowedValues.max());
 if(value <= this.allowedValues.min()) return(this.allowedValues.min());
 
 var offset = Math.abs(this.allowedValues[0] - value);
 var newValue = this.allowedValues[0];
 this.allowedValues.each( function(v) {
 var currentOffset = Math.abs(v - value);
 if(currentOffset <= offset){
 newValue = v;
 offset = currentOffset;
 } 
 });
 return newValue;
 }
 if(value > this.range.end) return this.range.end;
 if(value < this.range.start) return this.range.start;
 return value;
 },
 setValue: function(sliderValue, handleIdx){
 if(!this.active) {
 this.activeHandleIdx = handleIdx || 0;
 this.activeHandle = this.handles[this.activeHandleIdx];
 this.updateStyles();
 }
 handleIdx = handleIdx || this.activeHandleIdx || 0;
 if(this.initialized && this.restricted) {
 if((handleIdx>0) && (sliderValue<this.values[handleIdx-1]))
 sliderValue = this.values[handleIdx-1];
 if((handleIdx < (this.handles.length-1)) && (sliderValue>this.values[handleIdx+1]))
 sliderValue = this.values[handleIdx+1];
 }
 sliderValue = this.getNearestValue(sliderValue);
 this.values[handleIdx] = sliderValue;
 this.value = this.values[0]; // assure backwards compat
 
 this.handles[handleIdx].style[this.isVertical() ? 'top' : 'left'] = 
 this.translateToPx(sliderValue);
 
 this.drawSpans();
 if(!this.dragging || !this.event) this.updateFinished();
 },
 setValueBy: function(delta, handleIdx) {
 this.setValue(this.values[handleIdx || this.activeHandleIdx || 0] + delta, 
 handleIdx || this.activeHandleIdx || 0);
 },
 translateToPx: function(value) {
 return Math.round(
 ((this.trackLength-this.handleLength)/(this.range.end-this.range.start)) * 
 (value - this.range.start)) + "px";
 },
 translateToValue: function(offset) {
 return ((offset/(this.trackLength-this.handleLength) * 
 (this.range.end-this.range.start)) + this.range.start);
 },
 getRange: function(range) {
 var v = this.values.sortBy(Prototype.K); 
 range = range || 0;
 return $R(v[range],v[range+1]);
 },
 minimumOffset: function(){
 return(this.isVertical() ? this.alignY : this.alignX);
 },
 maximumOffset: function(){
 return(this.isVertical() ? 
 (this.track.offsetHeight != 0 ? this.track.offsetHeight :
 this.track.style.height.replace(/px$/,"")) - this.alignY : 
 (this.track.offsetWidth != 0 ? this.track.offsetWidth : 
 this.track.style.width.replace(/px$/,"")) - this.alignY);
 }, 
 isVertical: function(){
 return (this.axis == 'vertical');
 },
 drawSpans: function() {
 var slider = this;
 if(this.spans)
 $R(0, this.spans.length-1).each(function(r) { slider.setSpan(slider.spans[r], slider.getRange(r)) });
 if(this.options.startSpan)
 this.setSpan(this.options.startSpan,
 $R(0, this.values.length>1 ? this.getRange(0).min() : this.value ));
 if(this.options.endSpan)
 this.setSpan(this.options.endSpan, 
 $R(this.values.length>1 ? this.getRange(this.spans.length-1).max() : this.value, this.maximum));
 },
 setSpan: function(span, range) {
 if(this.isVertical()) {
 span.style.top = this.translateToPx(range.start);
 span.style.height = this.translateToPx(range.end - range.start + this.range.start);
 } else {
 span.style.left = this.translateToPx(range.start);
 span.style.width = this.translateToPx(range.end - range.start + this.range.start);
 }
 },
 updateStyles: function() {
 this.handles.each( function(h){ Element.removeClassName(h, 'selected') });
 Element.addClassName(this.activeHandle, 'selected');
 },
 startDrag: function(event) {
 if(Event.isLeftClick(event)) {
 if(!this.disabled){
 this.active = true;
 
 var handle = Event.element(event);
 var pointer = [Event.pointerX(event), Event.pointerY(event)];
 var track = handle;
 if(track==this.track) {
 var offsets = Position.cumulativeOffset(this.track); 
 this.event = event;
 this.setValue(this.translateToValue( 
 (this.isVertical() ? pointer[1]-offsets[1] : pointer[0]-offsets[0])-(this.handleLength/2)
 ));
 var offsets = Position.cumulativeOffset(this.activeHandle);
 this.offsetX = (pointer[0] - offsets[0]);
 this.offsetY = (pointer[1] - offsets[1]);
 } else {
 // find the handle (prevents issues with Safari)
 while((this.handles.indexOf(handle) == -1) && handle.parentNode) 
 handle = handle.parentNode;
 
 if(this.handles.indexOf(handle)!=-1) {
 this.activeHandle = handle;
 this.activeHandleIdx = this.handles.indexOf(this.activeHandle);
 this.updateStyles();
 
 var offsets = Position.cumulativeOffset(this.activeHandle);
 this.offsetX = (pointer[0] - offsets[0]);
 this.offsetY = (pointer[1] - offsets[1]);
 }
 }
 }
 Event.stop(event);
 }
 },
 update: function(event) {
 if(this.active) {
 if(!this.dragging) this.dragging = true;
 this.draw(event);
 if(Prototype.Browser.WebKit) window.scrollBy(0,0);
 Event.stop(event);
 }
 },
 draw: function(event) {
 var pointer = [Event.pointerX(event), Event.pointerY(event)];
 var offsets = Position.cumulativeOffset(this.track);
 pointer[0] -= this.offsetX + offsets[0];
 pointer[1] -= this.offsetY + offsets[1];
 this.event = event;
 this.setValue(this.translateToValue( this.isVertical() ? pointer[1] : pointer[0] ));
 if(this.initialized && this.options.onSlide)
 this.options.onSlide(this.values.length>1 ? this.values : this.value, this);
 },
 endDrag: function(event) {
 if(this.active && this.dragging) {
 this.finishDrag(event, true);
 Event.stop(event);
 }
 this.active = false;
 this.dragging = false;
 }, 
 finishDrag: function(event, success) {
 this.active = false;
 this.dragging = false;
 this.updateFinished();
 },
 updateFinished: function() {
 if(this.initialized && this.options.onChange) 
 this.options.onChange(this.values.length>1 ? this.values : this.value, this);
 this.event = null;
 }
}/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is bundled with this package in the file LICENSE.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/osl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@magentocommerce.com so we can send you a copy immediately.
 *
 * @copyright Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
 * @license http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 */
function popWin(url,win,para) {
 var win = window.open(url,win,para);
 win.focus();
}

function setLocation(url){
 window.location.href = url;
}

function setPLocation(url, setFocus){
 if( setFocus ) {
 window.opener.focus();
 }
 window.opener.location.href = url;
}

function setLanguageCode(code, fromCode){
 //TODO: javascript cookies have different domain and path than php cookies
 var href = window.location.href;
 var after = '', dash;
 if (dash = href.match(/\#(.*)$/)) {
 href = href.replace(/\#(.*)$/, '');
 after = dash[0];
 }

 if (href.match(/[?]/)) {
 var re = /([?&]store=)[a-z0-9_]*/;
 if (href.match(re)) {
 href = href.replace(re, '$1'+code);
 } else {
 href += '&store='+code;
 }

 var re = /([?&]from_store=)[a-z0-9_]*/;
 if (href.match(re)) {
 href = href.replace(re, '');
 }
 } else {
 href += '?store='+code;
 }
 if (typeof(fromCode) != 'undefined') {
 href += '&from_store='+fromCode;
 }
 href += after;

 setLocation(href);
}

/**
 * Add classes to specified elements.
 * Supported classes are: 'odd', 'even', 'first', 'last'
 *
 * @param elements - array of elements to be decorated
 * [@param decorateParams] - array of classes to be set. If omitted, all available will be used
 */
function decorateGeneric(elements, decorateParams)
{
 var allSupportedParams = ['odd', 'even', 'first', 'last'];
 var _decorateParams = {};
 var total = elements.length;

 if (total) {
 // determine params called
 if (typeof(decorateParams) == 'undefined') {
 decorateParams = allSupportedParams;
 }
 if (!decorateParams.length) {
 return;
 }
 for (var k in allSupportedParams) {
 _decorateParams[allSupportedParams[k]] = false;
 }
 for (var k in decorateParams) {
 _decorateParams[decorateParams[k]] = true;
 }

 // decorate elements
 // elements[0].addClassName('first'); // will cause bug in IE (#5587)
 if (_decorateParams.first) {
 Element.addClassName(elements[0], 'first');
 }
 if (_decorateParams.last) {
 Element.addClassName(elements[total-1], 'last');
 }
 for (var i = 0; i < total; i++) {
 if ((i + 1) % 2 == 0) {
 if (_decorateParams.even) {
 Element.addClassName(elements[i], 'even');
 }
 }
 else {
 if (_decorateParams.odd) {
 Element.addClassName(elements[i], 'odd');
 }
 }
 }
 }
}

/**
 * Decorate table rows and cells, tbody etc
 * @see decorateGeneric()
 */
function decorateTable(table, options) {
 var table = $(table);
 if (table) {
 // set default options
 var _options = {
 'tbody' : false,
 'tbody tr' : ['odd', 'even', 'first', 'last'],
 'thead tr' : ['first', 'last'],
 'tfoot tr' : ['first', 'last'],
 'tr td' : ['last']
 };
 // overload options
 if (typeof(options) != 'undefined') {
 for (var k in options) {
 _options[k] = options[k];
 }
 }
 // decorate
 if (_options['tbody']) {
 decorateGeneric(table.getElementsBySelector('tbody'), _options['tbody']);
 }
 if (_options['tbody tr']) {
 decorateGeneric(table.getElementsBySelector('tbody tr'), _options['tbody tr']);
 }
 if (_options['thead tr']) {
 decorateGeneric(table.getElementsBySelector('thead tr'), _options['thead tr']);
 }
 if (_options['tfoot tr']) {
 decorateGeneric(table.getElementsBySelector('tfoot tr'), _options['tfoot tr']);
 }
 if (_options['tr td']) {
 var allRows = table.getElementsBySelector('tr');
 if (allRows.length) {
 for (var i = 0; i < allRows.length; i++) {
 decorateGeneric(allRows[i].getElementsByTagName('TD'), _options['tr td']);
 }
 }
 }
 }
}

/**
 * Set "odd", "even" and "last" CSS classes for list items
 * @see decorateGeneric()
 */
function decorateList(list, nonRecursive) {
 if ($(list)) {
 if (typeof(nonRecursive) == 'undefined') {
 var items = $(list).getElementsBySelector('li')
 }
 else {
 var items = $(list).childElements();
 }
 decorateGeneric(items, ['odd', 'even', 'last']);
 }
}

/**
 * Set "odd", "even" and "last" CSS classes for list items
 * @see decorateGeneric()
 */
function decorateDataList(list) {
 list = $(list);
 if (list) {
 decorateGeneric(list.getElementsBySelector('dt'), ['odd', 'even', 'last']);
 decorateGeneric(list.getElementsBySelector('dd'), ['odd', 'even', 'last']);
 }
}

/**
 * Formats currency using patern
 * format - JSON (pattern, decimal, decimalsDelimeter, groupsDelimeter)
 * showPlus - true (always show '+'or '-'),
 * false (never show '-' even if number is negative)
 * null (show '-' if number is negative)
 */

function formatCurrency(price, format, showPlus){
 precision = isNaN(format.precision = Math.abs(format.precision)) ? 2 : format.precision;
 requiredPrecision = isNaN(format.requiredPrecision = Math.abs(format.requiredPrecision)) ? 2 : format.requiredPrecision;

 //precision = (precision > requiredPrecision) ? precision : requiredPrecision;
 //for now we don't need this difference so precision is requiredPrecision
 precision = requiredPrecision;

 integerRequired = isNaN(format.integerRequired = Math.abs(format.integerRequired)) ? 1 : format.integerRequired;

 decimalSymbol = format.decimalSymbol == undefined ? "," : format.decimalSymbol;
 groupSymbol = format.groupSymbol == undefined ? "." : format.groupSymbol;
 groupLength = format.groupLength == undefined ? 3 : format.groupLength;

 if (showPlus == undefined || showPlus == true) {
 s = price < 0 ? "-" : ( showPlus ? "+" : "");
 } else if (showPlus == false) {
 s = '';
 }

 i = parseInt(price = Math.abs(+price || 0).toFixed(precision)) + "";
 pad = (i.length < integerRequired) ? (integerRequired - i.length) : 0;
 while (pad) { i = '0' + i; pad--; }

 j = (j = i.length) > groupLength ? j % groupLength : 0;
 re = new RegExp("(\\d{" + groupLength + "})(?=\\d)", "g");

 /**
 * replace(/-/, 0) is only for fixing Safari bug which appears
 * when Math.abs(0).toFixed() executed on "0" number.
 * Result is "0.-0" :(
 */
 r = (j ? i.substr(0, j) + groupSymbol : "") + i.substr(j).replace(re, "$1" + groupSymbol) + (precision ? decimalSymbol + Math.abs(price - i).toFixed(precision).replace(/-/, 0).slice(2) : "")

 if (format.pattern.indexOf('{sign}') == -1) {
 pattern = s + format.pattern;
 } else {
 pattern = format.pattern.replace('{sign}', s);
 }

 return pattern.replace('%s', r).replace(/^\s\s*/, '').replace(/\s\s*$/, '');
};

function expandDetails(el, childClass) {
 if (Element.hasClassName(el,'show-details')) {
 $$(childClass).each(function(item){item.hide()});
 Element.removeClassName(el,'show-details');
 }
 else {
 $$(childClass).each(function(item){item.show()});
 Element.addClassName(el,'show-details');
 }
}

// Version 1.0
var isIE = navigator.appVersion.match(/MSIE/) == "MSIE";

if (!window.Varien)
 var Varien = new Object();

Varien.showLoading = function(){
 Element.show('loading-process');
}
Varien.hideLoading = function(){
 Element.hide('loading-process');
}
Varien.GlobalHandlers = {
 onCreate: function() {
 Varien.showLoading();
 },

 onComplete: function() {
 if(Ajax.activeRequestCount == 0) {
 Varien.hideLoading();
 }
 }
};

Ajax.Responders.register(Varien.GlobalHandlers);

/**
 * Quick Search form client model
 */
Varien.searchForm = Class.create();
Varien.searchForm.prototype = {
 initialize : function(form, field, emptyText){
 this.form = $(form);
 this.field = $(field);
 this.emptyText = emptyText;

 Event.observe(this.form, 'submit', this.submit.bind(this));
 Event.observe(this.field, 'focus', this.focus.bind(this));
 Event.observe(this.field, 'blur', this.blur.bind(this));
 this.blur();
 },

 submit : function(event){
 if (this.field.value == this.emptyText || this.field.value == ''){
 Event.stop(event);
 return false;
 }
 return true;
 },

 focus : function(event){
 if(this.field.value==this.emptyText){
 this.field.value='';
 }

 },

 blur : function(event){
 if(this.field.value==''){
 this.field.value=this.emptyText;
 }
 },

 initAutocomplete : function(url, destinationElement){
 new Ajax.Autocompleter(
 this.field,
 destinationElement,
 url,
 {
 paramName: this.field.name,
 minChars: 2,
 updateElement: this._selectAutocompleteItem.bind(this)
 }
 );
 },

 _selectAutocompleteItem : function(element){
 if(element.title){
 this.field.value = element.title;
 }
 this.submit();
 }
}

Varien.Tabs = Class.create();
Varien.Tabs.prototype = {
 initialize: function(selector) {
 var self=this;
 $$(selector+' a').each(this.initTab.bind(this));
 },

 initTab: function(el) {
 el.href = 'javascript:void(0)';
 if ($(el.parentNode).hasClassName('active')) {
 this.showContent(el);
 }
 el.observe('click', this.showContent.bind(this, el));
 },

 showContent: function(a) {
 var li = $(a.parentNode), ul = $(li.parentNode);
 ul.getElementsBySelector('li', 'ol').each(function(el){
 var contents = $(el.id+'_contents');
 if (el==li) {
 el.addClassName('active');
 contents.show();
 } else {
 el.removeClassName('active');
 contents.hide();
 }
 });
 }
}

Varien.DOB = Class.create();
Varien.DOB.prototype = {
 initialize: function(selector, required) {
 var el = $$(selector)[0];
 this.day = $(el).getElementsBySelector('.dob-day input')[0];
 this.month = $(el).getElementsBySelector('.dob-month input')[0];
 this.year = $(el).getElementsBySelector('.dob-year input')[0];
 this.dob = $(el).getElementsBySelector('.dob-full input')[0];
 this.advice = $(el).getElementsBySelector('.validation-advice')[0];
 this.required = required;

 this.day.validate = this.validate.bind(this);
 this.month.validate = this.validate.bind(this);
 this.year.validate = this.validate.bind(this);

 this.advice.hide();
 },

 validate: function() {
 var error = false;

 if (this.day.value=='' && this.month.value=='' && this.year.value=='') {
 if (this.required) {
 error = 'This date is a required value.';
 } else {
 this.dob.value = '';
 }
 } else if (this.day.value=='' || this.month.value=='' || this.year.value=='') {
 error = 'Please enter a valid full date.';
 } else {
 var date = new Date();
 if (this.day.value<1 || this.day.value>31) {
 error = 'Please enter a valid day (1-31).';
 } else if (this.month.value<1 || this.month.value>12) {
 error = 'Please enter a valid month (1-12).';
 } else if (this.year.value<1900 || this.year.value>date.getFullYear()) {
 error = 'Please enter a valid year (1900-'+date.getFullYear()+').';
 } else {
 this.dob.value = this.month.value+'/'+this.day.value+'/'+this.year.value;
 var test = new Date(this.dob.value);
 if (isNaN(test)) {
 error = 'Please enter a valid date.';
 }
 }
 }

 if (error !== false) {
 this.advice.innerHTML = Translator.translate(error);
 this.advice.show();
 return false;
 }

 this.advice.hide();
 return true;
 }
}

Validation.addAllThese([
 ['validate-custom', ' ', function(v,elm) {
 return elm.validate();
 }]
]);

function truncateOptions() {
 $$('.truncated').each(function(element){
 Event.observe(element, 'mouseover', function(){
 if (element.down('div.truncated_full_value')) {
 element.down('div.truncated_full_value').addClassName('show')
 }
 });
 Event.observe(element, 'mouseout', function(){
 if (element.down('div.truncated_full_value')) {
 element.down('div.truncated_full_value').removeClassName('show')
 }
 });

 });
}
Event.observe(window, 'load', function(){
 truncateOptions();
});/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is bundled with this package in the file LICENSE.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/osl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@magentocommerce.com so we can send you a copy immediately.
 *
 * @copyright Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
 * @license http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 */
VarienForm = Class.create();
VarienForm.prototype = {
 initialize: function(formId, firstFieldFocus){
 this.form = $(formId);
 if (!this.form) {
 return;
 }
 this.cache = $A();
 this.currLoader = false;
 this.currDataIndex = false;
 this.validator = new Validation(this.form);
 this.elementFocus = this.elementOnFocus.bindAsEventListener(this);
 this.elementBlur = this.elementOnBlur.bindAsEventListener(this);
 this.childLoader = this.onChangeChildLoad.bindAsEventListener(this);
 this.highlightClass = 'highlight';
 this.extraChildParams = '';
 this.firstFieldFocus= firstFieldFocus || false;
 this.bindElements();
 if(this.firstFieldFocus){
 try{
 Form.Element.focus(Form.findFirstElement(this.form))
 }
 catch(e){}
 }
 },

 submit : function(url){
 if(this.validator && this.validator.validate()){
 this.form.submit();
 }
 return false;
 },

 bindElements:function (){
 var elements = Form.getElements(this.form);
 for (var row in elements) {
 if (elements[row].id) {
 Event.observe(elements[row],'focus',this.elementFocus);
 Event.observe(elements[row],'blur',this.elementBlur);
 }
 }
 },

 elementOnFocus: function(event){
 var element = Event.findElement(event, 'fieldset');
 if(element.className){
 Element.addClassName(element, this.highlightClass);
 }
 },

 elementOnBlur: function(event){
 var element = Event.findElement(event, 'fieldset');
 if(element.className){
 Element.removeClassName(element, this.highlightClass);
 }
 },

 setElementsRelation: function(parent, child, dataUrl, first){
 if (parent=$(parent)) {
 // TODO: array of relation and caching
 if (!this.cache[parent.id]){
 this.cache[parent.id] = $A();
 this.cache[parent.id]['child'] = child;
 this.cache[parent.id]['dataUrl'] = dataUrl;
 this.cache[parent.id]['data'] = $A();
 this.cache[parent.id]['first'] = first || false;
 }
 Event.observe(parent,'change',this.childLoader);
 }
 },

 onChangeChildLoad: function(event){
 element = Event.element(event);
 this.elementChildLoad(element);
 },

 elementChildLoad: function(element, callback){
 this.callback = callback || false;
 if (element.value) {
 this.currLoader = element.id;
 this.currDataIndex = element.value;
 if (this.cache[element.id]['data'][element.value]) {
 this.setDataToChild(this.cache[element.id]['data'][element.value]);
 }
 else{
 new Ajax.Request(this.cache[this.currLoader]['dataUrl'],{
 method: 'post',
 parameters: {"parent":element.value},
 onComplete: this.reloadChildren.bind(this)
 });
 }
 }
 },

 reloadChildren: function(transport){
 var data = eval('(' + transport.responseText + ')');
 this.cache[this.currLoader]['data'][this.currDataIndex] = data;
 this.setDataToChild(data);
 },

 setDataToChild: function(data){
 if (data.length) {
 var child = $(this.cache[this.currLoader]['child']);
 if (child){
 var html = '<select name="'+child.name+'" id="'+child.id+'" class="'+child.className+'" title="'+child.title+'" '+this.extraChildParams+'>';
 if(this.cache[this.currLoader]['first']){
 html+= '<option value="">'+this.cache[this.currLoader]['first']+'</option>';
 }
 for (var i in data){
 if(data[i].value) {
 html+= '<option value="'+data[i].value+'"';
 if(child.value && (child.value == data[i].value || child.value == data[i].label)){
 html+= ' selected';
 }
 html+='>'+data[i].label+'</option>';
 }
 }
 html+= '</select>';
 new Insertion.Before(child,html);
 Element.remove(child);
 }
 }
 else{
 var child = $(this.cache[this.currLoader]['child']);
 if (child){
 var html = '<input type="text" name="'+child.name+'" id="'+child.id+'" class="'+child.className+'" title="'+child.title+'" '+this.extraChildParams+'>';
 new Insertion.Before(child,html);
 Element.remove(child);
 }
 }

 this.bindElements();
 if (this.callback) {
 this.callback();
 }
 }
}

RegionUpdater = Class.create();
RegionUpdater.prototype = {
 initialize: function (countryEl, regionTextEl, regionSelectEl, regions, disableAction)
 {
 this.countryEl = $(countryEl);
 this.regionTextEl = $(regionTextEl);
 this.regionSelectEl = $(regionSelectEl);
 this.regions = regions;

 this.disableAction = (typeof disableAction=='undefined') ? 'hide' : disableAction;

 if (this.regionSelectEl.options.length<=1) {
 this.update();
 }

 Event.observe(this.countryEl, 'change', this.update.bind(this));
 },

 update: function()
 {
 if (this.regions[this.countryEl.value]) {
 var i, option, region, def;

 if (this.regionTextEl) {
 def = this.regionTextEl.value.toLowerCase();
 this.regionTextEl.value = '';
 }
 if (!def) {
 def = this.regionSelectEl.getAttribute('defaultValue');
 }

 this.regionSelectEl.options.length = 1;
 for (regionId in this.regions[this.countryEl.value]) {
 region = this.regions[this.countryEl.value][regionId];

 option = document.createElement('OPTION');
 option.value = regionId;
 option.text = region.name;

 if (this.regionSelectEl.options.add) {
 this.regionSelectEl.options.add(option);
 } else {
 this.regionSelectEl.appendChild(option);
 }

 if (regionId==def || region.name.toLowerCase()==def || region.code.toLowerCase()==def) {
 this.regionSelectEl.value = regionId;
 }
 }

 if (this.disableAction=='hide') {
 if (this.regionTextEl) {
 this.regionTextEl.style.display = 'none';
 }

 this.regionSelectEl.style.display = '';
 } else if (this.disableAction=='disable') {
 if (this.regionTextEl) {
 this.regionTextEl.disabled = true;
 }
 this.regionSelectEl.disabled = false;
 }
 this.setMarkDisplay(this.regionSelectEl, true);
 } else {
 if (this.disableAction=='hide') {
 if (this.regionTextEl) {
 this.regionTextEl.style.display = '';
 }
 this.regionSelectEl.style.display = 'none';
 Validation.reset(this.regionSelectEl);
 } else if (this.disableAction=='disable') {
 if (this.regionTextEl) {
 this.regionTextEl.disabled = false;
 }
 this.regionSelectEl.disabled = true;
 } else if (this.disableAction=='nullify') {
 this.regionSelectEl.options.length = 1;
 this.regionSelectEl.value = '';
 this.regionSelectEl.selectedIndex = 0;
 this.lastCountryId = '';
 }
 this.setMarkDisplay(this.regionSelectEl, false);
 }
 },

 setMarkDisplay: function(elem, display){
 if(elem.parentNode){
 var marks = Element.getElementsByClassName(elem.parentNode, 'required');
 if(marks[0]){
 display ? marks[0].show() : marks[0].hide();
 }
 }
 }
}/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is bundled with this package in the file LICENSE.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/osl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@magentocommerce.com so we can send you a copy immediately.
 *
 * @copyright Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
 * @license http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 */
function toggleMenu(el, over)
{
 if (over) {
 Element.addClassName(el, 'over');
 }
 else {
 Element.removeClassName(el, 'over');
 }
}
/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is bundled with this package in the file LICENSE.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/osl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@magentocommerce.com so we can send you a copy immediately.
 *
 * @category Mage
 * @package Js
 * @copyright Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
 * @license http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 */

var Translate = Class.create();
Translate.prototype = {
 initialize: function(data){
 this.data = $H(data);
 },

 translate : function(){
 var args = arguments;
 var text = arguments[0];

 if(this.data[text]){
 return this.data[text];
 }
 return text;
 },
 add : function() {
 if (arguments.length > 1) {
 this.data[arguments[0]] = arguments[1];
 } else if (typeof arguments[0] =='object') {
 $H(arguments[0]).each(function (pair){
 this.data[pair.key] = pair.value;
 }.bind(this));
 }
 }
}/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is bundled with this package in the file LICENSE.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/osl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@magentocommerce.com so we can send you a copy immediately.
 *
 * @copyright Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
 * @license http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 */
// old school cookie functions grabbed off the web

if (!window.Mage) var Mage = {};

Mage.Cookies = {};
Mage.Cookies.set = function(name, value){
 var argv = arguments;
 var argc = arguments.length;
 var expires = (argc > 2) ? argv[2] : null;
 var path = (argc > 3) ? argv[3] : '/';
 var domain = (argc > 4) ? argv[4] : null;
 var secure = (argc > 5) ? argv[5] : false;
 document.cookie = name + "=" + escape (value) +
 ((expires == null) ? "" : ("; expires=" + expires.toGMTString())) +
 ((path == null) ? "" : ("; path=" + path)) +
 ((domain == null) ? "" : ("; domain=" + domain)) +
 ((secure == true) ? "; secure" : "");
};

Mage.Cookies.get = function(name){
 var arg = name + "=";
 var alen = arg.length;
 var clen = document.cookie.length;
 var i = 0;
 var j = 0;
 while(i < clen){
 j = i + alen;
 if (document.cookie.substring(i, j) == arg)
 return Cookies.getCookieVal(j);
 i = document.cookie.indexOf(" ", i) + 1;
 if(i == 0)
 break;
 }
 return null;
};

Mage.Cookies.clear = function(name) {
 if(Cookies.get(name)){
 document.cookie = name + "=" +
 "; expires=Thu, 01-Jan-70 00:00:01 GMT";
 }
};

Mage.Cookies.getCookieVal = function(offset){
 var endstr = document.cookie.indexOf(";", offset);
 if(endstr == -1){
 endstr = document.cookie.length;
 }
 return unescape(document.cookie.substring(offset, endstr));
};(function(){
/*
 * jQuery 1.2.3 - New Wave Javascript
 *
 * Copyright (c) 2008 John Resig (jquery.com)
 * Dual licensed under the MIT (MIT-LICENSE.txt)
 * and GPL (GPL-LICENSE.txt) licenses.
 *
 * $Date: 2008-02-06 00:21:25 -0500 (Wed, 06 Feb 2008) $
 * $Rev: 4663 $
 */

// Map over jQuery in case of overwrite
if ( window.jQuery )
 var _jQuery = window.jQuery;

var jQuery = window.jQuery = function( selector, context ) {
 // The jQuery object is actually just the init constructor 'enhanced'
 return new jQuery.prototype.init( selector, context );
};

// Map over the $ in case of overwrite
if ( window.$ )
 var _$ = window.$;
 
// Map the jQuery namespace to the '$' one
window.$ = jQuery;

// A simple way to check for HTML strings or ID strings
// (both of which we optimize for)
var quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#(\w+)$/;

// Is it a simple selector
var isSimple = /^.[^:#\[\.]*$/;

jQuery.fn = jQuery.prototype = {
 init: function( selector, context ) {
 // Make sure that a selection was provided
 selector = selector || document;

 // Handle $(DOMElement)
 if ( selector.nodeType ) {
 this[0] = selector;
 this.length = 1;
 return this;

 // Handle HTML strings
 } else if ( typeof selector == "string" ) {
 // Are we dealing with HTML string or an ID?
 var 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 {
 var elem = document.getElementById( match[3] );

 // Make sure an element was located
 if ( elem )
 // Handle the case where IE and Opera return items
 // by name instead of ID
 if ( elem.id != match[3] )
 return jQuery().find( selector );

 // Otherwise, we inject the element directly into the jQuery object
 else {
 this[0] = elem;
 this.length = 1;
 return this;
 }

 else
 selector = [];
 }

 // HANDLE: $(expr, [context])
 // (which is just equivalent to: $(content).find(expr)
 } else
 return new jQuery( context ).find( selector );

 // HANDLE: $(function)
 // Shortcut for document ready
 } else if ( jQuery.isFunction( selector ) )
 return new jQuery( document )[ jQuery.fn.ready ? "ready" : "load" ]( selector );

 return this.setArray(
 // HANDLE: $(array)
 selector.constructor == Array && selector ||

 // HANDLE: $(arraylike)
 // Watch for when an array-like object, contains DOM nodes, is passed in as the selector
 (selector.jquery || selector.length && selector != window && !selector.nodeType && selector[0] != undefined && selector[0].nodeType) && jQuery.makeArray( selector ) ||

 // HANDLE: $(*)
 [ selector ] );
 },
 
 // The current version of jQuery being used
 jquery: "1.2.3",

 // The number of elements contained in the matched element set
 size: function() {
 return this.length;
 },
 
 // The number of elements contained in the matched element set
 length: 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 == undefined ?

 // Return a 'clean' array
 jQuery.makeArray( 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 ) {
 // Build a new jQuery matched element set
 var ret = jQuery( elems );

 // Add the old object onto the stack (as a reference)
 ret.prevObject = this;

 // 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 ) {
 var ret = -1;

 // Locate the position of the desired element
 this.each(function(i){
 if ( this == elem )
 ret = i;
 });

 return ret;
 },

 attr: function( name, value, type ) {
 var options = name;
 
 // Look for the case where we're accessing a style value
 if ( name.constructor == String )
 if ( value == undefined )
 return this.length && jQuery[ type || "attr" ]( this[0], name ) || undefined;

 else {
 options = {};
 options[ name ] = value;
 }
 
 // Check to see if we're setting style values
 return this.each(function(i){
 // Set all the styles
 for ( name in options )
 jQuery.attr(
 type ?
 this.style :
 this,
 name, jQuery.prop( this, options[ name ], type, i, name )
 );
 });
 },

 css: function( key, value ) {
 // ignore negative width and height values
 if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
 value = undefined;
 return this.attr( key, value, "curCSS" );
 },

 text: function( text ) {
 if ( typeof text != "object" && text != null )
 return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );

 var ret = "";

 jQuery.each( text || this, function(){
 jQuery.each( this.childNodes, function(){
 if ( this.nodeType != 8 )
 ret += this.nodeType != 1 ?
 this.nodeValue :
 jQuery.fn.text( [ this ] );
 });
 });

 return ret;
 },

 wrapAll: function( html ) {
 if ( this[0] )
 // The elements to wrap the target around
 jQuery( html, this[0].ownerDocument )
 .clone()
 .insertBefore( this[0] )
 .map(function(){
 var elem = this;

 while ( elem.firstChild )
 elem = elem.firstChild;

 return elem;
 })
 .append(this);

 return this;
 },

 wrapInner: function( html ) {
 return this.each(function(){
 jQuery( this ).contents().wrapAll( html );
 });
 },

 wrap: function( html ) {
 return this.each(function(){
 jQuery( this ).wrapAll( html );
 });
 },

 append: function() {
 return this.domManip(arguments, true, false, function(elem){
 if (this.nodeType == 1)
 this.appendChild( elem );
 });
 },

 prepend: function() {
 return this.domManip(arguments, true, true, function(elem){
 if (this.nodeType == 1)
 this.insertBefore( elem, this.firstChild );
 });
 },
 
 before: function() {
 return this.domManip(arguments, false, false, function(elem){
 this.parentNode.insertBefore( elem, this );
 });
 },

 after: function() {
 return this.domManip(arguments, false, true, function(elem){
 this.parentNode.insertBefore( elem, this.nextSibling );
 });
 },

 end: function() {
 return this.prevObject || jQuery( [] );
 },

 find: function( selector ) {
 var elems = jQuery.map(this, function(elem){
 return jQuery.find( selector, elem );
 });

 return this.pushStack( /[^+>] [^+>]/.test( selector ) || selector.indexOf("..") > -1 ?
 jQuery.unique( elems ) :
 elems );
 },

 clone: function( events ) {
 // Do the clone
 var ret = this.map(function(){
 if ( jQuery.browser.msie && !jQuery.isXMLDoc(this) ) {
 // IE copies events bound via attachEvent when
 // using cloneNode. Calling detachEvent on the
 // clone will also remove the events from the orignal
 // In order to get around this, we use innerHTML.
 // Unfortunately, this means some modifications to 
 // attributes in IE that are actually only stored 
 // as properties will not be copied (such as the
 // the name attribute on an input).
 var clone = this.cloneNode(true),
 container = document.createElement("div");
 container.appendChild(clone);
 return jQuery.clean([container.innerHTML])[0];
 } else
 return this.cloneNode(true);
 });

 // Need to set the expando to null on the cloned set if it exists
 // removeData doesn't work here, IE removes it from the original as well
 // this is primarily for IE but the data expando shouldn't be copied over in any browser
 var clone = ret.find("*").andSelf().each(function(){
 if ( this[ expando ] != undefined )
 this[ expando ] = null;
 });
 
 // Copy the events from the original to the clone
 if ( events === true )
 this.find("*").andSelf().each(function(i){
 if (this.nodeType == 3)
 return;
 var events = jQuery.data( this, "events" );

 for ( var type in events )
 for ( var handler in events[ type ] )
 jQuery.event.add( clone[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );
 });

 // Return the cloned set
 return ret;
 },

 filter: function( selector ) {
 return this.pushStack(
 jQuery.isFunction( selector ) &&
 jQuery.grep(this, function(elem, i){
 return selector.call( elem, i );
 }) ||

 jQuery.multiFilter( selector, this ) );
 },

 not: function( selector ) {
 if ( selector.constructor == String )
 // test special case where just one selector is passed in
 if ( isSimple.test( selector ) )
 return this.pushStack( jQuery.multiFilter( selector, this, true ) );
 else
 selector = jQuery.multiFilter( selector, this );

 var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
 return this.filter(function() {
 return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
 });
 },

 add: function( selector ) {
 return !selector ? this : this.pushStack( jQuery.merge( 
 this.get(),
 selector.constructor == String ? 
 jQuery( selector ).get() :
 selector.length != undefined && (!selector.nodeName || jQuery.nodeName(selector, "form")) ?
 selector : [selector] ) );
 },

 is: function( selector ) {
 return selector ?
 jQuery.multiFilter( selector, this ).length > 0 :
 false;
 },

 hasClass: function( selector ) {
 return this.is( "." + selector );
 },
 
 val: function( value ) {
 if ( value == undefined ) {

 if ( this.length ) {
 var elem = this[0];

 // We need to handle select boxes special
 if ( jQuery.nodeName( elem, "select" ) ) {
 var index = elem.selectedIndex,
 values = [],
 options = elem.options,
 one = elem.type == "select-one";
 
 // Nothing was selected
 if ( index < 0 )
 return null;

 // Loop through all the selected options
 for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
 var option = options[ i ];

 if ( option.selected ) {
 // Get the specifc value for the option
 value = jQuery.browser.msie && !option.attributes.value.specified ? option.text : option.value;
 
 // We don't need an array for one selects
 if ( one )
 return value;
 
 // Multi-Selects return an array
 values.push( value );
 }
 }
 
 return values;
 
 // Everything else, we just grab the value
 } else
 return (this[0].value || "").replace(/\r/g, "");

 }

 return undefined;
 }

 return this.each(function(){
 if ( this.nodeType != 1 )
 return;

 if ( value.constructor == Array && /radio|checkbox/.test( this.type ) )
 this.checked = (jQuery.inArray(this.value, value) >= 0 ||
 jQuery.inArray(this.name, value) >= 0);

 else if ( jQuery.nodeName( this, "select" ) ) {
 var values = value.constructor == Array ?
 value :
 [ value ];

 jQuery( "option", this ).each(function(){
 this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
 jQuery.inArray( this.text, values ) >= 0);
 });

 if ( !values.length )
 this.selectedIndex = -1;

 } else
 this.value = value;
 });
 },
 
 html: function( value ) {
 return value == undefined ?
 (this.length ?
 this[0].innerHTML :
 null) :
 this.empty().append( value );
 },

 replaceWith: function( value ) {
 return this.after( value ).remove();
 },

 eq: function( i ) {
 return this.slice( i, i + 1 );
 },

 slice: function() {
 return this.pushStack( Array.prototype.slice.apply( this, arguments ) );
 },

 map: function( callback ) {
 return this.pushStack( jQuery.map(this, function(elem, i){
 return callback.call( elem, i, elem );
 }));
 },

 andSelf: function() {
 return this.add( this.prevObject );
 },

 data: function( key, value ){
 var parts = key.split(".");
 parts[1] = parts[1] ? "." + parts[1] : "";

 if ( value == null ) {
 var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
 
 if ( data == undefined && this.length )
 data = jQuery.data( this[0], key );

 return data == null && 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 );
 });
 },
 
 domManip: function( args, table, reverse, callback ) {
 var clone = this.length > 1, elems; 

 return this.each(function(){
 if ( !elems ) {
 elems = jQuery.clean( args, this.ownerDocument );

 if ( reverse )
 elems.reverse();
 }

 var obj = this;

 if ( table && jQuery.nodeName( this, "table" ) && jQuery.nodeName( elems[0], "tr" ) )
 obj = this.getElementsByTagName("tbody")[0] || this.appendChild( this.ownerDocument.createElement("tbody") );

 var scripts = jQuery( [] );

 jQuery.each(elems, function(){
 var elem = clone ?
 jQuery( this ).clone( true )[0] :
 this;

 // execute all scripts after the elements have been injected
 if ( jQuery.nodeName( elem, "script" ) ) {
 scripts = scripts.add( elem );
 } else {
 // Remove any inner scripts for later evaluation
 if ( elem.nodeType == 1 )
 scripts = scripts.add( jQuery( "script", elem ).remove() );

 // Inject the elements into the document
 callback.call( obj, elem );
 }
 });

 scripts.each( evalScript );
 });
 }
};

// Give the init function the jQuery prototype for later instantiation
jQuery.prototype.init.prototype = jQuery.prototype;

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 );
}

jQuery.extend = jQuery.fn.extend = function() {
 // copy reference to target object
 var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;

 // Handle a deep copy situation
 if ( target.constructor == 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" && typeof target != "function" )
 target = {};

 // extend jQuery itself if only one argument is passed
 if ( length == 1 ) {
 target = this;
 i = 0;
 }

 for ( ; i < length; i++ )
 // Only deal with non-null/undefined values
 if ( (options = arguments[ i ]) != null )
 // Extend the base object
 for ( var name in options ) {
 // Prevent never-ending loop
 if ( target === options[ name ] )
 continue;

 // Recurse if we're merging object values
 if ( deep && options[ name ] && typeof options[ name ] == "object" && target[ name ] && !options[ name ].nodeType )
 target[ name ] = jQuery.extend( target[ name ], options[ name ] );

 // Don't bring in undefined values
 else if ( options[ name ] != undefined )
 target[ name ] = options[ name ];

 }

 // Return the modified object
 return target;
};

var expando = "jQuery" + (new Date()).getTime(), uuid = 0, windowData = {};

// exclude the following css properties to add px
var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i;

jQuery.extend({
 noConflict: function( deep ) {
 window.$ = _$;

 if ( deep )
 window.jQuery = _jQuery;

 return jQuery;
 },

 // See test/unit/core.js for details concerning this function.
 isFunction: function( fn ) {
 return !!fn && typeof fn != "string" && !fn.nodeName && 
 fn.constructor != Array && /function/i.test( fn + "" );
 },
 
 // check if an element is in a (or is an) XML document
 isXMLDoc: function( elem ) {
 return elem.documentElement && !elem.body ||
 elem.tagName && elem.ownerDocument && !elem.ownerDocument.body;
 },

 // Evalulates a script in a global context
 globalEval: function( data ) {
 data = jQuery.trim( data );

 if ( 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.browser.msie )
 script.text = data;
 else
 script.appendChild( document.createTextNode( data ) );

 head.appendChild( script );
 head.removeChild( script );
 }
 },

 nodeName: function( elem, name ) {
 return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
 },
 
 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 ];
 }
 },

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

 // A special, fast, case for the most common use of each
 } else {
 if ( object.length == undefined ) {
 for ( var name in object )
 if ( callback.call( object[ name ], name, object[ name ] ) === false )
 break;
 } else
 for ( var i = 0, length = object.length, value = object[0]; 
 i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
 }

 return object;
 },
 
 prop: function( elem, value, type, i, name ) {
 // Handle executable functions
 if ( jQuery.isFunction( value ) )
 value = value.call( elem, i );
 
 // Handle passing in a number to a CSS property
 return value && value.constructor == Number && type == "curCSS" && !exclude.test( name ) ?
 value + "px" :
 value;
 },

 className: {
 // internal only, use addClass("class")
 add: function( elem, classNames ) {
 jQuery.each((classNames || "").split(/\s+/), function(i, className){
 if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
 elem.className += (elem.className ? " " : "") + className;
 });
 },

 // internal only, use removeClass("class")
 remove: function( elem, classNames ) {
 if (elem.nodeType == 1)
 elem.className = classNames != undefined ?
 jQuery.grep(elem.className.split(/\s+/), function(className){
 return !jQuery.className.has( classNames, className ); 
 }).join(" ") :
 "";
 },

 // internal only, use is(".class")
 has: function( elem, className ) {
 return jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
 }
 },

 // A method for quickly swapping in/out CSS properties to get correct calculations
 swap: function( elem, options, callback ) {
 var old = {};
 // Remember the old values, and insert the new ones
 for ( var name in options ) {
 old[ name ] = elem.style[ name ];
 elem.style[ name ] = options[ name ];
 }

 callback.call( elem );

 // Revert the old values
 for ( var name in options )
 elem.style[ name ] = old[ name ];
 },

 css: function( elem, name, force ) {
 if ( name == "width" || name == "height" ) {
 var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
 
 function getWH() {
 val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
 var padding = 0, border = 0;
 jQuery.each( which, function() {
 padding += parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
 border += parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
 });
 val -= Math.round(padding + border);
 }
 
 if ( jQuery(elem).is(":visible") )
 getWH();
 else
 jQuery.swap( elem, props, getWH );
 
 return Math.max(0, val);
 }
 
 return jQuery.curCSS( elem, name, force );
 },

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

 // A helper method for determining if an element's values are broken
 function color( elem ) {
 if ( !jQuery.browser.safari )
 return false;

 var ret = document.defaultView.getComputedStyle( elem, null );
 return !ret || ret.getPropertyValue("color") == "";
 }

 // We need to handle opacity special in IE
 if ( name == "opacity" && jQuery.browser.msie ) {
 ret = jQuery.attr( elem.style, "opacity" );

 return ret == "" ?
 "1" :
 ret;
 }
 // Opera sometimes will give the wrong display answer, this fixes it, see #2037
 if ( jQuery.browser.opera && name == "display" ) {
 var save = elem.style.outline;
 elem.style.outline = "0 solid black";
 elem.style.outline = save;
 }
 
 // Make sure we're using the right name for getting the float value
 if ( name.match( /float/i ) )
 name = styleFloat;

 if ( !force && elem.style && elem.style[ name ] )
 ret = elem.style[ name ];

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

 // Only "float" is needed here
 if ( name.match( /float/i ) )
 name = "float";

 name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();

 var getComputedStyle = document.defaultView.getComputedStyle( elem, null );

 if ( getComputedStyle && !color( elem ) )
 ret = getComputedStyle.getPropertyValue( name );

 // If the element isn't reporting its values properly in Safari
 // then some display: none elements are involved
 else {
 var swap = [], stack = [];

 // Locate all of the parent display: none elements
 for ( var a = elem; a && color(a); a = a.parentNode )
 stack.unshift(a);

 // Go through and make them visible, but in reverse
 // (It would be better if we knew the exact display type that they had)
 for ( var i = 0; i < stack.length; i++ )
 if ( color( stack[ i ] ) ) {
 swap[ i ] = stack[ i ].style.display;
 stack[ i ].style.display = "block";
 }

 // Since we flip the display style, we have to handle that
 // one special, otherwise get the value
 ret = name == "display" && swap[ stack.length - 1 ] != null ?
 "none" :
 ( getComputedStyle && getComputedStyle.getPropertyValue( name ) ) || "";

 // Finally, revert the display styles back
 for ( var i = 0; i < swap.length; i++ )
 if ( swap[ i ] != null )
 stack[ i ].style.display = swap[ i ];
 }

 // We should always get a number back from opacity
 if ( name == "opacity" && ret == "" )
 ret = "1";

 } else if ( elem.currentStyle ) {
 var camelCase = name.replace(/\-(\w)/g, function(all, letter){
 return letter.toUpperCase();
 });

 ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];

 // From the awesome hack by Dean Edwards
 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291

 // If we're not dealing with a regular pixel number
 // but a number that has a weird ending, we need to convert it to pixels
 if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {
 // Remember the original values
 var style = elem.style.left, runtimeStyle = elem.runtimeStyle.left;

 // Put in the new values to get a computed value out
 elem.runtimeStyle.left = elem.currentStyle.left;
 elem.style.left = ret || 0;
 ret = elem.style.pixelLeft + "px";

 // Revert the changed values
 elem.style.left = style;
 elem.runtimeStyle.left = runtimeStyle;
 }
 }

 return ret;
 },
 
 clean: function( elems, context ) {
 var ret = [];
 context = context || document;
 // !context.createElement fails in IE with an error but returns typeof 'object'
 if (typeof context.createElement == 'undefined') 
 context = context.ownerDocument || context[0] && context[0].ownerDocument || document;

 jQuery.each(elems, function(i, elem){
 if ( !elem )
 return;

 if ( elem.constructor == Number )
 elem = elem.toString();
 
 // Convert html string into DOM nodes
 if ( typeof elem == "string" ) {
 // Fix "XHTML"-style tags in all browsers
 elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
 return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
 all :
 front + "></" + tag + ">";
 });

 // Trim whitespace, otherwise indexOf won't work as expected
 var tags = jQuery.trim( elem ).toLowerCase(), div = context.createElement("div");

 var wrap =
 // option or optgroup
 !tags.indexOf("<opt") &&
 [ 1, "<select multiple='multiple'>", "</select>" ] ||
 
 !tags.indexOf("<leg") &&
 [ 1, "<fieldset>", "</fieldset>" ] ||
 
 tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
 [ 1, "<table>", "</table>" ] ||
 
 !tags.indexOf("<tr") &&
 [ 2, "<table><tbody>", "</tbody></table>" ] ||
 
 // <thead> matched above
 (!tags.indexOf("<td") || !tags.indexOf("<th")) &&
 [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] ||
 
 !tags.indexOf("<col") &&
 [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] ||

 // IE can't serialize <link> and <script> tags normally
 jQuery.browser.msie &&
 [ 1, "div<div>", "</div>" ] ||
 
 [ 0, "", "" ];

 // Go to html and back, then peel off extra wrappers
 div.innerHTML = wrap[1] + elem + wrap[2];
 
 // Move to the right depth
 while ( wrap[0]-- )
 div = div.lastChild;
 
 // Remove IE's autoinserted <tbody> from table fragments
 if ( jQuery.browser.msie ) {
 
 // String was a <table>, *may* have spurious <tbody>
 var tbody = !tags.indexOf("<table") && tags.indexOf("<tbody") < 0 ?
 div.firstChild && div.firstChild.childNodes :
 
 // String was a bare <thead> or <tfoot>
 wrap[1] == "<table>" && tags.indexOf("<tbody") < 0 ?
 div.childNodes :
 [];
 
 for ( var j = tbody.length - 1; j >= 0 ; --j )
 if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
 tbody[ j ].parentNode.removeChild( tbody[ j ] );
 
 // IE completely kills leading whitespace when innerHTML is used 
 if ( /^\s/.test( elem ) ) 
 div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );
 
 }
 
 elem = jQuery.makeArray( div.childNodes );
 }

 if ( elem.length === 0 && (!jQuery.nodeName( elem, "form" ) && !jQuery.nodeName( elem, "select" )) )
 return;

 if ( elem[0] == undefined || jQuery.nodeName( elem, "form" ) || elem.options )
 ret.push( elem );

 else
 ret = jQuery.merge( ret, elem );

 });

 return ret;
 },
 
 attr: function( elem, name, value ) {
 // don't set attributes on text and comment nodes
 if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
 return undefined;

 var fix = jQuery.isXMLDoc( elem ) ?
 {} :
 jQuery.props;

 // Safari mis-reports the default selected property of a hidden option
 // Accessing the parent's selectedIndex property fixes it
 if ( name == "selected" && jQuery.browser.safari )
 elem.parentNode.selectedIndex;
 
 // Certain attributes only work when accessed via the old DOM 0 way
 if ( fix[ name ] ) {
 if ( value != undefined )
 elem[ fix[ name ] ] = value;

 return elem[ fix[ name ] ];

 } else if ( jQuery.browser.msie && name == "style" )
 return jQuery.attr( elem.style, "cssText", value );

 else if ( value == undefined && jQuery.browser.msie && jQuery.nodeName( elem, "form" ) && (name == "action" || name == "method") )
 return elem.getAttributeNode( name ).nodeValue;

 // IE elem.getAttribute passes even for style
 else if ( elem.tagName ) {

 if ( value != undefined ) {
 // We can't allow the type property to be changed (since it causes problems in IE)
 if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )
 throw "type property can't be changed";

 // convert the value to a string (all browsers do this but IE) see #1070
 elem.setAttribute( name, "" + value );
 }

 if ( jQuery.browser.msie && /href|src/.test( name ) && !jQuery.isXMLDoc( elem ) ) 
 return elem.getAttribute( name, 2 );

 return elem.getAttribute( name );

 // elem is actually elem.style ... set the style
 } else {
 // IE actually uses filters for opacity
 if ( name == "opacity" && jQuery.browser.msie ) {
 if ( value != undefined ) {
 // IE has trouble with opacity if it does not have layout
 // Force it by setting the zoom level
 elem.zoom = 1; 
 
 // Set the alpha filter to set the opacity
 elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) +
 (parseFloat( value ).toString() == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
 }
 
 return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
 (parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100).toString() :
 "";
 }

 name = name.replace(/-([a-z])/ig, function(all, letter){
 return letter.toUpperCase();
 });

 if ( value != undefined )
 elem[ name ] = value;

 return elem[ name ];
 }
 },
 
 trim: function( text ) {
 return (text || "").replace( /^\s+|\s+$/g, "" );
 },

 makeArray: function( array ) {
 var ret = [];

 // Need to use typeof to fight Safari childNodes crashes
 if ( typeof array != "array" )
 for ( var i = 0, length = array.length; i < length; i++ )
 ret.push( array[ i ] );
 else
 ret = array.slice( 0 );

 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

 // Also, we need to make sure that the correct elements are being returned
 // (IE returns comment nodes in a '*' query)
 if ( jQuery.browser.msie ) {
 for ( var i = 0; second[ i ]; i++ )
 if ( second[ i ].nodeType != 8 )
 first.push( second[ i ] );

 } else
 for ( var i = 0; second[ i ]; i++ )
 first.push( second[ i ] );

 return first;
 },

 unique: function( array ) {
 var ret = [], done = {};

 try {

 for ( var i = 0, length = array.length; i < length; i++ ) {
 var 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 ) || inv && !callback( elems[ i ], i ) )
 ret.push( elems[ i ] );

 return ret;
 },

 map: function( elems, callback ) {
 var ret = [];

 // 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++ ) {
 var value = callback( elems[ i ], i );

 if ( value !== null && value != undefined ) {
 if ( value.constructor != Array )
 value = [ value ];

 ret = ret.concat( value );
 }
 }

 return ret;
 }
});

var userAgent = navigator.userAgent.toLowerCase();

// Figure out what browser is being used
jQuery.browser = {
 version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [])[1],
 safari: /webkit/.test( userAgent ),
 opera: /opera/.test( userAgent ),
 msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
 mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
};

var styleFloat = jQuery.browser.msie ?
 "styleFloat" :
 "cssFloat";
 
jQuery.extend({
 // Check to see if the W3C box model is being used
 boxModel: !jQuery.browser.msie || document.compatMode == "CSS1Compat",
 
 props: {
 "for": "htmlFor",
 "class": "className",
 "float": styleFloat,
 cssFloat: styleFloat,
 styleFloat: styleFloat,
 innerHTML: "innerHTML",
 className: "className",
 value: "value",
 disabled: "disabled",
 checked: "checked",
 readonly: "readOnly",
 selected: "selected",
 maxlength: "maxLength",
 selectedIndex: "selectedIndex",
 defaultValue: "defaultValue",
 tagName: "tagName",
 nodeName: "nodeName"
 }
});

jQuery.each({
 parent: function(elem){return elem.parentNode;},
 parents: function(elem){return jQuery.dir(elem,"parentNode");},
 next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
 prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
 nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
 prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
 siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
 children: function(elem){return jQuery.sibling(elem.firstChild);},
 contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
}, function(name, fn){
 jQuery.fn[ name ] = function( selector ) {
 var ret = jQuery.map( this, fn );

 if ( selector && typeof selector == "string" )
 ret = jQuery.multiFilter( selector, ret );

 return this.pushStack( jQuery.unique( ret ) );
 };
});

jQuery.each({
 appendTo: "append",
 prependTo: "prepend",
 insertBefore: "before",
 insertAfter: "after",
 replaceAll: "replaceWith"
}, function(name, original){
 jQuery.fn[ name ] = function() {
 var args = arguments;

 return this.each(function(){
 for ( var i = 0, length = args.length; i < length; i++ )
 jQuery( args[ i ] )[ original ]( this );
 });
 };
});

jQuery.each({
 removeAttr: function( name ) {
 jQuery.attr( this, name, "" );
 if (this.nodeType == 1) 
 this.removeAttribute( name );
 },

 addClass: function( classNames ) {
 jQuery.className.add( this, classNames );
 },

 removeClass: function( classNames ) {
 jQuery.className.remove( this, classNames );
 },

 toggleClass: function( classNames ) {
 jQuery.className[ jQuery.className.has( this, classNames ) ? "remove" : "add" ]( this, classNames );
 },

 remove: function( selector ) {
 if ( !selector || jQuery.filter( selector, [ this ] ).r.length ) {
 // Prevent memory leaks
 jQuery( "*", this ).add(this).each(function(){
 jQuery.event.remove(this);
 jQuery.removeData(this);
 });
 if (this.parentNode)
 this.parentNode.removeChild( this );
 }
 },

 empty: function() {
 // Remove element nodes and prevent memory leaks
 jQuery( ">*", this ).remove();
 
 // Remove any remaining nodes
 while ( this.firstChild )
 this.removeChild( this.firstChild );
 }
}, function(name, fn){
 jQuery.fn[ name ] = function(){
 return this.each( fn, arguments );
 };
});

jQuery.each([ "Height", "Width" ], function(i, name){
 var type = name.toLowerCase();
 
 jQuery.fn[ type ] = function( size ) {
 // Get window width or height
 return this[0] == window ?
 // Opera reports document.body.client[Width/Height] properly in both quirks and standards
 jQuery.browser.opera && document.body[ "client" + name ] || 
 
 // Safari reports inner[Width/Height] just fine (Mozilla and Opera include scroll bar widths)
 jQuery.browser.safari && window[ "inner" + name ] ||
 
 // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
 document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] || document.body[ "client" + name ] :
 
 // Get document width or height
 this[0] == document ?
 // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
 Math.max( 
 Math.max(document.body["scroll" + name], document.documentElement["scroll" + name]), 
 Math.max(document.body["offset" + name], document.documentElement["offset" + name]) 
 ) :

 // Get or set width or height on the element
 size == undefined ?
 // Get width or height on the element
 (this.length ? jQuery.css( this[0], type ) : null) :

 // Set the width or height on the element (default to pixels if value is unitless)
 this.css( type, size.constructor == String ? size : size + "px" );
 };
});

var chars = jQuery.browser.safari && parseInt(jQuery.browser.version) < 417 ?
 "(?:[\\w*_-]|\\\\.)" :
 "(?:[\\w\u0128-\uFFFF*_-]|\\\\.)",
 quickChild = new RegExp("^>\\s*(" + chars + "+)"),
 quickID = new RegExp("^(" + chars + "+)(#)(" + chars + "+)"),
 quickClass = new RegExp("^([#.]?)(" + chars + "*)");

jQuery.extend({
 expr: {
 "": function(a,i,m){return m[2]=="*"||jQuery.nodeName(a,m[2]);},
 "#": function(a,i,m){return a.getAttribute("id")==m[2];},
 ":": {
 // Position Checks
 lt: function(a,i,m){return i<m[3]-0;},
 gt: function(a,i,m){return i>m[3]-0;},
 nth: function(a,i,m){return m[3]-0==i;},
 eq: function(a,i,m){return m[3]-0==i;},
 first: function(a,i){return i==0;},
 last: function(a,i,m,r){return i==r.length-1;},
 even: function(a,i){return i%2==0;},
 odd: function(a,i){return i%2;},

 // Child Checks
 "first-child": function(a){return a.parentNode.getElementsByTagName("*")[0]==a;},
 "last-child": function(a){return jQuery.nth(a.parentNode.lastChild,1,"previousSibling")==a;},
 "only-child": function(a){return !jQuery.nth(a.parentNode.lastChild,2,"previousSibling");},

 // Parent Checks
 parent: function(a){return a.firstChild;},
 empty: function(a){return !a.firstChild;},

 // Text Check
 contains: function(a,i,m){return (a.textContent||a.innerText||jQuery(a).text()||"").indexOf(m[3])>=0;},

 // Visibility
 visible: function(a){return "hidden"!=a.type&&jQuery.css(a,"display")!="none"&&jQuery.css(a,"visibility")!="hidden";},
 hidden: function(a){return "hidden"==a.type||jQuery.css(a,"display")=="none"||jQuery.css(a,"visibility")=="hidden";},

 // Form attributes
 enabled: function(a){return !a.disabled;},
 disabled: function(a){return a.disabled;},
 checked: function(a){return a.checked;},
 selected: function(a){return a.selected||jQuery.attr(a,"selected");},

 // Form elements
 text: function(a){return "text"==a.type;},
 radio: function(a){return "radio"==a.type;},
 checkbox: function(a){return "checkbox"==a.type;},
 file: function(a){return "file"==a.type;},
 password: function(a){return "password"==a.type;},
 submit: function(a){return "submit"==a.type;},
 image: function(a){return "image"==a.type;},
 reset: function(a){return "reset"==a.type;},
 button: function(a){return "button"==a.type||jQuery.nodeName(a,"button");},
 input: function(a){return /input|select|textarea|button/i.test(a.nodeName);},

 // :has()
 has: function(a,i,m){return jQuery.find(m[3],a).length;},

 // :header
 header: function(a){return /h\d/i.test(a.nodeName);},

 // :animated
 animated: function(a){return jQuery.grep(jQuery.timers,function(fn){return a==fn.elem;}).length;}
 }
 },
 
 // The regular expressions that power the parsing engine
 parse: [
 // Match: [@value='test'], [@foo]
 /^(\[) *@?([\w-]+) *([!*$^~=]*) *('?"?)(.*?)\4 *\]/,

 // Match: :contains('foo')
 /^(:)([\w-]+)\("?'?(.*?(\(.*?\))?[^(]*?)"?'?\)/,

 // Match: :even, :last-chlid, #id, .class
 new RegExp("^([:.#]*)(" + chars + "+)")
 ],

 multiFilter: function( expr, elems, not ) {
 var old, cur = [];

 while ( expr && expr != old ) {
 old = expr;
 var f = jQuery.filter( expr, elems, not );
 expr = f.t.replace(/^\s*,\s*/, "" );
 cur = not ? elems = f.r : jQuery.merge( cur, f.r );
 }

 return cur;
 },

 find: function( t, context ) {
 // Quickly handle non-string expressions
 if ( typeof t != "string" )
 return [ t ];

 // check to make sure context is a DOM element or a document
 if ( context && context.nodeType != 1 && context.nodeType != 9)
 return [ ];

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

 // Initialize the search
 var ret = [context], done = [], last, nodeName;

 // Continue while a selector expression exists, and while
 // we're no longer looping upon ourselves
 while ( t && last != t ) {
 var r = [];
 last = t;

 t = jQuery.trim(t);

 var foundToken = false;

 // An attempt at speeding up child selectors that
 // point to a specific element tag
 var re = quickChild;
 var m = re.exec(t);

 if ( m ) {
 nodeName = m[1].toUpperCase();

 // Perform our own iteration and filter
 for ( var i = 0; ret[i]; i++ )
 for ( var c = ret[i].firstChild; c; c = c.nextSibling )
 if ( c.nodeType == 1 && (nodeName == "*" || c.nodeName.toUpperCase() == nodeName) )
 r.push( c );

 ret = r;
 t = t.replace( re, "" );
 if ( t.indexOf(" ") == 0 ) continue;
 foundToken = true;
 } else {
 re = /^([>+~])\s*(\w*)/i;

 if ( (m = re.exec(t)) != null ) {
 r = [];

 var merge = {};
 nodeName = m[2].toUpperCase();
 m = m[1];

 for ( var j = 0, rl = ret.length; j < rl; j++ ) {
 var n = m == "~" || m == "+" ? ret[j].nextSibling : ret[j].firstChild;
 for ( ; n; n = n.nextSibling )
 if ( n.nodeType == 1 ) {
 var id = jQuery.data(n);

 if ( m == "~" && merge[id] ) break;
 
 if (!nodeName || n.nodeName.toUpperCase() == nodeName ) {
 if ( m == "~" ) merge[id] = true;
 r.push( n );
 }
 
 if ( m == "+" ) break;
 }
 }

 ret = r;

 // And remove the token
 t = jQuery.trim( t.replace( re, "" ) );
 foundToken = true;
 }
 }

 // See if there's still an expression, and that we haven't already
 // matched a token
 if ( t && !foundToken ) {
 // Handle multiple expressions
 if ( !t.indexOf(",") ) {
 // Clean the result set
 if ( context == ret[0] ) ret.shift();

 // Merge the result sets
 done = jQuery.merge( done, ret );

 // Reset the context
 r = ret = [context];

 // Touch up the selector string
 t = " " + t.substr(1,t.length);

 } else {
 // Optimize for the case nodeName#idName
 var re2 = quickID;
 var m = re2.exec(t);
 
 // Re-organize the results, so that they're consistent
 if ( m ) {
 m = [ 0, m[2], m[3], m[1] ];

 } else {
 // Otherwise, do a traditional filter check for
 // ID, class, and element selectors
 re2 = quickClass;
 m = re2.exec(t);
 }

 m[2] = m[2].replace(/\\/g, "");

 var elem = ret[ret.length-1];

 // Try to do a global search by ID, where we can
 if ( m[1] == "#" && elem && elem.getElementById && !jQuery.isXMLDoc(elem) ) {
 // Optimization for HTML document case
 var oid = elem.getElementById(m[2]);
 
 // Do a quick check for the existence of the actual ID attribute
 // to avoid selecting by the name attribute in IE
 // also check to insure id is a string to avoid selecting an element with the name of 'id' inside a form
 if ( (jQuery.browser.msie||jQuery.browser.opera) && oid && typeof oid.id == "string" && oid.id != m[2] )
 oid = jQuery('[@id="'+m[2]+'"]', elem)[0];

 // Do a quick check for node name (where applicable) so
 // that div#foo searches will be really fast
 ret = r = oid && (!m[3] || jQuery.nodeName(oid, m[3])) ? [oid] : [];
 } else {
 // We need to find all descendant elements
 for ( var i = 0; ret[i]; i++ ) {
 // Grab the tag name being searched for
 var tag = m[1] == "#" && m[3] ? m[3] : m[1] != "" || m[0] == "" ? "*" : m[2];

 // Handle IE7 being really dumb about <object>s
 if ( tag == "*" && ret[i].nodeName.toLowerCase() == "object" )
 tag = "param";

 r = jQuery.merge( r, ret[i].getElementsByTagName( tag ));
 }

 // It's faster to filter by class and be done with it
 if ( m[1] == "." )
 r = jQuery.classFilter( r, m[2] );

 // Same with ID filtering
 if ( m[1] == "#" ) {
 var tmp = [];

 // Try to find the element with the ID
 for ( var i = 0; r[i]; i++ )
 if ( r[i].getAttribute("id") == m[2] ) {
 tmp = [ r[i] ];
 break;
 }

 r = tmp;
 }

 ret = r;
 }

 t = t.replace( re2, "" );
 }

 }

 // If a selector string still exists
 if ( t ) {
 // Attempt to filter it
 var val = jQuery.filter(t,r);
 ret = r = val.r;
 t = jQuery.trim(val.t);
 }
 }

 // An error occurred with the selector;
 // just return an empty set instead
 if ( t )
 ret = [];

 // Remove the root context
 if ( ret && context == ret[0] )
 ret.shift();

 // And combine the results
 done = jQuery.merge( done, ret );

 return done;
 },

 classFilter: function(r,m,not){
 m = " " + m + " ";
 var tmp = [];
 for ( var i = 0; r[i]; i++ ) {
 var pass = (" " + r[i].className + " ").indexOf( m ) >= 0;
 if ( !not && pass || not && !pass )
 tmp.push( r[i] );
 }
 return tmp;
 },

 filter: function(t,r,not) {
 var last;

 // Look for common filter expressions
 while ( t && t != last ) {
 last = t;

 var p = jQuery.parse, m;

 for ( var i = 0; p[i]; i++ ) {
 m = p[i].exec( t );

 if ( m ) {
 // Remove what we just matched
 t = t.substring( m[0].length );

 m[2] = m[2].replace(/\\/g, "");
 break;
 }
 }

 if ( !m )
 break;

 // :not() is a special case that can be optimized by
 // keeping it out of the expression list
 if ( m[1] == ":" && m[2] == "not" )
 // optimize if only one selector found (most common case)
 r = isSimple.test( m[3] ) ?
 jQuery.filter(m[3], r, true).r :
 jQuery( r ).not( m[3] );

 // We can get a big speed boost by filtering by class here
 else if ( m[1] == "." )
 r = jQuery.classFilter(r, m[2], not);

 else if ( m[1] == "[" ) {
 var tmp = [], type = m[3];
 
 for ( var i = 0, rl = r.length; i < rl; i++ ) {
 var a = r[i], z = a[ jQuery.props[m[2]] || m[2] ];
 
 if ( z == null || /href|src|selected/.test(m[2]) )
 z = jQuery.attr(a,m[2]) || '';

 if ( (type == "" && !!z ||
 type == "=" && z == m[5] ||
 type == "!=" && z != m[5] ||
 type == "^=" && z && !z.indexOf(m[5]) ||
 type == "$=" && z.substr(z.length - m[5].length) == m[5] ||
 (type == "*=" || type == "~=") && z.indexOf(m[5]) >= 0) ^ not )
 tmp.push( a );
 }
 
 r = tmp;

 // We can get a speed boost by handling nth-child here
 } else if ( m[1] == ":" && m[2] == "nth-child" ) {
 var merge = {}, tmp = [],
 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
 test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
 m[3] == "even" && "2n" || m[3] == "odd" && "2n+1" ||
 !/\D/.test(m[3]) && "0n+" + m[3] || m[3]),
 // calculate the numbers (first)n+(last) including if they are negative
 first = (test[1] + (test[2] || 1)) - 0, last = test[3] - 0;
 
 // loop through all the elements left in the jQuery object
 for ( var i = 0, rl = r.length; i < rl; i++ ) {
 var node = r[i], parentNode = node.parentNode, id = jQuery.data(parentNode);

 if ( !merge[id] ) {
 var c = 1;

 for ( var n = parentNode.firstChild; n; n = n.nextSibling )
 if ( n.nodeType == 1 )
 n.nodeIndex = c++;

 merge[id] = true;
 }

 var add = false;

 if ( first == 0 ) {
 if ( node.nodeIndex == last )
 add = true;
 } else if ( (node.nodeIndex - last) % first == 0 && (node.nodeIndex - last) / first >= 0 )
 add = true;

 if ( add ^ not )
 tmp.push( node );
 }

 r = tmp;

 // Otherwise, find the expression to execute
 } else {
 var fn = jQuery.expr[ m[1] ];
 if ( typeof fn == "object" )
 fn = fn[ m[2] ];

 if ( typeof fn == "string" )
 fn = eval("false||function(a,i){return " + fn + ";}");

 // Execute it against the current filter
 r = jQuery.grep( r, function(elem, i){
 return fn(elem, i, m, r);
 }, not );
 }
 }

 // Return an array of filtered elements (r)
 // and the modified expression string (t)
 return { r: r, t: t };
 },

 dir: function( elem, dir ){
 var matched = [];
 var cur = elem[dir];
 while ( cur && cur != document ) {
 if ( cur.nodeType == 1 )
 matched.push( cur );
 cur = cur[dir];
 }
 return matched;
 },
 
 nth: function(cur,result,dir,elem){
 result = result || 1;
 var num = 0;

 for ( ; cur; cur = cur[dir] )
 if ( cur.nodeType == 1 && ++num == result )
 break;

 return cur;
 },
 
 sibling: function( n, elem ) {
 var r = [];

 for ( ; n; n = n.nextSibling ) {
 if ( n.nodeType == 1 && (!elem || n != elem) )
 r.push( n );
 }

 return r;
 }
});

/*
 * A number of helper functions used for managing events.
 * Many of the ideas behind this code orignated from 
 * Dean Edwards' addEvent library.
 */
jQuery.event = {

 // Bind an event to an element
 // Original by Dean Edwards
 add: function(elem, types, handler, data) {
 if ( elem.nodeType == 3 || elem.nodeType == 8 )
 return;

 // For whatever reason, IE has trouble passing the window object
 // around, causing it to be cloned in the process
 if ( jQuery.browser.msie && elem.setInterval != undefined )
 elem = window;

 // Make sure that the function being executed has a unique ID
 if ( !handler.guid )
 handler.guid = this.guid++;
 
 // if data is passed, bind to handler 
 if( data != undefined ) { 
 // Create temporary function pointer to original handler 
 var fn = handler; 

 // Create unique handler function, wrapped around original handler 
 handler = function() { 
 // Pass arguments and context to original handler 
 return fn.apply(this, arguments); 
 };

 // Store data in unique handler 
 handler.data = data;

 // Set the guid of unique handler to the same of original handler, so it can be removed 
 handler.guid = fn.guid;
 }

 // Init the element's event structure
 var events = jQuery.data(elem, "events") || jQuery.data(elem, "events", {}),
 handle = jQuery.data(elem, "handle") || jQuery.data(elem, "handle", function(){
 // returned undefined or false
 var val;

 // Handle the second event of a trigger and when
 // an event is called after a page has unloaded
 if ( typeof jQuery == "undefined" || jQuery.event.triggered )
 return val;
 
 val = jQuery.event.handle.apply(arguments.callee.elem, arguments);
 
 return val;
 });
 // Add elem as a property of the handle function
 // This is to prevent a memory leak with non-native
 // event in IE.
 handle.elem = elem;
 
 // Handle multiple events seperated by a space
 // jQuery(...).bind("mouseover mouseout", fn);
 jQuery.each(types.split(/\s+/), function(index, type) {
 // Namespaced event handlers
 var parts = type.split(".");
 type = parts[0];
 handler.type = parts[1];

 // Get the current list of functions bound to this event
 var handlers = events[type];

 // Init the event handler queue
 if (!handlers) {
 handlers = events[type] = {};
 
 // Check for a special event handler
 // Only use addEventListener/attachEvent if the special
 // events handler returns false
 if ( !jQuery.event.special[type] || jQuery.event.special[type].setup.call(elem) === false ) {
 // Bind the global event handler to the element
 if (elem.addEventListener)
 elem.addEventListener(type, handle, false);
 else if (elem.attachEvent)
 elem.attachEvent("on" + type, handle);
 }
 }

 // Add the function to the element's handler list
 handlers[handler.guid] = handler;

 // Keep track of which events have been used, for global triggering
 jQuery.event.global[type] = true;
 });
 
 // Nullify elem to prevent memory leaks in IE
 elem = null;
 },

 guid: 1,
 global: {},

 // Detach an event or set of events from an element
 remove: function(elem, types, handler) {
 // don't do events on text and comment nodes
 if ( elem.nodeType == 3 || elem.nodeType == 8 )
 return;

 var events = jQuery.data(elem, "events"), ret, index;

 if ( events ) {
 // Unbind all events for the element
 if ( types == undefined || (typeof types == "string" && types.charAt(0) == ".") )
 for ( var type in events )
 this.remove( elem, type + (types || "") );
 else {
 // types is actually an event object here
 if ( types.type ) {
 handler = types.handler;
 types = types.type;
 }
 
 // Handle multiple events seperated by a space
 // jQuery(...).unbind("mouseover mouseout", fn);
 jQuery.each(types.split(/\s+/), function(index, type){
 // Namespaced event handlers
 var parts = type.split(".");
 type = parts[0];
 
 if ( events[type] ) {
 // remove the given handler for the given type
 if ( handler )
 delete events[type][handler.guid];
 
 // remove all handlers for the given type
 else
 for ( handler in events[type] )
 // Handle the removal of namespaced events
 if ( !parts[1] || events[type][handler].type == parts[1] )
 delete events[type][handler];

 // remove generic event handler if no more handlers exist
 for ( ret in events[type] ) break;
 if ( !ret ) {
 if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem) === false ) {
 if (elem.removeEventListener)
 elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
 else if (elem.detachEvent)
 elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
 }
 ret = null;
 delete events[type];
 }
 }
 });
 }

 // Remove the expando if it's no longer used
 for ( ret in events ) break;
 if ( !ret ) {
 var handle = jQuery.data( elem, "handle" );
 if ( handle ) handle.elem = null;
 jQuery.removeData( elem, "events" );
 jQuery.removeData( elem, "handle" );
 }
 }
 },

 trigger: function(type, data, elem, donative, extra) {
 // Clone the incoming data, if any
 data = jQuery.makeArray(data || []);

 if ( type.indexOf("!") >= 0 ) {
 type = type.slice(0, -1);
 var exclusive = true;
 }

 // Handle a global trigger
 if ( !elem ) {
 // Only trigger if we've ever bound an event for it
 if ( this.global[type] )
 jQuery("*").add([window, document]).trigger(type, data);

 // Handle triggering a single element
 } else {
 // don't do events on text and comment nodes
 if ( elem.nodeType == 3 || elem.nodeType == 8 )
 return undefined;

 var val, ret, fn = jQuery.isFunction( elem[ type ] || null ),
 // Check to see if we need to provide a fake event, or not
 event = !data[0] || !data[0].preventDefault;
 
 // Pass along a fake event
 if ( event )
 data.unshift( this.fix({ type: type, target: elem }) );

 // Enforce the right trigger type
 data[0].type = type;
 if ( exclusive )
 data[0].exclusive = true;

 // Trigger the event
 if ( jQuery.isFunction( jQuery.data(elem, "handle") ) )
 val = jQuery.data(elem, "handle").apply( elem, data );

 // Handle triggering native .onfoo handlers
 if ( !fn && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
 val = false;

 // Extra functions don't get the custom event object
 if ( event )
 data.shift();

 // Handle triggering of extra function
 if ( extra && jQuery.isFunction( extra ) ) {
 // call the extra function and tack the current return value on the end for possible inspection
 ret = extra.apply( elem, val == null ? data : data.concat( val ) );
 // if anything is returned, give it precedence and have it overwrite the previous value
 if (ret !== undefined)
 val = ret;
 }

 // Trigger the native events (except for clicks on links)
 if ( fn && donative !== false && val !== false && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
 this.triggered = true;
 try {
 elem[ type ]();
 // prevent IE from throwing an error for some hidden elements
 } catch (e) {}
 }

 this.triggered = false;
 }

 return val;
 },

 handle: function(event) {
 // returned undefined or false
 var val;

 // Empty object is for triggered events with no data
 event = jQuery.event.fix( event || window.event || {} ); 

 // Namespaced event handlers
 var parts = event.type.split(".");
 event.type = parts[0];

 var handlers = jQuery.data(this, "events") && jQuery.data(this, "events")[event.type], args = Array.prototype.slice.call( arguments, 1 );
 args.unshift( event );

 for ( var j in handlers ) {
 var handler = handlers[j];
 // Pass in a reference to the handler function itself
 // So that we can later remove it
 args[0].handler = handler;
 args[0].data = handler.data;

 // Filter the functions by class
 if ( !parts[1] && !event.exclusive || handler.type == parts[1] ) {
 var ret = handler.apply( this, args );

 if ( val !== false )
 val = ret;

 if ( ret === false ) {
 event.preventDefault();
 event.stopPropagation();
 }
 }
 }

 // Clean up added properties in IE to prevent memory leak
 if (jQuery.browser.msie)
 event.target = event.preventDefault = event.stopPropagation =
 event.handler = event.data = null;

 return val;
 },

 fix: function(event) {
 // store a copy of the original event object 
 // and clone to set read-only properties
 var originalEvent = event;
 event = jQuery.extend({}, originalEvent);
 
 // add preventDefault and stopPropagation since 
 // they will not work on the clone
 event.preventDefault = function() {
 // if preventDefault exists run it on the original event
 if (originalEvent.preventDefault)
 originalEvent.preventDefault();
 // otherwise set the returnValue property of the original event to false (IE)
 originalEvent.returnValue = false;
 };
 event.stopPropagation = function() {
 // if stopPropagation exists run it on the original event
 if (originalEvent.stopPropagation)
 originalEvent.stopPropagation();
 // otherwise set the cancelBubble property of the original event to true (IE)
 originalEvent.cancelBubble = true;
 };
 
 // Fix target property, if necessary
 if ( !event.target )
 event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
 
 // check if target is a textnode (safari)
 if ( event.target.nodeType == 3 )
 event.target = originalEvent.target.parentNode;

 // Add relatedTarget, if necessary
 if ( !event.relatedTarget && event.fromElement )
 event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;

 // Calculate pageX/Y if missing and clientX/Y available
 if ( event.pageX == null && event.clientX != null ) {
 var doc = document.documentElement, body = document.body;
 event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
 event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
 }
 
 // Add which for key events
 if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
 event.which = event.charCode || event.keyCode;
 
 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
 if ( !event.metaKey && event.ctrlKey )
 event.metaKey = event.ctrlKey;

 // Add which for click: 1 == left; 2 == middle; 3 == right
 // Note: button is not normalized, so don't use it
 if ( !event.which && event.button )
 event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
 
 return event;
 },
 
 special: {
 ready: {
 setup: function() {
 // Make sure the ready event is setup
 bindReady();
 return;
 },
 
 teardown: function() { return; }
 },
 
 mouseenter: {
 setup: function() {
 if ( jQuery.browser.msie ) return false;
 jQuery(this).bind("mouseover", jQuery.event.special.mouseenter.handler);
 return true;
 },
 
 teardown: function() {
 if ( jQuery.browser.msie ) return false;
 jQuery(this).unbind("mouseover", jQuery.event.special.mouseenter.handler);
 return true;
 },
 
 handler: function(event) {
 // If we actually just moused on to a sub-element, ignore it
 if ( withinElement(event, this) ) return true;
 // Execute the right handlers by setting the event type to mouseenter
 arguments[0].type = "mouseenter";
 return jQuery.event.handle.apply(this, arguments);
 }
 },
 
 mouseleave: {
 setup: function() {
 if ( jQuery.browser.msie ) return false;
 jQuery(this).bind("mouseout", jQuery.event.special.mouseleave.handler);
 return true;
 },
 
 teardown: function() {
 if ( jQuery.browser.msie ) return false;
 jQuery(this).unbind("mouseout", jQuery.event.special.mouseleave.handler);
 return true;
 },
 
 handler: function(event) {
 // If we actually just moused on to a sub-element, ignore it
 if ( withinElement(event, this) ) return true;
 // Execute the right handlers by setting the event type to mouseleave
 arguments[0].type = "mouseleave";
 return jQuery.event.handle.apply(this, arguments);
 }
 }
 }
};

jQuery.fn.extend({
 bind: function( type, data, fn ) {
 return type == "unload" ? this.one(type, data, fn) : this.each(function(){
 jQuery.event.add( this, type, fn || data, fn && data );
 });
 },
 
 one: function( type, data, fn ) {
 return this.each(function(){
 jQuery.event.add( this, type, function(event) {
 jQuery(this).unbind(event);
 return (fn || data).apply( this, arguments);
 }, fn && data);
 });
 },

 unbind: function( type, fn ) {
 return this.each(function(){
 jQuery.event.remove( this, type, fn );
 });
 },

 trigger: function( type, data, fn ) {
 return this.each(function(){
 jQuery.event.trigger( type, data, this, true, fn );
 });
 },

 triggerHandler: function( type, data, fn ) {
 if ( this[0] )
 return jQuery.event.trigger( type, data, this[0], false, fn );
 return undefined;
 },

 toggle: function() {
 // Save reference to arguments for access in closure
 var args = arguments;

 return this.click(function(event) {
 // Figure out which function to execute
 this.lastToggle = 0 == this.lastToggle ? 1 : 0;
 
 // Make sure that clicks stop
 event.preventDefault();
 
 // and execute the function
 return args[this.lastToggle].apply( this, arguments ) || false;
 });
 },

 hover: function(fnOver, fnOut) {
 return this.bind('mouseenter', fnOver).bind('mouseleave', fnOut);
 },
 
 ready: function(fn) {
 // Attach the listeners
 bindReady();

 // If the DOM is already ready
 if ( jQuery.isReady )
 // Execute the function immediately
 fn.call( document, jQuery );
 
 // Otherwise, remember the function for later
 else
 // Add the function to the wait list
 jQuery.readyList.push( function() { return fn.call(this, jQuery); } );
 
 return this;
 }
});

jQuery.extend({
 isReady: false,
 readyList: [],
 // Handle when the DOM is ready
 ready: function() {
 // Make sure that the DOM is not already loaded
 if ( !jQuery.isReady ) {
 // Remember that the DOM is ready
 jQuery.isReady = true;
 
 // If there are functions bound, to execute
 if ( jQuery.readyList ) {
 // Execute all of them
 jQuery.each( jQuery.readyList, function(){
 this.apply( document );
 });
 
 // Reset the list of functions
 jQuery.readyList = null;
 }
 
 // Trigger any bound ready events
 jQuery(document).triggerHandler("ready");
 }
 }
});

var readyBound = false;

function bindReady(){
 if ( readyBound ) return;
 readyBound = true;

 // Mozilla, Opera (see further below for it) and webkit nightlies currently support this event
 if ( document.addEventListener && !jQuery.browser.opera)
 // Use the handy event callback
 document.addEventListener( "DOMContentLoaded", jQuery.ready, false );
 
 // If IE is used and is not in a frame
 // Continually check to see if the document is ready
 if ( jQuery.browser.msie && window == top ) (function(){
 if (jQuery.isReady) return;
 try {
 // If IE is used, use the trick by Diego Perini
 // http://javascript.nwbox.com/IEContentLoaded/
 document.documentElement.doScroll("left");
 } catch( error ) {
 setTimeout( arguments.callee, 0 );
 return;
 }
 // and execute any waiting functions
 jQuery.ready();
 })();

 if ( jQuery.browser.opera )
 document.addEventListener( "DOMContentLoaded", function () {
 if (jQuery.isReady) return;
 for (var i = 0; i < document.styleSheets.length; i++)
 if (document.styleSheets[i].disabled) {
 setTimeout( arguments.callee, 0 );
 return;
 }
 // and execute any waiting functions
 jQuery.ready();
 }, false);

 if ( jQuery.browser.safari ) {
 var numStyles;
 (function(){
 if (jQuery.isReady) return;
 if ( document.readyState != "loaded" && document.readyState != "complete" ) {
 setTimeout( arguments.callee, 0 );
 return;
 }
 if ( numStyles === undefined )
 numStyles = jQuery("style, link[rel=stylesheet]").length;
 if ( document.styleSheets.length != numStyles ) {
 setTimeout( arguments.callee, 0 );
 return;
 }
 // and execute any waiting functions
 jQuery.ready();
 })();
 }

 // A fallback to window.onload, that will always work
 jQuery.event.add( window, "load", jQuery.ready );
}

jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," +
 "mousedown,mouseup,mousemove,mouseover,mouseout,change,select," + 
 "submit,keydown,keypress,keyup,error").split(","), function(i, name){
 
 // Handle event binding
 jQuery.fn[name] = function(fn){
 return fn ? this.bind(name, fn) : this.trigger(name);
 };
});

// Checks if an event happened on an element within another element
// Used in jQuery.event.special.mouseenter and mouseleave handlers
var withinElement = function(event, elem) {
 // Check if mouse(over|out) are still within the same parent element
 var parent = event.relatedTarget;
 // Traverse up the tree
 while ( parent && parent != elem ) try { parent = parent.parentNode; } catch(error) { parent = elem; }
 // Return true if we actually just moused on to a sub-element
 return parent == elem;
};

// Prevent memory leaks in IE
// And prevent errors on refresh with events like mouseover in other browsers
// Window isn't included so as not to unbind existing unload events
jQuery(window).bind("unload", function() {
 jQuery("*").add(document).unbind();
});
jQuery.fn.extend({
 load: function( url, params, callback ) {
 if ( jQuery.isFunction( url ) )
 return this.bind("load", url);

 var off = url.indexOf(" ");
 if ( off >= 0 ) {
 var selector = url.slice(off, url.length);
 url = url.slice(0, off);
 }

 callback = callback || function(){};

 // Default to a GET request
 var type = "GET";

 // If the second parameter was provided
 if ( params )
 // If it's a function
 if ( jQuery.isFunction( params ) ) {
 // We assume that it's the callback
 callback = params;
 params = null;

 // Otherwise, build a param string
 } else {
 params = jQuery.param( params );
 type = "POST";
 }

 var self = this;

 // Request the remote document
 jQuery.ajax({
 url: url,
 type: type,
 dataType: "html",
 data: params,
 complete: function(res, status){
 // If successful, inject the HTML into all the matched elements
 if ( status == "success" || status == "notmodified" )
 // See if a selector was specified
 self.html( selector ?
 // Create a dummy div to hold the results
 jQuery("<div/>")
 // inject the contents of the document in, removing the scripts
 // to avoid any 'Permission Denied' errors in IE
 .append(res.responseText.replace(/<script(.|\s)*?\/script>/g, ""))

 // Locate the specified elements
 .find(selector) :

 // If not, just inject the full result
 res.responseText );

 self.each( callback, [res.responseText, status, res] );
 }
 });
 return this;
 },

 serialize: function() {
 return jQuery.param(this.serializeArray());
 },
 serializeArray: function() {
 return this.map(function(){
 return jQuery.nodeName(this, "form") ?
 jQuery.makeArray(this.elements) : this;
 })
 .filter(function(){
 return this.name && !this.disabled && 
 (this.checked || /select|textarea/i.test(this.nodeName) || 
 /text|hidden|password/i.test(this.type));
 })
 .map(function(i, elem){
 var val = jQuery(this).val();
 return val == null ? null :
 val.constructor == Array ?
 jQuery.map( val, function(val, i){
 return {name: elem.name, value: val};
 }) :
 {name: elem.name, value: val};
 }).get();
 }
});

// Attach a bunch of functions for handling common AJAX events
jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
 jQuery.fn[o] = function(f){
 return this.bind(o, f);
 };
});

var jsc = (new Date).getTime();

jQuery.extend({
 get: function( url, data, callback, type ) {
 // shift arguments if data argument was ommited
 if ( jQuery.isFunction( data ) ) {
 callback = data;
 data = null;
 }
 
 return jQuery.ajax({
 type: "GET",
 url: url,
 data: data,
 success: callback,
 dataType: type
 });
 },

 getScript: function( url, callback ) {
 return jQuery.get(url, null, callback, "script");
 },

 getJSON: function( url, data, callback ) {
 return jQuery.get(url, data, callback, "json");
 },

 post: function( url, data, callback, type ) {
 if ( jQuery.isFunction( data ) ) {
 callback = data;
 data = {};
 }

 return jQuery.ajax({
 type: "POST",
 url: url,
 data: data,
 success: callback,
 dataType: type
 });
 },

 ajaxSetup: function( settings ) {
 jQuery.extend( jQuery.ajaxSettings, settings );
 },

 ajaxSettings: {
 global: true,
 type: "GET",
 timeout: 0,
 contentType: "application/x-www-form-urlencoded",
 processData: true,
 async: true,
 data: null,
 username: null,
 password: null,
 accepts: {
 xml: "application/xml, text/xml",
 html: "text/html",
 script: "text/javascript, application/javascript",
 json: "application/json, text/javascript",
 text: "text/plain",
 _default: "*/*"
 }
 },
 
 // Last-Modified header cache for next request
 lastModified: {},

 ajax: function( s ) {
 var jsonp, jsre = /=\?(&|$)/g, status, data;

 // Extend the settings, but re-extend 's' so that it can be
 // checked again later (in the test suite, specifically)
 s = jQuery.extend(true, s, jQuery.extend(true, {}, jQuery.ajaxSettings, s));

 // convert data if not already a string
 if ( s.data && s.processData && typeof s.data != "string" )
 s.data = jQuery.param(s.data);

 // Handle JSONP Parameter Callbacks
 if ( s.dataType == "jsonp" ) {
 if ( s.type.toLowerCase() == "get" ) {
 if ( !s.url.match(jsre) )
 s.url += (s.url.match(/\?/) ? "&" : "?") + (s.jsonp || "callback") + "=?";
 } else if ( !s.data || !s.data.match(jsre) )
 s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
 s.dataType = "json";
 }

 // Build temporary JSONP function
 if ( s.dataType == "json" && (s.data && s.data.match(jsre) || s.url.match(jsre)) ) {
 jsonp = "jsonp" + jsc++;

 // Replace the =? sequence both in the query string and the data
 if ( s.data )
 s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
 s.url = s.url.replace(jsre, "=" + jsonp + "$1");

 // We need to make sure
 // that a JSONP style response is executed properly
 s.dataType = "script";

 // Handle JSONP-style loading
 window[ jsonp ] = function(tmp){
 data = tmp;
 success();
 complete();
 // Garbage collect
 window[ jsonp ] = undefined;
 try{ delete window[ jsonp ]; } catch(e){}
 if ( head )
 head.removeChild( script );
 };
 }

 if ( s.dataType == "script" && s.cache == null )
 s.cache = false;

 if ( s.cache === false && s.type.toLowerCase() == "get" ) {
 var ts = (new Date()).getTime();
 // try replacing _= if it is there
 var ret = s.url.replace(/(\?|&)_=.*?(&|$)/, "$1_=" + ts + "$2");
 // if nothing was replaced, add timestamp to the end
 s.url = ret + ((ret == s.url) ? (s.url.match(/\?/) ? "&" : "?") + "_=" + ts : "");
 }

 // If data is available, append data to url for get requests
 if ( s.data && s.type.toLowerCase() == "get" ) {
 s.url += (s.url.match(/\?/) ? "&" : "?") + s.data;

 // IE likes to send both get and post data, prevent this
 s.data = null;
 }

 // Watch for a new set of requests
 if ( s.global && ! jQuery.active++ )
 jQuery.event.trigger( "ajaxStart" );

 // If we're requesting a remote document
 // and trying to load JSON or Script with a GET
 if ( (!s.url.indexOf("http") || !s.url.indexOf("//")) && s.dataType == "script" && s.type.toLowerCase() == "get" ) {
 var head = document.getElementsByTagName("head")[0];
 var script = document.createElement("script");
 script.src = s.url;
 if (s.scriptCharset)
 script.charset = s.scriptCharset;

 // Handle Script loading
 if ( !jsonp ) {
 var done = false;

 // Attach handlers for all browsers
 script.onload = script.onreadystatechange = function(){
 if ( !done && (!this.readyState || 
 this.readyState == "loaded" || this.readyState == "complete") ) {
 done = true;
 success();
 complete();
 head.removeChild( script );
 }
 };
 }

 head.appendChild(script);

 // We handle everything using the script element injection
 return undefined;
 }

 var requestDone = false;

 // Create the request object; Microsoft failed to properly
 // implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available
 var xml = window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();

 // Open the socket
 xml.open(s.type, s.url, s.async, s.username, s.password);

 // Need an extra try/catch for cross domain requests in Firefox 3
 try {
 // Set the correct header, if data is being sent
 if ( s.data )
 xml.setRequestHeader("Content-Type", s.contentType);

 // Set the If-Modified-Since header, if ifModified mode.
 if ( s.ifModified )
 xml.setRequestHeader("If-Modified-Since",
 jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" );

 // Set header so the called script knows that it's an XMLHttpRequest
 xml.setRequestHeader("X-Requested-With", "XMLHttpRequest");

 // Set the Accepts header for the server, depending on the dataType
 xml.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
 s.accepts[ s.dataType ] + ", */*" :
 s.accepts._default );
 } catch(e){}

 // Allow custom headers/mimetypes
 if ( s.beforeSend )
 s.beforeSend(xml);
 
 if ( s.global )
 jQuery.event.trigger("ajaxSend", [xml, s]);

 // Wait for a response to come back
 var onreadystatechange = function(isTimeout){
 // The transfer is complete and the data is available, or the request timed out
 if ( !requestDone && xml && (xml.readyState == 4 || isTimeout == "timeout") ) {
 requestDone = true;
 
 // clear poll interval
 if (ival) {
 clearInterval(ival);
 ival = null;
 }
 
 status = isTimeout == "timeout" && "timeout" ||
 !jQuery.httpSuccess( xml ) && "error" ||
 s.ifModified && jQuery.httpNotModified( xml, s.url ) && "notmodified" ||
 "success";

 if ( status == "success" ) {
 // Watch for, and catch, XML document parse errors
 try {
 // process the data (runs the xml through httpData regardless of callback)
 data = jQuery.httpData( xml, s.dataType );
 } catch(e) {
 status = "parsererror";
 }
 }

 // Make sure that the request was successful or notmodified
 if ( status == "success" ) {
 // Cache Last-Modified header, if ifModified mode.
 var modRes;
 try {
 modRes = xml.getResponseHeader("Last-Modified");
 } catch(e) {} // swallow exception thrown by FF if header is not available
 
 if ( s.ifModified && modRes )
 jQuery.lastModified[s.url] = modRes;

 // JSONP handles its own success callback
 if ( !jsonp )
 success(); 
 } else
 jQuery.handleError(s, xml, status);

 // Fire the complete handlers
 complete();

 // Stop memory leaks
 if ( s.async )
 xml = null;
 }
 };
 
 if ( s.async ) {
 // don't attach the handler to the request, just poll it instead
 var ival = setInterval(onreadystatechange, 13); 

 // Timeout checker
 if ( s.timeout > 0 )
 setTimeout(function(){
 // Check to see if the request is still happening
 if ( xml ) {
 // Cancel the request
 xml.abort();
 
 if( !requestDone )
 onreadystatechange( "timeout" );
 }
 }, s.timeout);
 }
 
 // Send the data
 try {
 xml.send(s.data);
 } catch(e) {
 jQuery.handleError(s, xml, null, e);
 }
 
 // firefox 1.5 doesn't fire statechange for sync requests
 if ( !s.async )
 onreadystatechange();

 function success(){
 // If a local callback was specified, fire it and pass it the data
 if ( s.success )
 s.success( data, status );

 // Fire the global callback
 if ( s.global )
 jQuery.event.trigger( "ajaxSuccess", [xml, s] );
 }

 function complete(){
 // Process result
 if ( s.complete )
 s.complete(xml, status);

 // The request was completed
 if ( s.global )
 jQuery.event.trigger( "ajaxComplete", [xml, s] );

 // Handle the global AJAX counter
 if ( s.global && ! --jQuery.active )
 jQuery.event.trigger( "ajaxStop" );
 }
 
 // return XMLHttpRequest to allow aborting the request etc.
 return xml;
 },

 handleError: function( s, xml, status, e ) {
 // If a local callback was specified, fire it
 if ( s.error ) s.error( xml, status, e );

 // Fire the global callback
 if ( s.global )
 jQuery.event.trigger( "ajaxError", [xml, s, e] );
 },

 // Counter for holding the number of active queries
 active: 0,

 // Determines if an XMLHttpRequest was successful or not
 httpSuccess: function( r ) {
 try {
 // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
 return !r.status && location.protocol == "file:" ||
 ( r.status >= 200 && r.status < 300 ) || r.status == 304 || r.status == 1223 ||
 jQuery.browser.safari && r.status == undefined;
 } catch(e){}
 return false;
 },

 // Determines if an XMLHttpRequest returns NotModified
 httpNotModified: function( xml, url ) {
 try {
 var xmlRes = xml.getResponseHeader("Last-Modified");

 // Firefox always returns 200. check Last-Modified date
 return xml.status == 304 || xmlRes == jQuery.lastModified[url] ||
 jQuery.browser.safari && xml.status == undefined;
 } catch(e){}
 return false;
 },

 httpData: function( r, type ) {
 var ct = r.getResponseHeader("content-type");
 var xml = type == "xml" || !type && ct && ct.indexOf("xml") >= 0;
 var data = xml ? r.responseXML : r.responseText;

 if ( xml && data.documentElement.tagName == "parsererror" )
 throw "parsererror";

 // If the type is "script", eval it in global context
 if ( type == "script" )
 jQuery.globalEval( data );

 // Get the JavaScript object, if JSON is used.
 if ( type == "json" )
 data = eval("(" + data + ")");

 return data;
 },

 // Serialize an array of form elements or a set of
 // key/values into a query string
 param: function( a ) {
 var s = [];

 // If an array was passed in, assume that it is an array
 // of form elements
 if ( a.constructor == Array || a.jquery )
 // Serialize the form elements
 jQuery.each( a, function(){
 s.push( encodeURIComponent(this.name) + "=" + encodeURIComponent( this.value ) );
 });

 // Otherwise, assume that it's an object of key/value pairs
 else
 // Serialize the key/values
 for ( var j in a )
 // If the value is an array then the key names need to be repeated
 if ( a[j] && a[j].constructor == Array )
 jQuery.each( a[j], function(){
 s.push( encodeURIComponent(j) + "=" + encodeURIComponent( this ) );
 });
 else
 s.push( encodeURIComponent(j) + "=" + encodeURIComponent( a[j] ) );

 // Return the resulting serialization
 return s.join("&").replace(/%20/g, "+");
 }

});
jQuery.fn.extend({
 show: function(speed,callback){
 return speed ?
 this.animate({
 height: "show", width: "show", opacity: "show"
 }, speed, callback) :
 
 this.filter(":hidden").each(function(){
 this.style.display = this.oldblock || "";
 if ( jQuery.css(this,"display") == "none" ) {
 var elem = jQuery("<" + this.tagName + " />").appendTo("body");
 this.style.display = elem.css("display");
 // handle an edge condition where css is - div { display:none; } or similar
 if (this.style.display == "none")
 this.style.display = "block";
 elem.remove();
 }
 }).end();
 },
 
 hide: function(speed,callback){
 return speed ?
 this.animate({
 height: "hide", width: "hide", opacity: "hide"
 }, speed, callback) :
 
 this.filter(":visible").each(function(){
 this.oldblock = this.oldblock || jQuery.css(this,"display");
 this.style.display = "none";
 }).end();
 },

 // Save the old toggle function
 _toggle: jQuery.fn.toggle,
 
 toggle: function( fn, fn2 ){
 return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
 this._toggle( fn, fn2 ) :
 fn ?
 this.animate({
 height: "toggle", width: "toggle", opacity: "toggle"
 }, fn, fn2) :
 this.each(function(){
 jQuery(this)[ jQuery(this).is(":hidden") ? "show" : "hide" ]();
 });
 },
 
 slideDown: function(speed,callback){
 return this.animate({height: "show"}, speed, callback);
 },
 
 slideUp: function(speed,callback){
 return this.animate({height: "hide"}, speed, callback);
 },

 slideToggle: function(speed, callback){
 return this.animate({height: "toggle"}, speed, callback);
 },
 
 fadeIn: function(speed, callback){
 return this.animate({opacity: "show"}, speed, callback);
 },
 
 fadeOut: function(speed, callback){
 return this.animate({opacity: "hide"}, speed, callback);
 },
 
 fadeTo: function(speed,to,callback){
 return this.animate({opacity: to}, speed, callback);
 },
 
 animate: function( prop, speed, easing, callback ) {
 var optall = jQuery.speed(speed, easing, callback);

 return this[ optall.queue === false ? "each" : "queue" ](function(){
 if ( this.nodeType != 1)
 return false;

 var opt = jQuery.extend({}, optall);
 var hidden = jQuery(this).is(":hidden"), self = this;
 
 for ( var p in prop ) {
 if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden )
 return jQuery.isFunction(opt.complete) && opt.complete.apply(this);

 if ( p == "height" || p == "width" ) {
 // Store display property
 opt.display = jQuery.css(this, "display");

 // Make sure that nothing sneaks out
 opt.overflow = this.style.overflow;
 }
 }

 if ( opt.overflow != null )
 this.style.overflow = "hidden";

 opt.curAnim = jQuery.extend({}, prop);
 
 jQuery.each( prop, function(name, val){
 var e = new jQuery.fx( self, opt, name );

 if ( /toggle|show|hide/.test(val) )
 e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );
 else {
 var parts = val.toString().match(/^([+-]=)?([\d+-.]+)(.*)$/),
 start = e.cur(true) || 0;

 if ( parts ) {
 var end = parseFloat(parts[2]),
 unit = parts[3] || "px";

 // We need to compute starting value
 if ( unit != "px" ) {
 self.style[ name ] = (end || 1) + unit;
 start = ((end || 1) / e.cur(true)) * start;
 self.style[ name ] = start + unit;
 }

 // If a +=/-= token was provided, we're doing a relative animation
 if ( parts[1] )
 end = ((parts[1] == "-=" ? -1 : 1) * end) + start;

 e.custom( start, end, unit );
 } else
 e.custom( start, val, "" );
 }
 });

 // For JS strict compliance
 return true;
 });
 },
 
 queue: function(type, fn){
 if ( jQuery.isFunction(type) || ( type && type.constructor == Array )) {
 fn = type;
 type = "fx";
 }

 if ( !type || (typeof type == "string" && !fn) )
 return queue( this[0], type );

 return this.each(function(){
 if ( fn.constructor == Array )
 queue(this, type, fn);
 else {
 queue(this, type).push( fn );
 
 if ( queue(this, type).length == 1 )
 fn.apply(this);
 }
 });
 },

 stop: function(clearQueue, gotoEnd){
 var timers = jQuery.timers;

 if (clearQueue)
 this.queue([]);

 this.each(function(){
 // go in reverse order so anything added to the queue during the loop is ignored
 for ( var i = timers.length - 1; i >= 0; i-- )
 if ( timers[i].elem == this ) {
 if (gotoEnd)
 // force the next step to be the last
 timers[i](true);
 timers.splice(i, 1);
 }
 });

 // start the next in the queue if the last step wasn't forced
 if (!gotoEnd)
 this.dequeue();

 return this;
 }

});

var queue = function( elem, type, array ) {
 if ( !elem )
 return undefined;

 type = type || "fx";

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

 if ( !q || array )
 q = jQuery.data( elem, type + "queue", 
 array ? jQuery.makeArray(array) : [] );

 return q;
};

jQuery.fn.dequeue = function(type){
 type = type || "fx";

 return this.each(function(){
 var q = queue(this, type);

 q.shift();

 if ( q.length )
 q[0].apply( this );
 });
};

jQuery.extend({
 
 speed: function(speed, easing, fn) {
 var opt = speed && speed.constructor == Object ? speed : {
 complete: fn || !fn && easing || 
 jQuery.isFunction( speed ) && speed,
 duration: speed,
 easing: fn && easing || easing && easing.constructor != Function && easing
 };

 opt.duration = (opt.duration && opt.duration.constructor == Number ? 
 opt.duration : 
 { slow: 600, fast: 200 }[opt.duration]) || 400;
 
 // Queueing
 opt.old = opt.complete;
 opt.complete = function(){
 if ( opt.queue !== false )
 jQuery(this).dequeue();
 if ( jQuery.isFunction( opt.old ) )
 opt.old.apply( this );
 };
 
 return opt;
 },
 
 easing: {
 linear: function( p, n, firstNum, diff ) {
 return firstNum + diff * p;
 },
 swing: function( p, n, firstNum, diff ) {
 return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
 }
 },
 
 timers: [],
 timerId: null,

 fx: function( elem, options, prop ){
 this.options = options;
 this.elem = elem;
 this.prop = prop;

 if ( !options.orig )
 options.orig = {};
 }

});

jQuery.fx.prototype = {

 // Simple function for setting a style value
 update: function(){
 if ( this.options.step )
 this.options.step.apply( this.elem, [ this.now, this ] );

 (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );

 // Set display property to block for height/width animations
 if ( this.prop == "height" || this.prop == "width" )
 this.elem.style.display = "block";
 },

 // Get the current size
 cur: function(force){
 if ( this.elem[this.prop] != null && this.elem.style[this.prop] == null )
 return this.elem[ this.prop ];

 var r = parseFloat(jQuery.css(this.elem, this.prop, force));
 return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
 },

 // Start an animation from one number to another
 custom: function(from, to, unit){
 this.startTime = (new Date()).getTime();
 this.start = from;
 this.end = to;
 this.unit = unit || this.unit || "px";
 this.now = this.start;
 this.pos = this.state = 0;
 this.update();

 var self = this;
 function t(gotoEnd){
 return self.step(gotoEnd);
 }

 t.elem = this.elem;

 jQuery.timers.push(t);

 if ( jQuery.timerId == null ) {
 jQuery.timerId = setInterval(function(){
 var timers = jQuery.timers;
 
 for ( var i = 0; i < timers.length; i++ )
 if ( !timers[i]() )
 timers.splice(i--, 1);

 if ( !timers.length ) {
 clearInterval( jQuery.timerId );
 jQuery.timerId = null;
 }
 }, 13);
 }
 },

 // Simple 'show' function
 show: function(){
 // Remember where we started, so that we can go back to it later
 this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
 this.options.show = true;

 // Begin the animation
 this.custom(0, this.cur());

 // Make sure that we start at a small width/height to avoid any
 // flash of content
 if ( this.prop == "width" || this.prop == "height" )
 this.elem.style[this.prop] = "1px";
 
 // Start by showing the element
 jQuery(this.elem).show();
 },

 // Simple 'hide' function
 hide: function(){
 // Remember where we started, so that we can go back to it later
 this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
 this.options.hide = true;

 // Begin the animation
 this.custom(this.cur(), 0);
 },

 // Each step of an animation
 step: function(gotoEnd){
 var t = (new Date()).getTime();

 if ( gotoEnd || t > this.options.duration + this.startTime ) {
 this.now = this.end;
 this.pos = this.state = 1;
 this.update();

 this.options.curAnim[ this.prop ] = true;

 var done = true;
 for ( var i in this.options.curAnim )
 if ( this.options.curAnim[i] !== true )
 done = false;

 if ( done ) {
 if ( this.options.display != null ) {
 // Reset the overflow
 this.elem.style.overflow = this.options.overflow;
 
 // Reset the display
 this.elem.style.display = this.options.display;
 if ( jQuery.css(this.elem, "display") == "none" )
 this.elem.style.display = "block";
 }

 // Hide the element if the "hide" operation was done
 if ( this.options.hide )
 this.elem.style.display = "none";

 // Reset the properties, if the item has been hidden or shown
 if ( this.options.hide || this.options.show )
 for ( var p in this.options.curAnim )
 jQuery.attr(this.elem.style, p, this.options.orig[p]);
 }

 // If a callback was provided, execute it
 if ( done && jQuery.isFunction( this.options.complete ) )
 // Execute the complete function
 this.options.complete.apply( this.elem );

 return false;
 } else {
 var n = t - this.startTime;
 this.state = n / this.options.duration;

 // Perform the easing function, defaults to swing
 this.pos = jQuery.easing[this.options.easing || (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
 this.now = this.start + ((this.end - this.start) * this.pos);

 // Perform the next step of the animation
 this.update();
 }

 return true;
 }

};

jQuery.fx.step = {
 scrollLeft: function(fx){
 fx.elem.scrollLeft = fx.now;
 },

 scrollTop: function(fx){
 fx.elem.scrollTop = fx.now;
 },

 opacity: function(fx){
 jQuery.attr(fx.elem.style, "opacity", fx.now);
 },

 _default: function(fx){
 fx.elem.style[ fx.prop ] = fx.now + fx.unit;
 }
};
// The Offset Method
// Originally By Brandon Aaron, part of the Dimension Plugin
// http://jquery.com/plugins/project/dimensions
jQuery.fn.offset = function() {
 var left = 0, top = 0, elem = this[0], results;
 
 if ( elem ) with ( jQuery.browser ) {
 var parent = elem.parentNode, 
 offsetChild = elem,
 offsetParent = elem.offsetParent, 
 doc = elem.ownerDocument,
 safari2 = safari && parseInt(version) < 522 && !/adobeair/i.test(userAgent),
 fixed = jQuery.css(elem, "position") == "fixed";
 
 // Use getBoundingClientRect if available
 if ( elem.getBoundingClientRect ) {
 var box = elem.getBoundingClientRect();
 
 // Add the document scroll offsets
 add(box.left + Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft),
 box.top + Math.max(doc.documentElement.scrollTop, doc.body.scrollTop));
 
 // IE adds the HTML element's border, by default it is medium which is 2px
 // IE 6 and 7 quirks mode the border width is overwritable by the following css html { border: 0; }
 // IE 7 standards mode, the border is always 2px
 // This border/offset is typically represented by the clientLeft and clientTop properties
 // However, in IE6 and 7 quirks mode the clientLeft and clientTop properties are not updated when overwriting it via CSS
 // Therefore this method will be off by 2px in IE while in quirksmode
 add( -doc.documentElement.clientLeft, -doc.documentElement.clientTop );
 
 // Otherwise loop through the offsetParents and parentNodes
 } else {
 
 // Initial element offsets
 add( elem.offsetLeft, elem.offsetTop );
 
 // Get parent offsets
 while ( offsetParent ) {
 // Add offsetParent offsets
 add( offsetParent.offsetLeft, offsetParent.offsetTop );
 
 // Mozilla and Safari > 2 does not include the border on offset parents
 // However Mozilla adds the border for table or table cells
 if ( mozilla && !/^t(able|d|h)$/i.test(offsetParent.tagName) || safari && !safari2 )
 border( offsetParent );
 
 // Add the document scroll offsets if position is fixed on any offsetParent
 if ( !fixed && jQuery.css(offsetParent, "position") == "fixed" )
 fixed = true;
 
 // Set offsetChild to previous offsetParent unless it is the body element
 offsetChild = /^body$/i.test(offsetParent.tagName) ? offsetChild : offsetParent;
 // Get next offsetParent
 offsetParent = offsetParent.offsetParent;
 }
 
 // Get parent scroll offsets
 while ( parent && parent.tagName && !/^body|html$/i.test(parent.tagName) ) {
 // Remove parent scroll UNLESS that parent is inline or a table to work around Opera inline/table scrollLeft/Top bug
 if ( !/^inline|table.*$/i.test(jQuery.css(parent, "display")) )
 // Subtract parent scroll offsets
 add( -parent.scrollLeft, -parent.scrollTop );
 
 // Mozilla does not add the border for a parent that has overflow != visible
 if ( mozilla && jQuery.css(parent, "overflow") != "visible" )
 border( parent );
 
 // Get next parent
 parent = parent.parentNode;
 }
 
 // Safari <= 2 doubles body offsets with a fixed position element/offsetParent or absolutely positioned offsetChild
 // Mozilla doubles body offsets with a non-absolutely positioned offsetChild
 if ( (safari2 && (fixed || jQuery.css(offsetChild, "position") == "absolute")) || 
 (mozilla && jQuery.css(offsetChild, "position") != "absolute") )
 add( -doc.body.offsetLeft, -doc.body.offsetTop );
 
 // Add the document scroll offsets if position is fixed
 if ( fixed )
 add(Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft),
 Math.max(doc.documentElement.scrollTop, doc.body.scrollTop));
 }

 // Return an object with top and left properties
 results = { top: top, left: left };
 }

 function border(elem) {
 add( jQuery.curCSS(elem, "borderLeftWidth", true), jQuery.curCSS(elem, "borderTopWidth", true) );
 }

 function add(l, t) {
 left += parseInt(l) || 0;
 top += parseInt(t) || 0;
 }

 return results;
};
})();
jQuery.noConflict();/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is bundled with this package in the file LICENSE.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/osl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@magentocommerce.com so we can send you a copy immediately.
 *
 * @copyright Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
 * @license http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 */
if(typeof Product=='undefined') {
 var Product = {};
}

/********************* IMAGE ZOOMER ***********************/

Product.Zoom = Class.create();
/**
 * Image zoom control
 *
 * @author Magento Core Team <core@magentocommerce.com>
 */
Product.Zoom.prototype = {
 initialize: function(imageEl, trackEl, handleEl, zoomInEl, zoomOutEl, hintEl){
 this.containerEl = $(imageEl).parentNode;
 this.imageEl = $(imageEl);
 this.handleEl = $(handleEl);
 this.trackEl = $(trackEl);
 this.hintEl = $(hintEl);

 this.containerDim = Element.getDimensions(this.containerEl);
 this.imageDim = Element.getDimensions(this.imageEl);

 this.imageDim.ratio = this.imageDim.width/this.imageDim.height;

 this.floorZoom = 1;

 if (this.imageDim.width > this.imageDim.height) {
 this.ceilingZoom = this.imageDim.width / this.containerDim.width;
 } else {
 this.ceilingZoom = this.imageDim.height / this.containerDim.height;
 }

 if (this.imageDim.width < this.containerDim.width
 && this.imageDim.height < this.containerDim.height) {
 this.trackEl.up().hide();
 this.hintEl.hide();
 this.containerEl.removeClassName('main-product-img');
 return;
 }

 this.imageX = 0;
 this.imageY = 0;
 this.imageZoom = 1;

 this.sliderSpeed = 0;
 this.sliderAccel = 0;
 this.zoomBtnPressed = false;

 this.showFull = false;

 this.selects = document.getElementsByTagName('select');

 this.draggable = new Draggable(imageEl, {
 starteffect:false,
 reverteffect:false,
 endeffect:false,
 snap:this.contain.bind(this)
 });

 this.slider = new Control.Slider(handleEl, trackEl, {
 axis:'horizontal',
 minimum:0,
 maximum:Element.getDimensions(this.trackEl).width,
 alignX:0,
 increment:1,
 sliderValue:0,
 onSlide:this.scale.bind(this),
 onChange:this.scale.bind(this)
 });

 this.scale(0);

 Event.observe(this.imageEl, 'dblclick', this.toggleFull.bind(this));

 Event.observe($(zoomInEl), 'mousedown', this.startZoomIn.bind(this));
 Event.observe($(zoomInEl), 'mouseup', this.stopZooming.bind(this));
 Event.observe($(zoomInEl), 'mouseout', this.stopZooming.bind(this));

 Event.observe($(zoomOutEl), 'mousedown', this.startZoomOut.bind(this));
 Event.observe($(zoomOutEl), 'mouseup', this.stopZooming.bind(this));
 Event.observe($(zoomOutEl), 'mouseout', this.stopZooming.bind(this));
 },

 toggleFull: function () {
 this.showFull = !this.showFull;
 //TODO: hide selects for IE only

 for (i=0; i<this.selects.length; i++) {
 this.selects[i].style.visibility = this.showFull ? 'hidden' : 'visible';
 }
 val_scale = !this.showFull ? this.slider.value : 1;
 this.scale(val_scale);

 this.trackEl.style.visibility = this.showFull ? 'hidden' : 'visible';
 this.containerEl.style.overflow = this.showFull ? 'visible' : 'hidden';
 this.containerEl.style.zIndex = this.showFull ? '999' : '9';

 return this;
 },

 scale: function (v) {

 var centerX = (this.containerDim.width*(1-this.imageZoom)/2-this.imageX)/this.imageZoom;
 var centerY = (this.containerDim.height*(1-this.imageZoom)/2-this.imageY)/this.imageZoom;

 this.imageZoom = this.floorZoom+(v*(this.ceilingZoom-this.floorZoom));

 this.imageEl.style.width = (this.imageZoom*this.containerDim.width)+'px';
 if(this.containerDim.ratio){
 this.imageEl.style.height = (this.imageZoom*this.containerDim.width*this.containerDim.ratio)+'px'; // for safari
 }

 this.imageX = this.containerDim.width*(1-this.imageZoom)/2-centerX*this.imageZoom;
 this.imageY = this.containerDim.height*(1-this.imageZoom)/2-centerY*this.imageZoom;

 this.contain(this.imageX, this.imageY, this.draggable);

 return true;
 },

 startZoomIn: function()
 {
 this.zoomBtnPressed = true;
 this.sliderAccel = .002;
 this.periodicalZoom();
 this.zoomer = new PeriodicalExecuter(this.periodicalZoom.bind(this), .05);
 return this;
 },

 startZoomOut: function()
 {
 this.zoomBtnPressed = true;
 this.sliderAccel = -.002;
 this.periodicalZoom();
 this.zoomer = new PeriodicalExecuter(this.periodicalZoom.bind(this), .05);
 return this;
 },

 stopZooming: function()
 {
 if (!this.zoomer || this.sliderSpeed==0) {
 return;
 }
 this.zoomBtnPressed = false;
 this.sliderAccel = 0;
 },

 periodicalZoom: function()
 {
 if (!this.zoomer) {
 return this;
 }

 if (this.zoomBtnPressed) {
 this.sliderSpeed += this.sliderAccel;
 } else {
 this.sliderSpeed /= 1.5;
 if (Math.abs(this.sliderSpeed)<.001) {
 this.sliderSpeed = 0;
 this.zoomer.stop();
 this.zoomer = null;
 }
 }
 this.slider.value += this.sliderSpeed;

 this.slider.setValue(this.slider.value);
 this.scale(this.slider.value);

 return this;
 },

 contain: function (x,y,draggable) {

 var dim = Element.getDimensions(draggable.element);

 var xMin = 0, xMax = this.containerDim.width-dim.width;
 var yMin = 0, yMax = this.containerDim.height-dim.height;

 x = x>xMin ? xMin : x;
 x = x<xMax ? xMax : x;
 y = y>yMin ? yMin : y;
 y = y<yMax ? yMax : y;

 this.imageX = x;
 this.imageY = y;

 this.imageEl.style.left = this.imageX+'px';
 this.imageEl.style.top = this.imageY+'px';

 return [x,y];
 }
}

/**************************** CONFIGURABLE PRODUCT **************************/
Product.Config = Class.create();
Product.Config.prototype = {
 initialize: function(config){
 this.config = config;
 this.settings = $$('.super-attribute-select');
 this.state = new Hash();
 this.priceTemplate = new Template(this.config.template);
 this.prices = config.prices;

 this.settings.each(function(element){
 Event.observe(element, 'change', this.configure.bind(this))
 }.bind(this));
 
 /* $$('.prueba').each(function(element){
 Event.observe(element, 'click', this.test.bind(this))
 }.bind(this)); 
*/
 // fill state
 this.settings.each(function(element){
 var attributeId = element.id.replace(/[a-z]*/, '');
 if(attributeId && this.config.attributes[attributeId]) {
 element.config = this.config.attributes[attributeId];
 element.attributeId = attributeId;
 this.state[attributeId] = false;
 }
 }.bind(this))

 // Init settings dropdown
 var childSettings = [];
 for(var i=this.settings.length-1;i>=0;i--){
 var prevSetting = this.settings[i-1] ? this.settings[i-1] : false;
 var nextSetting = this.settings[i+1] ? this.settings[i+1] : false;
 if(i==0){
 this.fillSelect(this.settings[i])
 }
 else {
 this.settings[i].disabled=true;
 }
 $(this.settings[i]).childSettings = childSettings.clone();
 $(this.settings[i]).prevSetting = prevSetting;
 $(this.settings[i]).nextSetting = nextSetting;
 childSettings.push(this.settings[i]);
 }

 // try retireve options from url
 var separatorIndex = window.location.href.indexOf('#');
 if (separatorIndex!=-1) {
 var paramsStr = window.location.href.substr(separatorIndex+1);
 this.values = paramsStr.toQueryParams();
 this.settings.each(function(element){
 var attributeId = element.attributeId;
 element.value = this.values[attributeId];
 this.configureElement(element);
 }.bind(this));
 }
 },

 configureColor: function(element){
 this.configureElement(element);
 },

 configure: function(event){
 var element = Event.element(event);
 this.configureElement(element);
 },

 configureElement : function(element) {
 this.reloadOptionLabels(element);
 if(element.value){
 this.state[element.config.id] = element.value;
 if(element.nextSetting){
 element.nextSetting.disabled = false;
 this.fillSelect(element.nextSetting);
 this.resetChildren(element.nextSetting);
 }
 }
 else {
 this.resetChildren(element);
 }
 this.reloadPrice();
// Calculator.updatePrice();
 },

 reloadOptionLabels: function(element){
 var selectedPrice;
 if(element.options[element.selectedIndex].config){
 selectedPrice = parseFloat(element.options[element.selectedIndex].config.price)
 }
 else{
 selectedPrice = 0;
 }
 for(var i=0;i<element.options.length;i++){
 if(element.options[i].config){
 element.options[i].text = this.getOptionLabel(element.options[i].config, element.options[i].config.price-selectedPrice);
 }
 }
 },

 resetChildren : function(element){
 if(element.childSettings) {
 for(var i=0;i<element.childSettings.length;i++){
 element.childSettings[i].selectedIndex = 0;
 element.childSettings[i].disabled = true;
 if(element.config){
 this.state[element.config.id] = false;
 }
 }
 }
 },

 fillSelect: function(element){
 var attributeId = element.id.replace(/[a-z]*/, '');
 var options = this.getAttributeOptions(attributeId);
 this.clearSelect(element);
 element.options[0] = new Option(this.config.chooseText, '');

 var prevConfig = false;
 if(element.prevSetting){
 prevConfig = element.prevSetting.options[element.prevSetting.selectedIndex];
 }

 if(options) {
 var index = 1;
 for(var i=0;i<options.length;i++){
 var allowedProducts = [];
 if(prevConfig) {
 for(var j=0;j<options[i].products.length;j++){
 if(prevConfig.config.allowedProducts
 && prevConfig.config.allowedProducts.indexOf(options[i].products[j])>-1){
 allowedProducts.push(options[i].products[j]);
 }
 }
 } else {
 allowedProducts = options[i].products.clone();
 }

 if(allowedProducts.size()>0){
 options[i].allowedProducts = allowedProducts;
 element.options[index] = new Option(this.getOptionLabel(options[i], options[i].price), options[i].id);
 element.options[index].config = options[i];
 index++;
 }
 }
 }
 },

 getOptionLabel: function(option, price){
 var price = parseFloat(price);
 var str = option.label;
 if(price){
 str+= ' (' + this.formatPrice(price, true) + ')';
 }
 return str;
 },

 formatPrice: function(price, showSign){
 var str = '';
 price = parseFloat(price);
 if(showSign){
 if(price<0){
 str+= '-';
 price = -price;
 }
 else{
 str+= '+';
 }
 }

 var roundedPrice = (Math.round(price*100)/100).toString();

 if (this.prices && this.prices[roundedPrice]) {
 str+= this.prices[roundedPrice];
 }
 else {
 str+= this.priceTemplate.evaluate({price:price.toFixed(2)});
 }
 return str;
 },

 clearSelect: function(element){
 for(var i=element.options.length-1;i>=0;i--){
 element.remove(i);
 }
 },

 getAttributeOptions: function(attributeId){
 if(this.config.attributes[attributeId]){
 return this.config.attributes[attributeId].options;
 }
 },

 reloadPrice: function(){
// var price = parseFloat(this.config.basePrice);
 var price = 0;
 for(var i=this.settings.length-1;i>=0;i--){
 var selected = this.settings[i].options[this.settings[i].selectedIndex];
 if(selected.config){
 price += parseFloat(selected.config.price);
 }
 }
 if (price < 0)
 price = 0;
// price = this.formatPrice(price);

 optionsPrice.changePrice('config', price);
 optionsPrice.reload();


 return price;

 if($('product-price-'+this.config.productId)){
 $('product-price-'+this.config.productId).innerHTML = price;
 }
 this.reloadOldPrice();
 },

 reloadOldPrice: function(){
 if ($('old-price-'+this.config.productId)) {

 var price = parseFloat(this.config.oldPrice);
 for(var i=this.settings.length-1;i>=0;i--){
 var selected = this.settings[i].options[this.settings[i].selectedIndex];
 if(selected.config){
 price+= parseFloat(selected.config.price);
 }
 }
 if (price < 0)
 price = 0;
 price = this.formatPrice(price);

 if($('old-price-'+this.config.productId)){
 $('old-price-'+this.config.productId).innerHTML = price;
 }

 }
 }
}


/**************************** SUPER PRODUCTS ********************************/

Product.Super = {};
Product.Super.Configurable = Class.create();

Product.Super.Configurable.prototype = {
 initialize: function(container, observeCss, updateUrl, updatePriceUrl, priceContainerId) {
 this.container = $(container);
 this.observeCss = observeCss;
 this.updateUrl = updateUrl;
 this.updatePriceUrl = updatePriceUrl;
 this.priceContainerId = priceContainerId;
 this.registerObservers();
 },
 registerObservers: function() {
 var elements = this.container.getElementsByClassName(this.observeCss);
 elements.each(function(element){
 Event.observe(element, 'change', this.update.bindAsEventListener(this));
 }.bind(this));
 return this;
 },
 update: function(event) {
 var elements = this.container.getElementsByClassName(this.observeCss);
 var parameters = Form.serializeElements(elements, true);

 new Ajax.Updater(this.container, this.updateUrl + '?ajax=1', {
 parameters:parameters,
 onComplete:this.registerObservers.bind(this)
 });
 var priceContainer = $(this.priceContainerId);
 if(priceContainer) {
 new Ajax.Updater(priceContainer, this.updatePriceUrl + '?ajax=1', {
 parameters:parameters
 });
 }
 }
}

/**************************** PRICE RELOADER ********************************/
Product.OptionsPrice = Class.create();
Product.OptionsPrice.prototype = {
 initialize: function(config) {
 this.productId = config.productId;
 this.priceFormat = config.priceFormat;
 this.includeTax = config.includeTax;
 this.defaultTax = config.defaultTax;
 this.currentTax = config.currentTax;
 this.productPrice = config.productPrice;
 this.showIncludeTax = config.showIncludeTax;
 this.productPrice = config.productPrice;
 this.skipCalculate = config.skipCalculate;
 this.duplicateIdSuffix = config.idSuffix;

 this.optionPrices = {};
 this.containers = {};

 this.initPrices();
 },

 setDuplicateIdSuffix: function(idSuffix) {
 this.duplicateIdSuffix = idSuffix;
 },

 initPrices: function() {
 this.containers[0] = 'product-price-' + this.productId;
 this.containers[1] = 'bundle-price-' + this.productId;
 this.containers[2] = 'price-including-tax-' + this.productId;
 this.containers[3] = 'price-excluding-tax-' + this.productId;
 },

 changePrice: function(key, price) {
 this.optionPrices[key] = parseFloat(price);
 },

 getOptionPrices: function() {
 var result = 0;
 $H(this.optionPrices).each(function(pair) {
 result += pair.value;
 });
 return result;
 },

 reload: function() {
 var price;
 var formattedPrice;
 var optionPrices = this.getOptionPrices();
 $H(this.containers).each(function(pair) {
 if ($(pair.value)) {

 var price = optionPrices+parseFloat(this.productPrice)
 if (this.includeTax == 'true') {
 // tax = tax included into product price by admin
 var tax = price / (100 + this.defaultTax) * this.defaultTax;
 var excl = price - tax;
 var incl = excl*(1+(this.currentTax/100));
 } else {
 var tax = price * (this.defaultTax / 100);
 var excl = price;
 var incl = excl + tax;
 }

 if (pair.value == 'price-including-tax-'+this.productId) {
 price = incl;
 } else {
 if (this.showIncludeTax) {
 price = incl;
 } else {
 if (!this.skipCalculate || this.productPrice == 0) {
 price = excl;
 } else {
 price = optionPrices+parseFloat(this.productPrice);
 }
 }
 }

 if (price < 0) price = 0;
 formattedPrice = this.formatPrice(price);
 if ($(pair.value).getElementsBySelector('.price')[0]) {
 $(pair.value).getElementsBySelector('.price')[0].innerHTML = formattedPrice;
 if ($(pair.value+this.duplicateIdSuffix) && $(pair.value+this.duplicateIdSuffix).getElementsBySelector('.price')[0]) {
 $(pair.value+this.duplicateIdSuffix).getElementsBySelector('.price')[0].innerHTML = formattedPrice;
 }
 } else {
 $(pair.value).innerHTML = formattedPrice;
 if ($(pair.value+this.duplicateIdSuffix)) {
 $(pair.value+this.duplicateIdSuffix).innerHTML = formattedPrice;
 }
 }
 };
 }.bind(this));
 },
 formatPrice: function(price) {
 return formatCurrency(price, this.priceFormat);
 }
}