// MooTools: the javascript framework. // Load this file's selection again by visiting: mootools.net/more/753e1dcb3f1fb4af9b29df94f0b458dd // Or build this file again with packager using: packager build More/More More/Class.Binds More/Chain.Wait More/Array.Extras More/Date More/Date.Extras More/Number.Format More/Object.Extras More/String.Extras More/String.QueryString More/URI More/URI.Relative More/Hash More/Hash.Extras More/Element.Pin More/Element.Position More/Form.Request More/OverText More/Fx.Elements More/Fx.Scroll More/Fx.Slide More/Fx.SmoothScroll More/Fx.Sort More/Drag More/Drag.Move More/Sortables More/Request.JSONP More/HtmlTable More/HtmlTable.Select


script: More.js

name: More

description: MooTools More

license: MIT-style license

authors:

- Guillermo Rauch
- Thomas Aylott
- Scott Kyle
- Arian Stolwijk
- Tim Wienk
- Christoph Pojer
- Aaron Newton
- Jacob Thornton

requires:

- Core/MooTools

provides: [MooTools.More]

MooTools.More = {

'version': '1.4.0.1',
'build': 'a4244edf2aa97ac8a196fc96082dd35af1abab87'

};


script: Class.Binds.js

name: Class.Binds

description: Automagically binds specified methods in a class to the instance of the class.

license: MIT-style license

authors:

- Aaron Newton

requires:

- Core/Class
- /MooTools.More

provides: [Class.Binds]

/

Class.Mutators.Binds = function(binds){

if (!this.prototype.initialize) this.implement('initialize', function(){});
return Array.from(binds).concat(this.prototype.Binds || []);

};

Class.Mutators.initialize = function(initialize){

return function(){
        Array.from(this.Binds).each(function(name){
                var original = this[name];
                if (original) this[name] = original.bind(this);
        }, this);
        return initialize.apply(this, arguments);
};

};

/*


script: Chain.Wait.js

name: Chain.Wait

description: value, Adds a method to inject pauses between chained events.

license: MIT-style license.

authors:

- Aaron Newton

requires:

- Core/Chain
- Core/Element
- Core/Fx
- /MooTools.More

provides: [Chain.Wait]

/

(function(){

var wait = {
        wait: function(duration){
                return this.chain(function(){
                        this.callChain.delay(duration == null ? 500 : duration, this);
                        return this;
                }.bind(this));
        }
};

Chain.implement(wait);

if (this.Fx) Fx.implement(wait);

if (this.Element && Element.implement && this.Fx){
        Element.implement({

                chains: function(effects){
                        Array.from(effects || ['tween', 'morph', 'reveal']).each(function(effect){
                                effect = this.get(effect);
                                if (!effect) return;
                                effect.setOptions({
                                        link:'chain'
                                });
                        }, this);
                        return this;
                },

                pauseFx: function(duration, effect){
                        this.chains(effect).get(effect || 'tween').wait(duration);
                        return this;
                }

        });
}

})();

/*


script: Array.Extras.js

name: Array.Extras

description: Extends the Array native object to include useful methods to work with arrays.

license: MIT-style license

authors:

- Christoph Pojer
- Sebastian Markbåge

requires:

- Core/Array
- MooTools.More

provides: [Array.Extras]

/

(function(nil){

Array.implement({

min: function(){
        return Math.min.apply(null, this);
},

max: function(){
        return Math.max.apply(null, this);
},

average: function(){
        return this.length ? this.sum() / this.length : 0;
},

sum: function(){
        var result = 0, l = this.length;
        if (l){
                while (l--) result += this[l];
        }
        return result;
},

unique: function(){
        return [].combine(this);
},

shuffle: function(){
        for (var i = this.length; i && --i;){
                var temp = this[i], r = Math.floor(Math.random() * ( i + 1 ));
                this[i] = this[r];
                this[r] = temp;
        }
        return this;
},

reduce: function(fn, value){
        for (var i = 0, l = this.length; i < l; i++){
                if (i in this) value = value === nil ? this[i] : fn.call(null, value, this[i], i, this);
        }
        return value;
},

reduceRight: function(fn, value){
        var i = this.length;
        while (i--){
                if (i in this) value = value === nil ? this[i] : fn.call(null, value, this[i], i, this);
        }
        return value;
}

});

})();

/*


script: Object.Extras.js

name: Object.Extras

description: Extra Object generics, like getFromPath which allows a path notation to child elements.

license: MIT-style license

authors:

- Aaron Newton

requires:

- Core/Object
- /MooTools.More

provides: [Object.Extras]

/

(function(){

var defined = function(value){

return value != null;

};

var hasOwnProperty = Object.prototype.hasOwnProperty;

Object.extend({

getFromPath: function(source, parts){
        if (typeof parts == 'string') parts = parts.split('.');
        for (var i = 0, l = parts.length; i < l; i++){
                if (hasOwnProperty.call(source, parts[i])) source = source[parts[i]];
                else return null;
        }
        return source;
},

cleanValues: function(object, method){
        method = method || defined;
        for (var key in object) if (!method(object[key])){
                delete object[key];
        }
        return object;
},

erase: function(object, key){
        if (hasOwnProperty.call(object, key)) delete object[key];
        return object;
},

run: function(object){
        var args = Array.slice(arguments, 1);
        for (var key in object) if (object[key].apply){
                object[key].apply(object, args);
        }
        return object;
}

});

})();

/*


script: Locale.js

name: Locale

description: Provides methods for localization.

license: MIT-style license

authors:

- Aaron Newton
- Arian Stolwijk

requires:

- Core/Events
- /Object.Extras
- /MooTools.More

provides: [Locale, Lang]

/

(function(){

var current = null,

locales = {},
inherits = {};

var getSet = function(set){

if (instanceOf(set, Locale.Set)) return set;
else return locales[set];

};

var Locale = this.Locale = {

define: function(locale, set, key, value){
        var name;
        if (instanceOf(locale, Locale.Set)){
                name = locale.name;
                if (name) locales[name] = locale;
        } else {
                name = locale;
                if (!locales[name]) locales[name] = new Locale.Set(name);
                locale = locales[name];
        }

        if (set) locale.define(set, key, value);

        /*<1.2compat>  
        if (set == 'cascade') return Locale.inherit(name, key);
        /*</1.2compat>*/

        if (!current) current = locale;

        return locale;
},

use: function(locale){
        locale = getSet(locale);

        if (locale){
                current = locale;

                this.fireEvent('change', locale);

                /*<1.2compat>*/
                this.fireEvent('langChange', locale.name);
                /*</1.2compat>*/
        }

        return this;
},

getCurrent: function(){
        return current;
},

get: function(key, args){
        return (current) ? current.get(key, args) : '';
},

inherit: function(locale, inherits, set){
        locale = getSet(locale);

        if (locale) locale.inherit(inherits, set);
        return this;
},

list: function(){
        return Object.keys(locales);
}

};

Object.append(Locale, new Events);

Locale.Set = new Class({

sets: {},

inherits: {
        locales: [],
        sets: {}
},

initialize: function(name){
        this.name = name || '';
},

define: function(set, key, value){
        var defineData = this.sets[set];
        if (!defineData) defineData = {};

        if (key){
                if (typeOf(key) == 'object') defineData = Object.merge(defineData, key);
                else defineData[key] = value;
        }
        this.sets[set] = defineData;

        return this;
},

get: function(key, args, _base){
        var value = Object.getFromPath(this.sets, key);
        if (value != null){
                var type = typeOf(value);
                if (type == 'function') value = value.apply(null, Array.from(args));
                else if (type == 'object') value = Object.clone(value);
                return value;
        }

        // get value of inherited locales
        var index = key.indexOf('.'),
                set = index < 0 ? key : key.substr(0, index),
                names = (this.inherits.sets[set] || []).combine(this.inherits.locales).include('en-US');
        if (!_base) _base = [];

        for (var i = 0, l = names.length; i < l; i++){
                if (_base.contains(names[i])) continue;
                _base.include(names[i]);

                var locale = locales[names[i]];
                if (!locale) continue;

                value = locale.get(key, args, _base);
                if (value != null) return value;
        }

        return '';
},

inherit: function(names, set){
        names = Array.from(names);

        if (set && !this.inherits.sets[set]) this.inherits.sets[set] = [];

        var l = names.length;
        while (l--) (set ? this.inherits.sets[set] : this.inherits.locales).unshift(names[l]);

        return this;
}

});

/*<1.2compat>*/ var lang = MooTools.lang = {};

Object.append(lang, Locale, {

setLanguage: Locale.use,
getCurrentLanguage: function(){
        var current = Locale.getCurrent();
        return (current) ? current.name : null;
},
set: function(){
        Locale.define.apply(this, arguments);
        return this;
},
get: function(set, key, args){
        if (key) set += '.' + key;
        return Locale.get(set, args);
}

}); /*</1.2compat>*/

})();

/*


name: Locale.en-US.Date

description: Date messages for US English.

license: MIT-style license

authors:

- Aaron Newton

requires:

- /Locale

provides: [Locale.en-US.Date]

/

Locale.define('en-US', 'Date', {

months: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
months_abbr: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
days: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
days_abbr: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],

// Culture's date order: MM/DD/YYYY
dateOrder: ['month', 'date', 'year'],
shortDate: '%m/%d/%Y',
shortTime: '%I:%M%p',
AM: 'AM',
PM: 'PM',
firstDayOfWeek: 0,

// Date.Extras
ordinal: function(dayOfMonth){
        // 1st, 2nd, 3rd, etc.
        return (dayOfMonth > 3 && dayOfMonth < 21) ? 'th' : ['th', 'st', 'nd', 'rd', 'th'][Math.min(dayOfMonth % 10, 4)];
},

lessThanMinuteAgo: 'less than a minute ago',
minuteAgo: 'about a minute ago',
minutesAgo: '{delta} minutes ago',
hourAgo: 'about an hour ago',
hoursAgo: 'about {delta} hours ago',
dayAgo: '1 day ago',
daysAgo: '{delta} days ago',
weekAgo: '1 week ago',
weeksAgo: '{delta} weeks ago',
monthAgo: '1 month ago',
monthsAgo: '{delta} months ago',
yearAgo: '1 year ago',
yearsAgo: '{delta} years ago',

lessThanMinuteUntil: 'less than a minute from now',
minuteUntil: 'about a minute from now',
minutesUntil: '{delta} minutes from now',
hourUntil: 'about an hour from now',
hoursUntil: 'about {delta} hours from now',
dayUntil: '1 day from now',
daysUntil: '{delta} days from now',
weekUntil: '1 week from now',
weeksUntil: '{delta} weeks from now',
monthUntil: '1 month from now',
monthsUntil: '{delta} months from now',
yearUntil: '1 year from now',
yearsUntil: '{delta} years from now'

});

/*


script: Date.js

name: Date

description: Extends the Date native object to include methods useful in managing dates.

license: MIT-style license

authors:

- Aaron Newton
- Nicholas Barthelemy - https://svn.nbarthelemy.com/date-js/
- Harald Kirshner - mail [at] digitarald.de; http://digitarald.de
- Scott Kyle - scott [at] appden.com; http://appden.com

requires:

- Core/Array
- Core/String
- Core/Number
- MooTools.More
- Locale
- Locale.en-US.Date

provides: [Date]

/

(function(){

var Date = this.Date;

var DateMethods = Date.Methods = {

ms: 'Milliseconds',
year: 'FullYear',
min: 'Minutes',
mo: 'Month',
sec: 'Seconds',
hr: 'Hours'

};

['Date', 'Day', 'FullYear', 'Hours', 'Milliseconds', 'Minutes', 'Month', 'Seconds', 'Time', 'TimezoneOffset',

'Week', 'Timezone', 'GMTOffset', 'DayOfYear', 'LastMonth', 'LastDayOfMonth', 'UTCDate', 'UTCDay', 'UTCFullYear',
'AMPM', 'Ordinal', 'UTCHours', 'UTCMilliseconds', 'UTCMinutes', 'UTCMonth', 'UTCSeconds', 'UTCMilliseconds'].each(function(method){
Date.Methods[method.toLowerCase()] = method;

});

var pad = function(n, digits, string){

if (digits == 1) return n;
return n < Math.pow(10, digits - 1) ? (string || '0') + pad(n, digits - 1, string) : n;

};

Date.implement({

set: function(prop, value){
        prop = prop.toLowerCase();
        var method = DateMethods[prop] && 'set' + DateMethods[prop];
        if (method && this[method]) this[method](value);
        return this;
}.overloadSetter(),

get: function(prop){
        prop = prop.toLowerCase();
        var method = DateMethods[prop] && 'get' + DateMethods[prop];
        if (method && this[method]) return this[method]();
        return null;
}.overloadGetter(),

clone: function(){
        return new Date(this.get('time'));
},

increment: function(interval, times){
        interval = interval || 'day';
        times = times != null ? times : 1;

        switch (interval){
                case 'year':
                        return this.increment('month', times * 12);
                case 'month':
                        var d = this.get('date');
                        this.set('date', 1).set('mo', this.get('mo') + times);
                        return this.set('date', d.min(this.get('lastdayofmonth')));
                case 'week':
                        return this.increment('day', times * 7);
                case 'day':
                        return this.set('date', this.get('date') + times);
        }

        if (!Date.units[interval]) throw new Error(interval + ' is not a supported interval');

        return this.set('time', this.get('time') + times * Date.units[interval]());
},

decrement: function(interval, times){
        return this.increment(interval, -1 * (times != null ? times : 1));
},

isLeapYear: function(){
        return Date.isLeapYear(this.get('year'));
},

clearTime: function(){
        return this.set({hr: 0, min: 0, sec: 0, ms: 0});
},

diff: function(date, resolution){
        if (typeOf(date) == 'string') date = Date.parse(date);

        return ((date - this) / Date.units[resolution || 'day'](3, 3)).round(); // non-leap year, 30-day month
},

getLastDayOfMonth: function(){
        return Date.daysInMonth(this.get('mo'), this.get('year'));
},

getDayOfYear: function(){
        return (Date.UTC(this.get('year'), this.get('mo'), this.get('date') + 1)
                - Date.UTC(this.get('year'), 0, 1)) / Date.units.day();
},

setDay: function(day, firstDayOfWeek){
        if (firstDayOfWeek == null){
                firstDayOfWeek = Date.getMsg('firstDayOfWeek');
                if (firstDayOfWeek === '') firstDayOfWeek = 1;
        }

        day = (7 + Date.parseDay(day, true) - firstDayOfWeek) % 7;
        var currentDay = (7 + this.get('day') - firstDayOfWeek) % 7;

        return this.increment('day', day - currentDay);
},

getWeek: function(firstDayOfWeek){
        if (firstDayOfWeek == null){
                firstDayOfWeek = Date.getMsg('firstDayOfWeek');
                if (firstDayOfWeek === '') firstDayOfWeek = 1;
        }

        var date = this,
                dayOfWeek = (7 + date.get('day') - firstDayOfWeek) % 7,
                dividend = 0,
                firstDayOfYear;

        if (firstDayOfWeek == 1){
                // ISO-8601, week belongs to year that has the most days of the week (i.e. has the thursday of the week)
                var month = date.get('month'),
                        startOfWeek = date.get('date') - dayOfWeek;

                if (month == 11 && startOfWeek > 28) return 1; // Week 1 of next year

                if (month == 0 && startOfWeek < -2){
                        // Use a date from last year to determine the week
                        date = new Date(date).decrement('day', dayOfWeek);
                        dayOfWeek = 0;
                }

                firstDayOfYear = new Date(date.get('year'), 0, 1).get('day') || 7;
                if (firstDayOfYear > 4) dividend = -7; // First week of the year is not week 1
        } else {
                // In other cultures the first week of the year is always week 1 and the last week always 53 or 54.
                // Days in the same week can have a different weeknumber if the week spreads across two years.
                firstDayOfYear = new Date(date.get('year'), 0, 1).get('day');
        }

        dividend += date.get('dayofyear');
        dividend += 6 - dayOfWeek; // Add days so we calculate the current date's week as a full week
        dividend += (7 + firstDayOfYear - firstDayOfWeek) % 7; // Make up for first week of the year not being a full week

        return (dividend / 7);
},

getOrdinal: function(day){
        return Date.getMsg('ordinal', day || this.get('date'));
},

getTimezone: function(){
        return this.toString()
                .replace(/^.*? ([A-Z]{3}).[0-9]{4}.*$/, '$1')
                .replace(/^.*?\(([A-Z])[a-z]+ ([A-Z])[a-z]+ ([A-Z])[a-z]+\)$/, '$1$2$3');
},

getGMTOffset: function(){
        var off = this.get('timezoneOffset');
        return ((off > 0) ? '-' : '+') + pad((off.abs() / 60).floor(), 2) + pad(off % 60, 2);
},

setAMPM: function(ampm){
        ampm = ampm.toUpperCase();
        var hr = this.get('hr');
        if (hr > 11 && ampm == 'AM') return this.decrement('hour', 12);
        else if (hr < 12 && ampm == 'PM') return this.increment('hour', 12);
        return this;
},

getAMPM: function(){
        return (this.get('hr') < 12) ? 'AM' : 'PM';
},

parse: function(str){
        this.set('time', Date.parse(str));
        return this;
},

isValid: function(date){
        if (!date) date = this;
        return typeOf(date) == 'date' && !isNaN(date.valueOf());
},

format: function(format){
        if (!this.isValid()) return 'invalid date';

        if (!format) format = '%x %X';
        if (typeof format == 'string') format = formats[format.toLowerCase()] || format;
        if (typeof format == 'function') return format(this);

        var d = this;
        return format.replace(/%([a-z%])/gi,
                function($0, $1){
                        switch ($1){
                                case 'a': return Date.getMsg('days_abbr')[d.get('day')];
                                case 'A': return Date.getMsg('days')[d.get('day')];
                                case 'b': return Date.getMsg('months_abbr')[d.get('month')];
                                case 'B': return Date.getMsg('months')[d.get('month')];
                                case 'c': return d.format('%a %b %d %H:%M:%S %Y');
                                case 'd': return pad(d.get('date'), 2);
                                case 'e': return pad(d.get('date'), 2, ' ');
                                case 'H': return pad(d.get('hr'), 2);
                                case 'I': return pad((d.get('hr') % 12) || 12, 2);
                                case 'j': return pad(d.get('dayofyear'), 3);
                                case 'k': return pad(d.get('hr'), 2, ' ');
                                case 'l': return pad((d.get('hr') % 12) || 12, 2, ' ');
                                case 'L': return pad(d.get('ms'), 3);
                                case 'm': return pad((d.get('mo') + 1), 2);
                                case 'M': return pad(d.get('min'), 2);
                                case 'o': return d.get('ordinal');
                                case 'p': return Date.getMsg(d.get('ampm'));
                                case 's': return Math.round(d / 1000);
                                case 'S': return pad(d.get('seconds'), 2);
                                case 'T': return d.format('%H:%M:%S');
                                case 'U': return pad(d.get('week'), 2);
                                case 'w': return d.get('day');
                                case 'x': return d.format(Date.getMsg('shortDate'));
                                case 'X': return d.format(Date.getMsg('shortTime'));
                                case 'y': return d.get('year').toString().substr(2);
                                case 'Y': return d.get('year');
                                case 'z': return d.get('GMTOffset');
                                case 'Z': return d.get('Timezone');
                        }
                        return $1;
                }
        );
},

toISOString: function(){
        return this.format('iso8601');
}

}).alias({

toJSON: 'toISOString',
compare: 'diff',
strftime: 'format'

});

// The day and month abbreviations are standardized, so we cannot use simply %a and %b because they will get localized var rfcDayAbbr = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],

rfcMonthAbbr = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];

var formats = {

db: '%Y-%m-%d %H:%M:%S',
compact: '%Y%m%dT%H%M%S',
'short': '%d %b %H:%M',
'long': '%B %d, %Y %H:%M',
rfc822: function(date){
        return rfcDayAbbr[date.get('day')] + date.format(', %d ') + rfcMonthAbbr[date.get('month')] + date.format(' %Y %H:%M:%S %Z');
},
rfc2822: function(date){
        return rfcDayAbbr[date.get('day')] + date.format(', %d ') + rfcMonthAbbr[date.get('month')] + date.format(' %Y %H:%M:%S %z');
},
iso8601: function(date){
        return (
                date.getUTCFullYear() + '-' +
                pad(date.getUTCMonth() + 1, 2) + '-' +
                pad(date.getUTCDate(), 2) + 'T' +
                pad(date.getUTCHours(), 2) + ':' +
                pad(date.getUTCMinutes(), 2) + ':' +
                pad(date.getUTCSeconds(), 2) + '.' +
                pad(date.getUTCMilliseconds(), 3) + 'Z'
        );
}

};

var parsePatterns = [],

nativeParse = Date.parse;

var parseWord = function(type, word, num){

var ret = -1,
        translated = Date.getMsg(type + 's');
switch (typeOf(word)){
        case 'object':
                ret = translated[word.get(type)];
                break;
        case 'number':
                ret = translated[word];
                if (!ret) throw new Error('Invalid ' + type + ' index: ' + word);
                break;
        case 'string':
                var match = translated.filter(function(name){
                        return this.test(name);
                }, new RegExp('^' + word, 'i'));
                if (!match.length) throw new Error('Invalid ' + type + ' string');
                if (match.length > 1) throw new Error('Ambiguous ' + type);
                ret = match[0];
}

return (num) ? translated.indexOf(ret) : ret;

};

var startCentury = 1900,

startYear = 70;

Date.extend({

getMsg: function(key, args){
        return Locale.get('Date.' + key, args);
},

units: {
        ms: Function.from(1),
        second: Function.from(1000),
        minute: Function.from(60000),
        hour: Function.from(3600000),
        day: Function.from(86400000),
        week: Function.from(608400000),
        month: function(month, year){
                var d = new Date;
                return Date.daysInMonth(month != null ? month : d.get('mo'), year != null ? year : d.get('year')) * 86400000;
        },
        year: function(year){
                year = year || new Date().get('year');
                return Date.isLeapYear(year) ? 31622400000 : 31536000000;
        }
},

daysInMonth: function(month, year){
        return [31, Date.isLeapYear(year) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month];
},

isLeapYear: function(year){
        return ((year % 4 === 0) && (year % 100 !== 0)) || (year % 400 === 0);
},

parse: function(from){
        var t = typeOf(from);
        if (t == 'number') return new Date(from);
        if (t != 'string') return from;
        from = from.clean();
        if (!from.length) return null;

        var parsed;
        parsePatterns.some(function(pattern){
                var bits = pattern.re.exec(from);
                return (bits) ? (parsed = pattern.handler(bits)) : false;
        });

        if (!(parsed && parsed.isValid())){
                parsed = new Date(nativeParse(from));
                if (!(parsed && parsed.isValid())) parsed = new Date(from.toInt());
        }
        return parsed;
},

parseDay: function(day, num){
        return parseWord('day', day, num);
},

parseMonth: function(month, num){
        return parseWord('month', month, num);
},

parseUTC: function(value){
        var localDate = new Date(value);
        var utcSeconds = Date.UTC(
                localDate.get('year'),
                localDate.get('mo'),
                localDate.get('date'),
                localDate.get('hr'),
                localDate.get('min'),
                localDate.get('sec'),
                localDate.get('ms')
        );
        return new Date(utcSeconds);
},

orderIndex: function(unit){
        return Date.getMsg('dateOrder').indexOf(unit) + 1;
},

defineFormat: function(name, format){
        formats[name] = format;
        return this;
},

//<1.2compat>
parsePatterns: parsePatterns,
//</1.2compat>

defineParser: function(pattern){
        parsePatterns.push((pattern.re && pattern.handler) ? pattern : build(pattern));
        return this;
},

defineParsers: function(){
        Array.flatten(arguments).each(Date.defineParser);
        return this;
},

define2DigitYearStart: function(year){
        startYear = year % 100;
        startCentury = year - startYear;
        return this;
}

}).extend({

defineFormats: Date.defineFormat.overloadSetter()

});

var regexOf = function(type){

return new RegExp('(?:' + Date.getMsg(type).map(function(name){
        return name.substr(0, 3);
}).join('|') + ')[a-z]*');

};

var replacers = function(key){

switch (key){
        case 'T':
                return '%H:%M:%S';
        case 'x': // iso8601 covers yyyy-mm-dd, so just check if month is first
                return ((Date.orderIndex('month') == 1) ? '%m[-./]%d' : '%d[-./]%m') + '([-./]%y)?';
        case 'X':
                return '%H([.:]%M)?([.:]%S([.:]%s)?)? ?%p? ?%z?';
}
return null;

};

var keys = {

d: /[0-2]?[0-9]|3[01]/,
H: /[01]?[0-9]|2[0-3]/,
I: /0?[1-9]|1[0-2]/,
M: /[0-5]?\d/,
s: /\d+/,
o: /[a-z]*/,
p: /[ap]\.?m\.?/,
y: /\d{2}|\d{4}/,
Y: /\d{4}/,
z: /Z|[+-]\d{2}(?::?\d{2})?/

};

keys.m = keys.I; keys.S = keys.M;

var currentLanguage;

var recompile = function(language){

currentLanguage = language;

keys.a = keys.A = regexOf('days');
keys.b = keys.B = regexOf('months');

parsePatterns.each(function(pattern, i){
        if (pattern.format) parsePatterns[i] = build(pattern.format);
});

};

var build = function(format){

if (!currentLanguage) return {format: format};

var parsed = [];
var re = (format.source || format) // allow format to be regex
 .replace(/%([a-z])/gi,
        function($0, $1){
                return replacers($1) || $0;
        }
).replace(/\((?!\?)/g, '(?:') // make all groups non-capturing
 .replace(/ (?!\?|\*)/g, ',? ') // be forgiving with spaces and commas
 .replace(/%([a-z%])/gi,
        function($0, $1){
                var p = keys[$1];
                if (!p) return $1;
                parsed.push($1);
                return '(' + p.source + ')';
        }
).replace(/\[a-z\]/gi, '[a-z\\u00c0-\\uffff;\&]'); // handle unicode words

return {
        format: format,
        re: new RegExp('^' + re + '$', 'i'),
        handler: function(bits){
                bits = bits.slice(1).associate(parsed);
                var date = new Date().clearTime(),
                        year = bits.y || bits.Y;

                if (year != null) handle.call(date, 'y', year); // need to start in the right year
                if ('d' in bits) handle.call(date, 'd', 1);
                if ('m' in bits || bits.b || bits.B) handle.call(date, 'm', 1);

                for (var key in bits) handle.call(date, key, bits[key]);
                return date;
        }
};

};

var handle = function(key, value){

if (!value) return this;

switch (key){
        case 'a': case 'A': return this.set('day', Date.parseDay(value, true));
        case 'b': case 'B': return this.set('mo', Date.parseMonth(value, true));
        case 'd': return this.set('date', value);
        case 'H': case 'I': return this.set('hr', value);
        case 'm': return this.set('mo', value - 1);
        case 'M': return this.set('min', value);
        case 'p': return this.set('ampm', value.replace(/\./g, ''));
        case 'S': return this.set('sec', value);
        case 's': return this.set('ms', ('0.' + value) * 1000);
        case 'w': return this.set('day', value);
        case 'Y': return this.set('year', value);
        case 'y':
                value = +value;
                if (value < 100) value += startCentury + (value < startYear ? 100 : 0);
                return this.set('year', value);
        case 'z':
                if (value == 'Z') value = '+00';
                var offset = value.match(/([+-])(\d{2}):?(\d{2})?/);
                offset = (offset[1] + '1') * (offset[2] * 60 + (+offset[3] || 0)) + this.getTimezoneOffset();
                return this.set('time', this - offset * 60000);
}

return this;

};

Date.defineParsers(

'%Y([-./]%m([-./]%d((T| )%X)?)?)?', // "1999-12-31", "1999-12-31 11:59pm", "1999-12-31 23:59:59", ISO8601
'%Y%m%d(T%H(%M%S?)?)?', // "19991231", "19991231T1159", compact
'%x( %X)?', // "12/31", "12.31.99", "12-31-1999", "12/31/2008 11:59 PM"
'%d%o( %b( %Y)?)?( %X)?', // "31st", "31st December", "31 Dec 1999", "31 Dec 1999 11:59pm"
'%b( %d%o)?( %Y)?( %X)?', // Same as above with month and day switched
'%Y %b( %d%o( %X)?)?', // Same as above with year coming first
'%o %b %d %X %z %Y', // "Thu Oct 22 08:11:23 +0000 2009"
'%T', // %H:%M:%S
'%H:%M( ?%p)?' // "11:05pm", "11:05 am" and "11:05"

);

Locale.addEvent('change', function(language){

if (Locale.get('Date')) recompile(language);

}).fireEvent('change', Locale.getCurrent());

})();

/*


script: Date.Extras.js

name: Date.Extras

description: Extends the Date native object to include extra methods (on top of those in Date.js).

license: MIT-style license

authors:

- Aaron Newton
- Scott Kyle

requires:

- /Date

provides: [Date.Extras]

/

Date.implement({

timeDiffInWords: function(to){
        return Date.distanceOfTimeInWords(this, to || new Date);
},

timeDiff: function(to, separator){
        if (to == null) to = new Date;
        var delta = ((to - this) / 1000).floor().abs();

        var vals = [],
                durations = [60, 60, 24, 365, 0],
                names = ['s', 'm', 'h', 'd', 'y'],
                value, duration;

        for (var item = 0; item < durations.length; item++){
                if (item && !delta) break;
                value = delta;
                if ((duration = durations[item])){
                        value = (delta % duration);
                        delta = (delta / duration).floor();
                }
                vals.unshift(value + (names[item] || ''));
        }

        return vals.join(separator || ':');
}

}).extend({

distanceOfTimeInWords: function(from, to){
        return Date.getTimePhrase(((to - from) / 1000).toInt());
},

getTimePhrase: function(delta){
        var suffix = (delta < 0) ? 'Until' : 'Ago';
        if (delta < 0) delta *= -1;

        var units = {
                minute: 60,
                hour: 60,
                day: 24,
                week: 7,
                month: 52 / 12,
                year: 12,
                eon: Infinity
        };

        var msg = 'lessThanMinute';

        for (var unit in units){
                var interval = units[unit];
                if (delta < 1.5 * interval){
                        if (delta > 0.75 * interval) msg = unit;
                        break;
                }
                delta /= interval;
                msg = unit + 's';
        }

        delta = delta.round();
        return Date.getMsg(msg + suffix, delta).substitute({delta: delta});
}

}).defineParsers(

{
        // "today", "tomorrow", "yesterday"
        re: /^(?:tod|tom|yes)/i,
        handler: function(bits){
                var d = new Date().clearTime();
                switch (bits[0]){
                        case 'tom': return d.increment();
                        case 'yes': return d.decrement();
                        default: return d;
                }
        }
},

{
        // "next Wednesday", "last Thursday"
        re: /^(next|last) ([a-z]+)$/i,
        handler: function(bits){
                var d = new Date().clearTime();
                var day = d.getDay();
                var newDay = Date.parseDay(bits[2], true);
                var addDays = newDay - day;
                if (newDay <= day) addDays += 7;
                if (bits[1] == 'last') addDays -= 7;
                return d.set('date', d.getDate() + addDays);
        }
}

).alias('timeAgoInWords', 'timeDiffInWords');

/*


name: Locale.en-US.Number

description: Number messages for US English.

license: MIT-style license

authors:

- Arian Stolwijk

requires:

- /Locale

provides: [Locale.en-US.Number]

/

Locale.define('en-US', 'Number', {

decimal: '.',
group: ',',

/* Commented properties are the defaults for Number.format

decimals: 0,
precision: 0,
scientific: null,

prefix: null,
suffic: null,

// Negative/Currency/percentage will mixin Number
negative: {
        prefix: '-'
},*/

currency: {

// decimals: 2,

        prefix: '$ '
}/*,

percentage: {
        decimals: 2,
        suffix: '%'
}*/

});

/*


name: Number.Format description: Extends the Number Type object to include a number formatting method. license: MIT-style license authors: [Arian Stolwijk] requires: [Core/Number, Locale.en-US.Number] # Number.Extras is for compatibility provides: [Number.Format, Number.Extras] …

/

Number.implement({

format: function(options){
        // Thanks dojo and YUI for some inspiration
        var value = this;
        options = options ? Object.clone(options) : {};
        var getOption = function(key){
                if (options[key] != null) return options[key];
                return Locale.get('Number.' + key);
        };

        var negative = value < 0,
                decimal = getOption('decimal'),
                precision = getOption('precision'),
                group = getOption('group'),
                decimals = getOption('decimals');

        if (negative){
                var negativeLocale = getOption('negative') || {};
                if (negativeLocale.prefix == null && negativeLocale.suffix == null) negativeLocale.prefix = '-';
                ['prefix', 'suffix'].each(function(key){
                        if (negativeLocale[key]) options[key] = getOption(key) + negativeLocale[key];
                });

                value = -value;
        }

        var prefix = getOption('prefix'),
                suffix = getOption('suffix');

        if (decimals !== '' && decimals >= 0 && decimals <= 20) value = value.toFixed(decimals);
        if (precision >= 1 && precision <= 21) value = (+value).toPrecision(precision);

        value += '';
        var index;
        if (getOption('scientific') === false && value.indexOf('e') > -1){
                var match = value.split('e'),
                        zeros = +match[1];
                value = match[0].replace('.', '');

                if (zeros < 0){
                        zeros = -zeros - 1;
                        index = match[0].indexOf('.');
                        if (index > -1) zeros -= index - 1;
                        while (zeros--) value = '0' + value;
                        value = '0.' + value;
                } else {
                        index = match[0].lastIndexOf('.');
                        if (index > -1) zeros -= match[0].length - index - 1;
                        while (zeros--) value += '0';
                }
        }

        if (decimal != '.') value = value.replace('.', decimal);

        if (group){
                index = value.lastIndexOf(decimal);
                index = (index > -1) ? index : value.length;
                var newOutput = value.substring(index),
                        i = index;

                while (i--){
                        if ((index - i - 1) % 3 == 0 && i != (index - 1)) newOutput = group + newOutput;
                        newOutput = value.charAt(i) + newOutput;
                }

                value = newOutput;
        }

        if (prefix) value = prefix + value;
        if (suffix) value += suffix;

        return value;
},

formatCurrency: function(decimals){
        var locale = Locale.get('Number.currency') || {};
        if (locale.scientific == null) locale.scientific = false;
        locale.decimals = decimals != null ? decimals
                : (locale.decimals == null ? 2 : locale.decimals);

        return this.format(locale);
},

formatPercentage: function(decimals){
        var locale = Locale.get('Number.percentage') || {};
        if (locale.suffix == null) locale.suffix = '%';
        locale.decimals = decimals != null ? decimals
                : (locale.decimals == null ? 2 : locale.decimals);

        return this.format(locale);
}

});

/*


script: String.Extras.js

name: String.Extras

description: Extends the String native object to include methods useful in managing various kinds of strings (query strings, urls, html, etc).

license: MIT-style license

authors:

- Aaron Newton
- Guillermo Rauch
- Christopher Pitt

requires:

- Core/String
- Core/Array
- MooTools.More

provides: [String.Extras]

/

(function(){

var special = {

'a': /[àáâãäåăą]/g,
'A': /[ÀÁÂÃÄÅĂĄ]/g,
'c': /[ćčç]/g,
'C': /[ĆČÇ]/g,
'd': /[ďđ]/g,
'D': /[ĎÐ]/g,
'e': /[èéêëěę]/g,
'E': /[ÈÉÊËĚĘ]/g,
'g': /[ğ]/g,
'G': /[Ğ]/g,
'i': /[ìíîï]/g,
'I': /[ÌÍÎÏ]/g,
'l': /[ĺľł]/g,
'L': /[ĹĽŁ]/g,
'n': /[ñňń]/g,
'N': /[ÑŇŃ]/g,
'o': /[òóôõöøő]/g,
'O': /[ÒÓÔÕÖØ]/g,
'r': /[řŕ]/g,
'R': /[ŘŔ]/g,
's': /[ššş]/g,
'S': /[ŠŞŚ]/g,
't': /[ťţ]/g,
'T': /[ŤŢ]/g,
'ue': /[ü]/g,
'UE': /[Ü]/g,
'u': /[ùúûůµ]/g,
'U': /[ÙÚÛŮ]/g,
'y': /[ÿý]/g,
'Y': /[ŸÝ]/g,
'z': /[žźż]/g,
'Z': /[ŽŹŻ]/g,
'th': /[þ]/g,
'TH': /[Þ]/g,
'dh': /[ð]/g,
'DH': /[Ð]/g,
'ss': /[ß]/g,
'oe': /[œ]/g,
'OE': /[Œ]/g,
'ae': /[æ]/g,
'AE': /[Æ]/g

},

tidy = {

' ': /[\xa0\u2002\u2003\u2009]/g,
'*': /[\xb7]/g,
'\'': /[\u2018\u2019]/g,
'"': /[\u201c\u201d]/g,
'...': /[\u2026]/g,
'-': /[\u2013]/g,

// '–': /[u2014]/g,

'&raquo;': /[\uFFFD]/g

};

var walk = function(string, replacements){

var result = string, key;
for (key in replacements) result = result.replace(replacements[key], key);
return result;

};

var getRegexForTag = function(tag, contents){

tag = tag || '';
var regstr = contents ? "<" + tag + "(?!\\w)[^>]*>([\\s\\S]*?)<\/" + tag + "(?!\\w)>" : "<\/?" + tag + "([^>]+)?>",
        reg = new RegExp(regstr, "gi");
return reg;

};

String.implement({

standardize: function(){
        return walk(this, special);
},

repeat: function(times){
        return new Array(times + 1).join(this);
},

pad: function(length, str, direction){
        if (this.length >= length) return this;

        var pad = (str == null ? ' ' : '' + str)
                .repeat(length - this.length)
                .substr(0, length - this.length);

        if (!direction || direction == 'right') return this + pad;
        if (direction == 'left') return pad + this;

        return pad.substr(0, (pad.length / 2).floor()) + this + pad.substr(0, (pad.length / 2).ceil());
},

getTags: function(tag, contents){
        return this.match(getRegexForTag(tag, contents)) || [];
},

stripTags: function(tag, contents){
        return this.replace(getRegexForTag(tag, contents), '');
},

tidy: function(){
        return walk(this, tidy);
},

truncate: function(max, trail, atChar){
        var string = this;
        if (trail == null && arguments.length == 1) trail = '…';
        if (string.length > max){
                string = string.substring(0, max);
                if (atChar){
                        var index = string.lastIndexOf(atChar);
                        if (index != -1) string = string.substr(0, index);
                }
                if (trail) string += trail;
        }
        return string;
}

});

})();

/*


script: String.QueryString.js

name: String.QueryString

description: Methods for dealing with URI query strings.

license: MIT-style license

authors:

- Sebastian Markbåge
- Aaron Newton
- Lennart Pilon
- Valerio Proietti

requires:

- Core/Array
- Core/String
- /MooTools.More

provides: [String.QueryString]

/

String.implement({

parseQueryString: function(decodeKeys, decodeValues){
        if (decodeKeys == null) decodeKeys = true;
        if (decodeValues == null) decodeValues = true;

        var vars = this.split(/[&;]/),
                object = {};
        if (!vars.length) return object;

        vars.each(function(val){
                var index = val.indexOf('=') + 1,
                        value = index ? val.substr(index) : '',
                        keys = index ? val.substr(0, index - 1).match(/([^\]\[]+|(\B)(?=\]))/g) : [val],
                        obj = object;
                if (!keys) return;
                if (decodeValues) value = decodeURIComponent(value);
                keys.each(function(key, i){
                        if (decodeKeys) key = decodeURIComponent(key);
                        var current = obj[key];

                        if (i < keys.length - 1) obj = obj[key] = current || {};
                        else if (typeOf(current) == 'array') current.push(value);
                        else obj[key] = current != null ? [current, value] : value;
                });
        });

        return object;
},

cleanQueryString: function(method){
        return this.split('&').filter(function(val){
                var index = val.indexOf('='),
                        key = index < 0 ? '' : val.substr(0, index),
                        value = val.substr(index + 1);

                return method ? method.call(null, key, value) : (value || value === 0);
        }).join('&');
}

});

/*


script: URI.js

name: URI

description: Provides methods useful in managing the window location and uris.

license: MIT-style license

authors:

- Sebastian Markbåge
- Aaron Newton

requires:

- Core/Object
- Core/Class
- Core/Class.Extras
- Core/Element
- /String.QueryString

provides: [URI]

/

(function(){

var toString = function(){

return this.get('value');

};

var URI = this.URI = new Class({

Implements: Options,

options: {
        /*base: false*/
},

regex: /^(?:(\w+):)?(?:\/\/(?:(?:([^:@\/]*):?([^:@\/]*))?@)?([^:\/?#]*)(?::(\d*))?)?(\.\.?$|(?:[^?#\/]*\/)*)([^?#]*)(?:\?([^#]*))?(?:#(.*))?/,
parts: ['scheme', 'user', 'password', 'host', 'port', 'directory', 'file', 'query', 'fragment'],
schemes: {http: 80, https: 443, ftp: 21, rtsp: 554, mms: 1755, file: 0},

initialize: function(uri, options){
        this.setOptions(options);
        var base = this.options.base || URI.base;
        if (!uri) uri = base;

        if (uri && uri.parsed) this.parsed = Object.clone(uri.parsed);
        else this.set('value', uri.href || uri.toString(), base ? new URI(base) : false);
},

parse: function(value, base){
        var bits = value.match(this.regex);
        if (!bits) return false;
        bits.shift();
        return this.merge(bits.associate(this.parts), base);
},

merge: function(bits, base){
        if ((!bits || !bits.scheme) && (!base || !base.scheme)) return false;
        if (base){
                this.parts.every(function(part){
                        if (bits[part]) return false;
                        bits[part] = base[part] || '';
                        return true;
                });
        }
        bits.port = bits.port || this.schemes[bits.scheme.toLowerCase()];
        bits.directory = bits.directory ? this.parseDirectory(bits.directory, base ? base.directory : '') : '/';
        return bits;
},

parseDirectory: function(directory, baseDirectory){
        directory = (directory.substr(0, 1) == '/' ? '' : (baseDirectory || '/')) + directory;
        if (!directory.test(URI.regs.directoryDot)) return directory;
        var result = [];
        directory.replace(URI.regs.endSlash, '').split('/').each(function(dir){
                if (dir == '..' && result.length > 0) result.pop();
                else if (dir != '.') result.push(dir);
        });
        return result.join('/') + '/';
},

combine: function(bits){
        return bits.value || bits.scheme + '://' +
                (bits.user ? bits.user + (bits.password ? ':' + bits.password : '') + '@' : '') +
                (bits.host || '') + (bits.port && bits.port != this.schemes[bits.scheme] ? ':' + bits.port : '') +
                (bits.directory || '/') + (bits.file || '') +
                (bits.query ? '?' + bits.query : '') +
                (bits.fragment ? '#' + bits.fragment : '');
},

set: function(part, value, base){
        if (part == 'value'){
                var scheme = value.match(URI.regs.scheme);
                if (scheme) scheme = scheme[1];
                if (scheme && this.schemes[scheme.toLowerCase()] == null) this.parsed = { scheme: scheme, value: value };
                else this.parsed = this.parse(value, (base || this).parsed) || (scheme ? { scheme: scheme, value: value } : { value: value });
        } else if (part == 'data'){
                this.setData(value);
        } else {
                this.parsed[part] = value;
        }
        return this;
},

get: function(part, base){
        switch (part){
                case 'value': return this.combine(this.parsed, base ? base.parsed : false);
                case 'data' : return this.getData();
        }
        return this.parsed[part] || '';
},

go: function(){
        document.location.href = this.toString();
},

toURI: function(){
        return this;
},

getData: function(key, part){
        var qs = this.get(part || 'query');
        if (!(qs || qs === 0)) return key ? null : {};
        var obj = qs.parseQueryString();
        return key ? obj[key] : obj;
},

setData: function(values, merge, part){
        if (typeof values == 'string'){
                var data = this.getData();
                data[arguments[0]] = arguments[1];
                values = data;
        } else if (merge){
                values = Object.merge(this.getData(), values);
        }
        return this.set(part || 'query', Object.toQueryString(values));
},

clearData: function(part){
        return this.set(part || 'query', '');
},

toString: toString,
valueOf: toString

});

URI.regs = {

endSlash: /\/$/,
scheme: /^(\w+):/,
directoryDot: /\.\/|\.$/

};

URI.base = new URI(Array.from(document.getElements(‘base', true)).getLast(), {base: document.location});

String.implement({

toURI: function(options){
        return new URI(this, options);
}

});

})();

/*


script: Class.Refactor.js

name: Class.Refactor

description: Extends a class onto itself with new property, preserving any items attached to the class's namespace.

license: MIT-style license

authors:

- Aaron Newton

requires:

- Core/Class
- /MooTools.More

# Some modules declare themselves dependent on Class.Refactor provides: [Class.refactor, Class.Refactor]

/

Class.refactor = function(original, refactors){

Object.each(refactors, function(item, name){
        var origin = original.prototype[name];
        origin = (origin && origin.$origin) || origin || function(){};
        original.implement(name, (typeof item == 'function') ? function(){
                var old = this.previous;
                this.previous = origin;
                var value = item.apply(this, arguments);
                this.previous = old;
                return value;
        } : item);
});

return original;

};

/*


script: URI.Relative.js

name: URI.Relative

description: Extends the URI class to add methods for computing relative and absolute urls.

license: MIT-style license

authors:

- Sebastian Markbåge

requires:

- /Class.refactor
- /URI

provides: [URI.Relative]

/

URI = Class.refactor(URI, {

combine: function(bits, base){
        if (!base || bits.scheme != base.scheme || bits.host != base.host || bits.port != base.port)
                return this.previous.apply(this, arguments);
        var end = bits.file + (bits.query ? '?' + bits.query : '') + (bits.fragment ? '#' + bits.fragment : '');

        if (!base.directory) return (bits.directory || (bits.file ? '' : './')) + end;

        var baseDir = base.directory.split('/'),
                relDir = bits.directory.split('/'),
                path = '',
                offset;

        var i = 0;
        for (offset = 0; offset < baseDir.length && offset < relDir.length && baseDir[offset] == relDir[offset]; offset++);
        for (i = 0; i < baseDir.length - offset - 1; i++) path += '../';
        for (i = offset; i < relDir.length - 1; i++) path += relDir[i] + '/';

        return (path || (bits.file ? '' : './')) + end;
},

toAbsolute: function(base){
        base = new URI(base);
        if (base) base.set('directory', '').set('file', '');
        return this.toRelative(base);
},

toRelative: function(base){
        return this.get('value', new URI(base));
}

});

/*


name: Hash

description: Contains Hash Prototypes. Provides a means for overcoming the JavaScript practical impossibility of extending native Objects.

license: MIT-style license.

requires:

- Core/Object
- /MooTools.More

provides: [Hash]

/

(function(){

if (this.Hash) return;

var Hash = this.Hash = new Type('Hash', function(object){

if (typeOf(object) == 'hash') object = Object.clone(object.getClean());
for (var key in object) this[key] = object[key];
return this;

});

this.$H = function(object){

return new Hash(object);

};

Hash.implement({

forEach: function(fn, bind){
        Object.forEach(this, fn, bind);
},

getClean: function(){
        var clean = {};
        for (var key in this){
                if (this.hasOwnProperty(key)) clean[key] = this[key];
        }
        return clean;
},

getLength: function(){
        var length = 0;
        for (var key in this){
                if (this.hasOwnProperty(key)) length++;
        }
        return length;
}

});

Hash.alias('each', 'forEach');

Hash.implement({

has: Object.prototype.hasOwnProperty,

keyOf: function(value){
        return Object.keyOf(this, value);
},

hasValue: function(value){
        return Object.contains(this, value);
},

extend: function(properties){
        Hash.each(properties || {}, function(value, key){
                Hash.set(this, key, value);
        }, this);
        return this;
},

combine: function(properties){
        Hash.each(properties || {}, function(value, key){
                Hash.include(this, key, value);
        }, this);
        return this;
},

erase: function(key){
        if (this.hasOwnProperty(key)) delete this[key];
        return this;
},

get: function(key){
        return (this.hasOwnProperty(key)) ? this[key] : null;
},

set: function(key, value){
        if (!this[key] || this.hasOwnProperty(key)) this[key] = value;
        return this;
},

empty: function(){
        Hash.each(this, function(value, key){
                delete this[key];
        }, this);
        return this;
},

include: function(key, value){
        if (this[key] == undefined) this[key] = value;
        return this;
},

map: function(fn, bind){
        return new Hash(Object.map(this, fn, bind));
},

filter: function(fn, bind){
        return new Hash(Object.filter(this, fn, bind));
},

every: function(fn, bind){
        return Object.every(this, fn, bind);
},

some: function(fn, bind){
        return Object.some(this, fn, bind);
},

getKeys: function(){
        return Object.keys(this);
},

getValues: function(){
        return Object.values(this);
},

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

});

Hash.alias({indexOf: 'keyOf', contains: 'hasValue'});

})();

/*


script: Hash.Extras.js

name: Hash.Extras

description: Extends the Hash Type to include getFromPath which allows a path notation to child elements.

license: MIT-style license

authors:

- Aaron Newton

requires:

- /Hash
- /Object.Extras

provides: [Hash.Extras]

/

Hash.implement({

getFromPath: function(notation){
        return Object.getFromPath(this, notation);
},

cleanValues: function(method){
        return new Hash(Object.cleanValues(this, method));
},

run: function(){
        Object.run(arguments);
}

});

/*


script: Element.Pin.js

name: Element.Pin

description: Extends the Element native object to include the pin method useful for fixed positioning for elements.

license: MIT-style license

authors:

- Aaron Newton

requires:

- Core/Element.Event
- Core/Element.Dimensions
- Core/Element.Style
- /MooTools.More

provides: [Element.Pin]

/

(function(){

var supportsPositionFixed = false,
        supportTested = false;

var testPositionFixed = function(){
        var test = new Element('div').setStyles({
                position: 'fixed',
                top: 0,
                right: 0
        }).inject(document.body);
        supportsPositionFixed = (test.offsetTop === 0);
        test.dispose();
        supportTested = true;
};

Element.implement({

        pin: function(enable, forceScroll){
                if (!supportTested) testPositionFixed();
                if (this.getStyle('display') == 'none') return this;

                var pinnedPosition,
                        scroll = window.getScroll(),
                        parent,
                        scrollFixer;

                if (enable !== false){
                        pinnedPosition = this.getPosition(supportsPositionFixed ? document.body : this.getOffsetParent());
                        if (!this.retrieve('pin:_pinned')){
                                var currentPosition = {
                                        top: pinnedPosition.y - scroll.y,
                                        left: pinnedPosition.x - scroll.x
                                };

                                if (supportsPositionFixed && !forceScroll){
                                        this.setStyle('position', 'fixed').setStyles(currentPosition);
                                } else {

                                        parent = this.getOffsetParent();
                                        var position = this.getPosition(parent),
                                                styles = this.getStyles('left', 'top');

                                        if (parent && styles.left == 'auto' || styles.top == 'auto') this.setPosition(position);
                                        if (this.getStyle('position') == 'static') this.setStyle('position', 'absolute');

                                        position = {
                                                x: styles.left.toInt() - scroll.x,
                                                y: styles.top.toInt() - scroll.y
                                        };

                                        scrollFixer = function(){
                                                if (!this.retrieve('pin:_pinned')) return;
                                                var scroll = window.getScroll();
                                                this.setStyles({
                                                        left: position.x + scroll.x,
                                                        top: position.y + scroll.y
                                                });
                                        }.bind(this);

                                        this.store('pin:_scrollFixer', scrollFixer);
                                        window.addEvent('scroll', scrollFixer);
                                }
                                this.store('pin:_pinned', true);
                        }

                } else {
                        if (!this.retrieve('pin:_pinned')) return this;

                        parent = this.getParent();
                        var offsetParent = (parent.getComputedStyle('position') != 'static' ? parent : parent.getOffsetParent());

                        pinnedPosition = this.getPosition(offsetParent);

                        this.store('pin:_pinned', false);
                        scrollFixer = this.retrieve('pin:_scrollFixer');
                        if (!scrollFixer){
                                this.setStyles({
                                        position: 'absolute',
                                        top: pinnedPosition.y + scroll.y,
                                        left: pinnedPosition.x + scroll.x
                                });
                        } else {
                                this.store('pin:_scrollFixer', null);
                                window.removeEvent('scroll', scrollFixer);
                        }
                        this.removeClass('isPinned');
                }
                return this;
        },

        unpin: function(){
                return this.pin(false);
        },

        togglePin: function(){
                return this.pin(!this.retrieve('pin:_pinned'));
        }

});

//<1.2compat> Element.alias('togglepin', 'togglePin'); //</1.2compat>

})();

/*


script: Element.Measure.js

name: Element.Measure

description: Extends the Element native object to include methods useful in measuring dimensions.

credits: “Element.measure / .expose methods by Daniel Steigerwald License: MIT-style license. Copyright: Copyright © 2008 Daniel Steigerwald, daniel.steigerwald.cz”

license: MIT-style license

authors:

- Aaron Newton

requires:

- Core/Element.Style
- Core/Element.Dimensions
- /MooTools.More

provides: [Element.Measure]

/

(function(){

var getStylesList = function(styles, planes){

var list = [];
Object.each(planes, function(directions){
        Object.each(directions, function(edge){
                styles.each(function(style){
                        list.push(style + '-' + edge + (style == 'border' ? '-width' : ''));
                });
        });
});
return list;

};

var calculateEdgeSize = function(edge, styles){

var total = 0;
Object.each(styles, function(value, style){
        if (style.test(edge)) total = total + value.toInt();
});
return total;

};

var isVisible = function(el){

return !!(!el || el.offsetHeight || el.offsetWidth);

};

Element.implement({

measure: function(fn){
        if (isVisible(this)) return fn.call(this);
        var parent = this.getParent(),
                toMeasure = [];
        while (!isVisible(parent) && parent != document.body){
                toMeasure.push(parent.expose());
                parent = parent.getParent();
        }
        var restore = this.expose(),
                result = fn.call(this);
        restore();
        toMeasure.each(function(restore){
                restore();
        });
        return result;
},

expose: function(){
        if (this.getStyle('display') != 'none') return function(){};
        var before = this.style.cssText;
        this.setStyles({
                display: 'block',
                position: 'absolute',
                visibility: 'hidden'
        });
        return function(){
                this.style.cssText = before;
        }.bind(this);
},

getDimensions: function(options){
        options = Object.merge({computeSize: false}, options);
        var dim = {x: 0, y: 0};

        var getSize = function(el, options){
                return (options.computeSize) ? el.getComputedSize(options) : el.getSize();
        };

        var parent = this.getParent('body');

        if (parent && this.getStyle('display') == 'none'){
                dim = this.measure(function(){
                        return getSize(this, options);
                });
        } else if (parent){
                try { //safari sometimes crashes here, so catch it
                        dim = getSize(this, options);
                }catch(e){}
        }

        return Object.append(dim, (dim.x || dim.x === 0) ? {
                        width: dim.x,
                        height: dim.y
                } : {
                        x: dim.width,
                        y: dim.height
                }
        );
},

getComputedSize: function(options){
        //<1.2compat>
        //legacy support for my stupid spelling error
        if (options && options.plains) options.planes = options.plains;
        //</1.2compat>

        options = Object.merge({
                styles: ['padding','border'],
                planes: {
                        height: ['top','bottom'],
                        width: ['left','right']
                },
                mode: 'both'
        }, options);

        var styles = {},
                size = {width: 0, height: 0},
                dimensions;

        if (options.mode == 'vertical'){
                delete size.width;
                delete options.planes.width;
        } else if (options.mode == 'horizontal'){
                delete size.height;
                delete options.planes.height;
        }

        getStylesList(options.styles, options.planes).each(function(style){
                styles[style] = this.getStyle(style).toInt();
        }, this);

        Object.each(options.planes, function(edges, plane){

                var capitalized = plane.capitalize(),
                        style = this.getStyle(plane);

                if (style == 'auto' && !dimensions) dimensions = this.getDimensions();

                style = styles[plane] = (style == 'auto') ? dimensions[plane] : style.toInt();
                size['total' + capitalized] = style;

                edges.each(function(edge){
                        var edgesize = calculateEdgeSize(edge, styles);
                        size['computed' + edge.capitalize()] = edgesize;
                        size['total' + capitalized] += edgesize;
                });

        }, this);

        return Object.append(size, styles);
}

});

})();

/*


script: Element.Position.js

name: Element.Position

description: Extends the Element native object to include methods useful positioning elements relative to others.

license: MIT-style license

authors:

- Aaron Newton
- Jacob Thornton

requires:

- Core/Options
- Core/Element.Dimensions
- Element.Measure

provides: [Element.Position]

/

(function(original){

var local = Element.Position = {

options: {/*
        edge: false,
        returnPos: false,
        minimum: {x: 0, y: 0},
        maximum: {x: 0, y: 0},
        relFixedPosition: false,
        ignoreMargins: false,
        ignoreScroll: false,
        allowNegative: false,*/
        relativeTo: document.body,
        position: {
                x: 'center', //left, center, right
                y: 'center' //top, center, bottom
        },
        offset: {x: 0, y: 0}
},

getOptions: function(element, options){
        options = Object.merge({}, local.options, options);
        local.setPositionOption(options);
        local.setEdgeOption(options);
        local.setOffsetOption(element, options);
        local.setDimensionsOption(element, options);
        return options;
},

setPositionOption: function(options){
        options.position = local.getCoordinateFromValue(options.position);
},

setEdgeOption: function(options){
        var edgeOption = local.getCoordinateFromValue(options.edge);
        options.edge = edgeOption ? edgeOption :
                (options.position.x == 'center' && options.position.y == 'center') ? {x: 'center', y: 'center'} :
                {x: 'left', y: 'top'};
},

setOffsetOption: function(element, options){
        var parentOffset = {x: 0, y: 0},
                offsetParent = element.measure(function(){
                        return document.id(this.getOffsetParent());
                }),
                parentScroll = offsetParent.getScroll();

        if (!offsetParent || offsetParent == element.getDocument().body) return;
        parentOffset = offsetParent.measure(function(){
                var position = this.getPosition();
                if (this.getStyle('position') == 'fixed'){
                        var scroll = window.getScroll();
                        position.x += scroll.x;
                        position.y += scroll.y;
                }
                return position;
        });

        options.offset = {
                parentPositioned: offsetParent != document.id(options.relativeTo),
                x: options.offset.x - parentOffset.x + parentScroll.x,
                y: options.offset.y - parentOffset.y + parentScroll.y
        };
},

setDimensionsOption: function(element, options){
        options.dimensions = element.getDimensions({
                computeSize: true,
                styles: ['padding', 'border', 'margin']
        });
},

getPosition: function(element, options){
        var position = {};
        options = local.getOptions(element, options);
        var relativeTo = document.id(options.relativeTo) || document.body;

        local.setPositionCoordinates(options, position, relativeTo);
        if (options.edge) local.toEdge(position, options);

        var offset = options.offset;
        position.left = ((position.x >= 0 || offset.parentPositioned || options.allowNegative) ? position.x : 0).toInt();
        position.top = ((position.y >= 0 || offset.parentPositioned || options.allowNegative) ? position.y : 0).toInt();

        local.toMinMax(position, options);

        if (options.relFixedPosition || relativeTo.getStyle('position') == 'fixed') local.toRelFixedPosition(relativeTo, position);
        if (options.ignoreScroll) local.toIgnoreScroll(relativeTo, position);
        if (options.ignoreMargins) local.toIgnoreMargins(position, options);

        position.left = Math.ceil(position.left);
        position.top = Math.ceil(position.top);
        delete position.x;
        delete position.y;

        return position;
},

setPositionCoordinates: function(options, position, relativeTo){
        var offsetY = options.offset.y,
                offsetX = options.offset.x,
                calc = (relativeTo == document.body) ? window.getScroll() : relativeTo.getPosition(),
                top = calc.y,
                left = calc.x,
                winSize = window.getSize();

        switch(options.position.x){
                case 'left': position.x = left + offsetX; break;
                case 'right': position.x = left + offsetX + relativeTo.offsetWidth; break;
                default: position.x = left + ((relativeTo == document.body ? winSize.x : relativeTo.offsetWidth) / 2) + offsetX; break;
        }

        switch(options.position.y){
                case 'top': position.y = top + offsetY; break;
                case 'bottom': position.y = top + offsetY + relativeTo.offsetHeight; break;
                default: position.y = top + ((relativeTo == document.body ? winSize.y : relativeTo.offsetHeight) / 2) + offsetY; break;
        }
},

toMinMax: function(position, options){
        var xy = {left: 'x', top: 'y'}, value;
        ['minimum', 'maximum'].each(function(minmax){
                ['left', 'top'].each(function(lr){
                        value = options[minmax] ? options[minmax][xy[lr]] : null;
                        if (value != null && ((minmax == 'minimum') ? position[lr] < value : position[lr] > value)) position[lr] = value;
                });
        });
},

toRelFixedPosition: function(relativeTo, position){
        var winScroll = window.getScroll();
        position.top += winScroll.y;
        position.left += winScroll.x;
},

toIgnoreScroll: function(relativeTo, position){
        var relScroll = relativeTo.getScroll();
        position.top -= relScroll.y;
        position.left -= relScroll.x;
},

toIgnoreMargins: function(position, options){
        position.left += options.edge.x == 'right'
                ? options.dimensions['margin-right']
                : (options.edge.x != 'center'
                        ? -options.dimensions['margin-left']
                        : -options.dimensions['margin-left'] + ((options.dimensions['margin-right'] + options.dimensions['margin-left']) / 2));

        position.top += options.edge.y == 'bottom'
                ? options.dimensions['margin-bottom']
                : (options.edge.y != 'center'
                        ? -options.dimensions['margin-top']
                        : -options.dimensions['margin-top'] + ((options.dimensions['margin-bottom'] + options.dimensions['margin-top']) / 2));
},

toEdge: function(position, options){
        var edgeOffset = {},
                dimensions = options.dimensions,
                edge = options.edge;

        switch(edge.x){
                case 'left': edgeOffset.x = 0; break;
                case 'right': edgeOffset.x = -dimensions.x - dimensions.computedRight - dimensions.computedLeft; break;
                // center
                default: edgeOffset.x = -(Math.round(dimensions.totalWidth / 2)); break;
        }

        switch(edge.y){
                case 'top': edgeOffset.y = 0; break;
                case 'bottom': edgeOffset.y = -dimensions.y - dimensions.computedTop - dimensions.computedBottom; break;
                // center
                default: edgeOffset.y = -(Math.round(dimensions.totalHeight / 2)); break;
        }

        position.x += edgeOffset.x;
        position.y += edgeOffset.y;
},

getCoordinateFromValue: function(option){
        if (typeOf(option) != 'string') return option;
        option = option.toLowerCase();

        return {
                x: option.test('left') ? 'left'
                        : (option.test('right') ? 'right' : 'center'),
                y: option.test(/upper|top/) ? 'top'
                        : (option.test('bottom') ? 'bottom' : 'center')
        };
}

};

Element.implement({

position: function(options){
        if (options && (options.x != null || options.y != null)){
                return (original ? original.apply(this, arguments) : this);
        }
        var position = this.setStyle('position', 'absolute').calculatePosition(options);
        return (options && options.returnPos) ? position : this.setStyles(position);
},

calculatePosition: function(options){
        return local.getPosition(this, options);
}

});

})(Element.prototype.position);

/*


script: Class.Occlude.js

name: Class.Occlude

description: Prevents a class from being applied to a DOM element twice.

license: MIT-style license.

authors:

- Aaron Newton

requires:

- Core/Class
- Core/Element
- /MooTools.More

provides: [Class.Occlude]

/

Class.Occlude = new Class({

occlude: function(property, element){
        element = document.id(element || this.element);
        var instance = element.retrieve(property || this.property);
        if (instance && !this.occluded)
                return (this.occluded = instance);

        this.occluded = false;
        element.store(property || this.property, this);
        return this.occluded;
}

});

/*


script: IframeShim.js

name: IframeShim

description: Defines IframeShim, a class for obscuring select lists and flash objects in IE.

license: MIT-style license

authors:

- Aaron Newton

requires:

- Core/Element.Event
- Core/Element.Style
- Core/Options
- Core/Events
- /Element.Position
- /Class.Occlude

provides: [IframeShim]

/

var IframeShim = new Class({

Implements: [Options, Events, Class.Occlude],

options: {
        className: 'iframeShim',
        src: 'javascript:false;document.write("");',
        display: false,
        zIndex: null,
        margin: 0,
        offset: {x: 0, y: 0},
        browsers: (Browser.ie6 || (Browser.firefox && Browser.version < 3 && Browser.Platform.mac))
},

property: 'IframeShim',

initialize: function(element, options){
        this.element = document.id(element);
        if (this.occlude()) return this.occluded;
        this.setOptions(options);
        this.makeShim();
        return this;
},

makeShim: function(){
        if (this.options.browsers){
                var zIndex = this.element.getStyle('zIndex').toInt();

                if (!zIndex){
                        zIndex = 1;
                        var pos = this.element.getStyle('position');
                        if (pos == 'static' || !pos) this.element.setStyle('position', 'relative');
                        this.element.setStyle('zIndex', zIndex);
                }
                zIndex = ((this.options.zIndex != null || this.options.zIndex === 0) && zIndex > this.options.zIndex) ? this.options.zIndex : zIndex - 1;
                if (zIndex < 0) zIndex = 1;
                this.shim = new Element('iframe', {
                        src: this.options.src,
                        scrolling: 'no',
                        frameborder: 0,
                        styles: {
                                zIndex: zIndex,
                                position: 'absolute',
                                border: 'none',
                                filter: 'progid:DXImageTransform.Microsoft.Alpha(style=0,opacity=0)'
                        },
                        'class': this.options.className
                }).store('IframeShim', this);
                var inject = (function(){
                        this.shim.inject(this.element, 'after');
                        this[this.options.display ? 'show' : 'hide']();
                        this.fireEvent('inject');
                }).bind(this);
                if (!IframeShim.ready) window.addEvent('load', inject);
                else inject();
        } else {
                this.position = this.hide = this.show = this.dispose = Function.from(this);
        }
},

position: function(){
        if (!IframeShim.ready || !this.shim) return this;
        var size = this.element.measure(function(){
                return this.getSize();
        });
        if (this.options.margin != undefined){
                size.x = size.x - (this.options.margin * 2);
                size.y = size.y - (this.options.margin * 2);
                this.options.offset.x += this.options.margin;
                this.options.offset.y += this.options.margin;
        }
        this.shim.set({width: size.x, height: size.y}).position({
                relativeTo: this.element,
                offset: this.options.offset
        });
        return this;
},

hide: function(){
        if (this.shim) this.shim.setStyle('display', 'none');
        return this;
},

show: function(){
        if (this.shim) this.shim.setStyle('display', 'block');
        return this.position();
},

dispose: function(){
        if (this.shim) this.shim.dispose();
        return this;
},

destroy: function(){
        if (this.shim) this.shim.destroy();
        return this;
}

});

window.addEvent('load', function(){

IframeShim.ready = true;

});

/*


script: Mask.js

name: Mask

description: Creates a mask element to cover another.

license: MIT-style license

authors:

- Aaron Newton

requires:

- Core/Options
- Core/Events
- Core/Element.Event
- /Class.Binds
- /Element.Position
- /IframeShim

provides: [Mask]

/

var Mask = new Class({

Implements: [Options, Events],

Binds: ['position'],

options: {/*
        onShow: function(){},
        onHide: function(){},
        onDestroy: function(){},
        onClick: function(event){},
        inject: {
                where: 'after',
                target: null,
        },
        hideOnClick: false,
        id: null,
        destroyOnHide: false,*/
        style: {},
        'class': 'mask',
        maskMargins: false,
        useIframeShim: true,
        iframeShimOptions: {}
},

initialize: function(target, options){
        this.target = document.id(target) || document.id(document.body);
        this.target.store('mask', this);
        this.setOptions(options);
        this.render();
        this.inject();
},

render: function(){
        this.element = new Element('div', {
                'class': this.options['class'],
                id: this.options.id || 'mask-' + String.uniqueID(),
                styles: Object.merge({}, this.options.style, {
                        display: 'none'
                }),
                events: {
                        click: function(event){
                                this.fireEvent('click', event);
                                if (this.options.hideOnClick) this.hide();
                        }.bind(this)
                }
        });

        this.hidden = true;
},

toElement: function(){
        return this.element;
},

inject: function(target, where){
        where = where || (this.options.inject ? this.options.inject.where : '') || this.target == document.body ? 'inside' : 'after';
        target = target || (this.options.inject && this.options.inject.target) || this.target;

        this.element.inject(target, where);

        if (this.options.useIframeShim){
                this.shim = new IframeShim(this.element, this.options.iframeShimOptions);

                this.addEvents({
                        show: this.shim.show.bind(this.shim),
                        hide: this.shim.hide.bind(this.shim),
                        destroy: this.shim.destroy.bind(this.shim)
                });
        }
},

position: function(){
        this.resize(this.options.width, this.options.height);

        this.element.position({
                relativeTo: this.target,
                position: 'topLeft',
                ignoreMargins: !this.options.maskMargins,
                ignoreScroll: this.target == document.body
        });

        return this;
},

resize: function(x, y){
        var opt = {
                styles: ['padding', 'border']
        };
        if (this.options.maskMargins) opt.styles.push('margin');

        var dim = this.target.getComputedSize(opt);
        if (this.target == document.body){
                this.element.setStyles({width: 0, height: 0});
                var win = window.getScrollSize();
                if (dim.totalHeight < win.y) dim.totalHeight = win.y;
                if (dim.totalWidth < win.x) dim.totalWidth = win.x;
        }
        this.element.setStyles({
                width: Array.pick([x, dim.totalWidth, dim.x]),
                height: Array.pick([y, dim.totalHeight, dim.y])
        });

        return this;
},

show: function(){
        if (!this.hidden) return this;

        window.addEvent('resize', this.position);
        this.position();
        this.showMask.apply(this, arguments);

        return this;
},

showMask: function(){
        this.element.setStyle('display', 'block');
        this.hidden = false;
        this.fireEvent('show');
},

hide: function(){
        if (this.hidden) return this;

        window.removeEvent('resize', this.position);
        this.hideMask.apply(this, arguments);
        if (this.options.destroyOnHide) return this.destroy();

        return this;
},

hideMask: function(){
        this.element.setStyle('display', 'none');
        this.hidden = true;
        this.fireEvent('hide');
},

toggle: function(){
        this[this.hidden ? 'show' : 'hide']();
},

destroy: function(){
        this.hide();
        this.element.destroy();
        this.fireEvent('destroy');
        this.target.eliminate('mask');
}

});

Element.Properties.mask = {

set: function(options){
        var mask = this.retrieve('mask');
        if (mask) mask.destroy();
        return this.eliminate('mask').store('mask:options', options);
},

get: function(){
        var mask = this.retrieve('mask');
        if (!mask){
                mask = new Mask(this, this.retrieve('mask:options'));
                this.store('mask', mask);
        }
        return mask;
}

};

Element.implement({

mask: function(options){
        if (options) this.set('mask', options);
        this.get('mask').show();
        return this;
},

unmask: function(){
        this.get('mask').hide();
        return this;
}

});

/*


script: Spinner.js

name: Spinner

description: Adds a semi-transparent overlay over a dom element with a spinnin ajax icon.

license: MIT-style license

authors:

- Aaron Newton

requires:

- Core/Fx.Tween
- Core/Request
- /Class.refactor
- /Mask

provides: [Spinner]

/

var Spinner = new Class({

Extends: Mask,

Implements: Chain,

options: {/*
        message: false,*/
        'class': 'spinner',
        containerPosition: {},
        content: {
                'class': 'spinner-content'
        },
        messageContainer: {
                'class': 'spinner-msg'
        },
        img: {
                'class': 'spinner-img'
        },
        fxOptions: {
                link: 'chain'
        }
},

initialize: function(target, options){
        this.target = document.id(target) || document.id(document.body);
        this.target.store('spinner', this);
        this.setOptions(options);
        this.render();
        this.inject();

        // Add this to events for when noFx is true; parent methods handle hide/show.
        var deactivate = function(){ this.active = false; }.bind(this);
        this.addEvents({
                hide: deactivate,
                show: deactivate
        });
},

render: function(){
        this.parent();

        this.element.set('id', this.options.id || 'spinner-' + String.uniqueID());

        this.content = document.id(this.options.content) || new Element('div', this.options.content);
        this.content.inject(this.element);

        if (this.options.message){
                this.msg = document.id(this.options.message) || new Element('p', this.options.messageContainer).appendText(this.options.message);
                this.msg.inject(this.content);
        }

        if (this.options.img){
                this.img = document.id(this.options.img) || new Element('div', this.options.img);
                this.img.inject(this.content);
        }

        this.element.set('tween', this.options.fxOptions);
},

show: function(noFx){
        if (this.active) return this.chain(this.show.bind(this));
        if (!this.hidden){
                this.callChain.delay(20, this);
                return this;
        }

        this.active = true;

        return this.parent(noFx);
},

showMask: function(noFx){
        var pos = function(){
                this.content.position(Object.merge({
                        relativeTo: this.element
                }, this.options.containerPosition));
        }.bind(this);

        if (noFx){
                this.parent();
                pos();
        } else {
                if (!this.options.style.opacity) this.options.style.opacity = this.element.getStyle('opacity').toFloat();
                this.element.setStyles({
                        display: 'block',
                        opacity: 0
                }).tween('opacity', this.options.style.opacity);
                pos();
                this.hidden = false;
                this.fireEvent('show');
                this.callChain();
        }
},

hide: function(noFx){
        if (this.active) return this.chain(this.hide.bind(this));
        if (this.hidden){
                this.callChain.delay(20, this);
                return this;
        }
        this.active = true;
        return this.parent(noFx);
},

hideMask: function(noFx){
        if (noFx) return this.parent();
        this.element.tween('opacity', 0).get('tween').chain(function(){
                this.element.setStyle('display', 'none');
                this.hidden = true;
                this.fireEvent('hide');
                this.callChain();
        }.bind(this));
},

destroy: function(){
        this.content.destroy();
        this.parent();
        this.target.eliminate('spinner');
}

});

Request = Class.refactor(Request, {

options: {
        useSpinner: false,
        spinnerOptions: {},
        spinnerTarget: false
},

initialize: function(options){
        this._send = this.send;
        this.send = function(options){
                var spinner = this.getSpinner();
                if (spinner) spinner.chain(this._send.pass(options, this)).show();
                else this._send(options);
                return this;
        };
        this.previous(options);
},

getSpinner: function(){
        if (!this.spinner){
                var update = document.id(this.options.spinnerTarget) || document.id(this.options.update);
                if (this.options.useSpinner && update){
                        update.set('spinner', this.options.spinnerOptions);
                        var spinner = this.spinner = update.get('spinner');
                        ['complete', 'exception', 'cancel'].each(function(event){
                                this.addEvent(event, spinner.hide.bind(spinner));
                        }, this);
                }
        }
        return this.spinner;
}

});

Element.Properties.spinner = {

set: function(options){
        var spinner = this.retrieve('spinner');
        if (spinner) spinner.destroy();
        return this.eliminate('spinner').store('spinner:options', options);
},

get: function(){
        var spinner = this.retrieve('spinner');
        if (!spinner){
                spinner = new Spinner(this, this.retrieve('spinner:options'));
                this.store('spinner', spinner);
        }
        return spinner;
}

};

Element.implement({

spin: function(options){
        if (options) this.set('spinner', options);
        this.get('spinner').show();
        return this;
},

unspin: function(){
        this.get('spinner').hide();
        return this;
}

});

/*


name: Events.Pseudos

description: Adds the functionality to add pseudo events

license: MIT-style license

authors:

- Arian Stolwijk

requires: [Core/Class.Extras, Core/Slick.Parser, More/MooTools.More]

provides: [Events.Pseudos]

/

(function(){

Events.Pseudos = function(pseudos, addEvent, removeEvent){

var storeKey = '_monitorEvents:';

var storageOf = function(object){
        return {
                store: object.store ? function(key, value){
                        object.store(storeKey + key, value);
                } : function(key, value){
                        (object._monitorEvents || (object._monitorEvents = {}))[key] = value;
                },
                retrieve: object.retrieve ? function(key, dflt){
                        return object.retrieve(storeKey + key, dflt);
                } : function(key, dflt){
                        if (!object._monitorEvents) return dflt;
                        return object._monitorEvents[key] || dflt;
                }
        };
};

var splitType = function(type){
        if (type.indexOf(':') == -1 || !pseudos) return null;

        var parsed = Slick.parse(type).expressions[0][0],
                parsedPseudos = parsed.pseudos,
                l = parsedPseudos.length,
                splits = [];

        while (l--){
                var pseudo = parsedPseudos[l].key,
                        listener = pseudos[pseudo];
                if (listener != null) splits.push({
                        event: parsed.tag,
                        value: parsedPseudos[l].value,
                        pseudo: pseudo,
                        original: type,
                        listener: listener
                });
        }
        return splits.length ? splits : null;
};

return {

        addEvent: function(type, fn, internal){
                var split = splitType(type);
                if (!split) return addEvent.call(this, type, fn, internal);

                var storage = storageOf(this),
                        events = storage.retrieve(type, []),
                        eventType = split[0].event,
                        args = Array.slice(arguments, 2),
                        stack = fn,
                        self = this;

                split.each(function(item){
                        var listener = item.listener,
                                stackFn = stack;
                        if (listener == false) eventType += ':' + item.pseudo + '(' + item.value + ')';
                        else stack = function(){
                                listener.call(self, item, stackFn, arguments, stack);
                        };
                });

                events.include({type: eventType, event: fn, monitor: stack});
                storage.store(type, events);

                if (type != eventType) addEvent.apply(this, [type, fn].concat(args));
                return addEvent.apply(this, [eventType, stack].concat(args));
        },

        removeEvent: function(type, fn){
                var split = splitType(type);
                if (!split) return removeEvent.call(this, type, fn);

                var storage = storageOf(this),
                        events = storage.retrieve(type);
                if (!events) return this;

                var args = Array.slice(arguments, 2);

                removeEvent.apply(this, [type, fn].concat(args));
                events.each(function(monitor, i){
                        if (!fn || monitor.event == fn) removeEvent.apply(this, [monitor.type, monitor.monitor].concat(args));
                        delete events[i];
                }, this);

                storage.store(type, events);
                return this;
        }

};

};

var pseudos = {

once: function(split, fn, args, monitor){
        fn.apply(this, args);
        this.removeEvent(split.event, monitor)
                .removeEvent(split.original, fn);
},

throttle: function(split, fn, args){
        if (!fn._throttled){
                fn.apply(this, args);
                fn._throttled = setTimeout(function(){
                        fn._throttled = false;
                }, split.value || 250);
        }
},

pause: function(split, fn, args){
        clearTimeout(fn._pause);
        fn._pause = fn.delay(split.value || 250, this, args);
}

};

Events.definePseudo = function(key, listener){

pseudos[key] = listener;
return this;

};

Events.lookupPseudo = function(key){

return pseudos[key];

};

var proto = Events.prototype; Events.implement(Events.Pseudos(pseudos, proto.addEvent, proto.removeEvent));

['Request', 'Fx'].each(function(klass){

if (this[klass]) this[klass].implement(Events.prototype);

});

})();

/*


name: Element.Event.Pseudos

description: Adds the functionality to add pseudo events for Elements

license: MIT-style license

authors:

- Arian Stolwijk

requires: [Core/Element.Event, Core/Element.Delegation, Events.Pseudos]

provides: [Element.Event.Pseudos, Element.Delegation]

/

(function(){

var pseudos = {relay: false},

copyFromEvents = ['once', 'throttle', 'pause'],
count = copyFromEvents.length;

while (count–) pseudos[copyFromEvents] = Events.lookupPseudo(copyFromEvents);

DOMEvent.definePseudo = function(key, listener){

pseudos[key] = listener;
return this;

};

var proto = Element.prototype; [Element, Window, Document].invoke('implement', Events.Pseudos(pseudos, proto.addEvent, proto.removeEvent));

})();

/*


script: Form.Request.js

name: Form.Request

description: Handles the basic functionality of submitting a form and updating a dom element with the result.

license: MIT-style license

authors:

- Aaron Newton

requires:

- Core/Request.HTML
- /Class.Binds
- /Class.Occlude
- /Spinner
- /String.QueryString
- /Element.Delegation

provides: [Form.Request]

/

if (!window.Form) window.Form = {};

(function(){

Form.Request = new Class({

        Binds: ['onSubmit', 'onFormValidate'],

        Implements: [Options, Events, Class.Occlude],

        options: {/*
                onFailure: function(){},
                onSuccess: function(){}, // aliased to onComplete,
                onSend: function(){}*/
                requestOptions: {
                        evalScripts: true,
                        useSpinner: true,
                        emulation: false,
                        link: 'ignore'
                },
                sendButtonClicked: true,
                extraData: {},
                resetForm: true
        },

        property: 'form.request',

        initialize: function(form, target, options){
                this.element = document.id(form);
                if (this.occlude()) return this.occluded;
                this.setOptions(options)
                        .setTarget(target)
                        .attach();
        },

        setTarget: function(target){
                this.target = document.id(target);
                if (!this.request){
                        this.makeRequest();
                } else {
                        this.request.setOptions({
                                update: this.target
                        });
                }
                return this;
        },

        toElement: function(){
                return this.element;
        },

        makeRequest: function(){
                var self = this;
                this.request = new Request.HTML(Object.merge({
                                update: this.target,
                                emulation: false,
                                spinnerTarget: this.element,
                                method: this.element.get('method') || 'post'
                }, this.options.requestOptions)).addEvents({
                        success: function(tree, elements, html, javascript){
                                ['complete', 'success'].each(function(evt){
                                        self.fireEvent(evt, [self.target, tree, elements, html, javascript]);
                                });
                        },
                        failure: function(){
                                self.fireEvent('complete', arguments).fireEvent('failure', arguments);
                        },
                        exception: function(){
                                self.fireEvent('failure', arguments);
                        }
                });
                return this.attachReset();
        },

        attachReset: function(){
                if (!this.options.resetForm) return this;
                this.request.addEvent('success', function(){
                        Function.attempt(function(){
                                this.element.reset();
                        }.bind(this));
                        if (window.OverText) OverText.update();
                }.bind(this));
                return this;
        },

        attach: function(attach){
                var method = (attach != false) ? 'addEvent' : 'removeEvent';
                this.element[method]('click:relay(button, input[type=submit])', this.saveClickedButton.bind(this));

                var fv = this.element.retrieve('validator');
                if (fv) fv[method]('onFormValidate', this.onFormValidate);
                else this.element[method]('submit', this.onSubmit);

                return this;
        },

        detach: function(){
                return this.attach(false);
        },

        //public method
        enable: function(){
                return this.attach();
        },

        //public method
        disable: function(){
                return this.detach();
        },

        onFormValidate: function(valid, form, event){
                //if there's no event, then this wasn't a submit event
                if (!event) return;
                var fv = this.element.retrieve('validator');
                if (valid || (fv && !fv.options.stopOnFailure)){
                        event.stop();
                        this.send();
                }
        },

        onSubmit: function(event){
                var fv = this.element.retrieve('validator');
                if (fv){
                        //form validator was created after Form.Request
                        this.element.removeEvent('submit', this.onSubmit);
                        fv.addEvent('onFormValidate', this.onFormValidate);
                        this.element.validate();
                        return;
                }
                if (event) event.stop();
                this.send();
        },

        saveClickedButton: function(event, target){
                var targetName = target.get('name');
                if (!targetName || !this.options.sendButtonClicked) return;
                this.options.extraData[targetName] = target.get('value') || true;
                this.clickedCleaner = function(){
                        delete this.options.extraData[targetName];
                        this.clickedCleaner = function(){};
                }.bind(this);
        },

        clickedCleaner: function(){},

        send: function(){
                var str = this.element.toQueryString().trim(),
                        data = Object.toQueryString(this.options.extraData);

                if (str) str += "&" + data;
                else str = data;

                this.fireEvent('send', [this.element, str.parseQueryString()]);
                this.request.send({
                        data: str,
                        url: this.options.requestOptions.url || this.element.get('action')
                });
                this.clickedCleaner();
                return this;
        }

});

Element.implement('formUpdate', function(update, options){
        var fq = this.retrieve('form.request');
        if (!fq){
                fq = new Form.Request(this, update, options);
        } else {
                if (update) fq.setTarget(update);
                if (options) fq.setOptions(options).makeRequest();
        }
        fq.send();
        return this;
});

})();

/*


script: Element.Shortcuts.js

name: Element.Shortcuts

description: Extends the Element native object to include some shortcut methods.

license: MIT-style license

authors:

- Aaron Newton

requires:

- Core/Element.Style
- /MooTools.More

provides: [Element.Shortcuts]

/

Element.implement({

isDisplayed: function(){
        return this.getStyle('display') != 'none';
},

isVisible: function(){
        var w = this.offsetWidth,
                h = this.offsetHeight;
        return (w == 0 && h == 0) ? false : (w > 0 && h > 0) ? true : this.style.display != 'none';
},

toggle: function(){
        return this[this.isDisplayed() ? 'hide' : 'show']();
},

hide: function(){
        var d;
        try {
                //IE fails here if the element is not in the dom
                d = this.getStyle('display');
        } catch(e){}
        if (d == 'none') return this;
        return this.store('element:_originalDisplay', d || '').setStyle('display', 'none');
},

show: function(display){
        if (!display && this.isDisplayed()) return this;
        display = display || this.retrieve('element:_originalDisplay') || 'block';
        return this.setStyle('display', (display == 'none') ? 'block' : display);
},

swapClass: function(remove, add){
        return this.removeClass(remove).addClass(add);
}

});

Document.implement({

clearSelection: function(){
        if (window.getSelection){
                var selection = window.getSelection();
                if (selection && selection.removeAllRanges) selection.removeAllRanges();
        } else if (document.selection && document.selection.empty){
                try {
                        //IE fails here if selected element is not in dom
                        document.selection.empty();
                } catch(e){}
        }
}

});

/*


script: OverText.js

name: OverText

description: Shows text over an input that disappears when the user clicks into it. The text remains hidden if the user adds a value.

license: MIT-style license

authors:

- Aaron Newton

requires:

- Core/Options
- Core/Events
- Core/Element.Event
- Class.Binds
- Class.Occlude
- Element.Position
- Element.Shortcuts

provides: [OverText]

/

var OverText = new Class({

Implements: [Options, Events, Class.Occlude],

Binds: ['reposition', 'assert', 'focus', 'hide'],

options: {/*
        textOverride: null,
        onFocus: function(){},
        onTextHide: function(textEl, inputEl){},
        onTextShow: function(textEl, inputEl){}, */
        element: 'label',
        labelClass: 'overTxtLabel',
        positionOptions: {
                position: 'upperLeft',
                edge: 'upperLeft',
                offset: {
                        x: 4,
                        y: 2
                }
        },
        poll: false,
        pollInterval: 250,
        wrap: false
},

property: 'OverText',

initialize: function(element, options){
        element = this.element = document.id(element);

        if (this.occlude()) return this.occluded;
        this.setOptions(options);

        this.attach(element);
        OverText.instances.push(this);

        if (this.options.poll) this.poll();
},

toElement: function(){
        return this.element;
},

attach: function(){
        var element = this.element,
                options = this.options,
                value = options.textOverride || element.get('alt') || element.get('title');

        if (!value) return this;

        var text = this.text = new Element(options.element, {
                'class': options.labelClass,
                styles: {
                        lineHeight: 'normal',
                        position: 'absolute',
                        cursor: 'text'
                },
                html: value,
                events: {
                        click: this.hide.pass(options.element == 'label', this)
                }
        }).inject(element, 'after');

        if (options.element == 'label'){
                if (!element.get('id')) element.set('id', 'input_' + String.uniqueID());
                text.set('for', element.get('id'));
        }

        if (options.wrap){
                this.textHolder = new Element('div.overTxtWrapper', {
                        styles: {
                                lineHeight: 'normal',
                                position: 'relative'
                        }
                }).grab(text).inject(element, 'before');
        }

        return this.enable();
},

destroy: function(){
        this.element.eliminate(this.property); // Class.Occlude storage
        this.disable();
        if (this.text) this.text.destroy();
        if (this.textHolder) this.textHolder.destroy();
        return this;
},

disable: function(){
        this.element.removeEvents({
                focus: this.focus,
                blur: this.assert,
                change: this.assert
        });
        window.removeEvent('resize', this.reposition);
        this.hide(true, true);
        return this;
},

enable: function(){
        this.element.addEvents({
                focus: this.focus,
                blur: this.assert,
                change: this.assert
        });
        window.addEvent('resize', this.reposition);
        this.reposition();
        return this;
},

wrap: function(){
        if (this.options.element == 'label'){
                if (!this.element.get('id')) this.element.set('id', 'input_' + String.uniqueID());
                this.text.set('for', this.element.get('id'));
        }
},

startPolling: function(){
        this.pollingPaused = false;
        return this.poll();
},

poll: function(stop){
        //start immediately
        //pause on focus
        //resumeon blur
        if (this.poller && !stop) return this;
        if (stop){
                clearInterval(this.poller);
        } else {
                this.poller = (function(){
                        if (!this.pollingPaused) this.assert(true);
                }).periodical(this.options.pollInterval, this);
        }

        return this;
},

stopPolling: function(){
        this.pollingPaused = true;
        return this.poll(true);
},

focus: function(){
        if (this.text && (!this.text.isDisplayed() || this.element.get('disabled'))) return this;
        return this.hide();
},

hide: function(suppressFocus, force){
        if (this.text && (this.text.isDisplayed() && (!this.element.get('disabled') || force))){
                this.text.hide();
                this.fireEvent('textHide', [this.text, this.element]);
                this.pollingPaused = true;
                if (!suppressFocus){
                        try {
                                this.element.fireEvent('focus');
                                this.element.focus();
                        } catch(e){} //IE barfs if you call focus on hidden elements
                }
        }
        return this;
},

show: function(){
        if (this.text && !this.text.isDisplayed()){
                this.text.show();
                this.reposition();
                this.fireEvent('textShow', [this.text, this.element]);
                this.pollingPaused = false;
        }
        return this;
},

test: function(){
        return !this.element.get('value');
},

assert: function(suppressFocus){
        return this[this.test() ? 'show' : 'hide'](suppressFocus);
},

reposition: function(){
        this.assert(true);
        if (!this.element.isVisible()) return this.stopPolling().hide();
        if (this.text && this.test()){
                this.text.position(Object.merge(this.options.positionOptions, {
                        relativeTo: this.element
                }));
        }
        return this;
}

});

OverText.instances = [];

Object.append(OverText, {

each: function(fn){
        return OverText.instances.each(function(ot, i){
                if (ot.element && ot.text) fn.call(OverText, ot, i);
        });
},

update: function(){

        return OverText.each(function(ot){
                return ot.reposition();
        });

},

hideAll: function(){

        return OverText.each(function(ot){
                return ot.hide(true, true);
        });

},

showAll: function(){
        return OverText.each(function(ot){
                return ot.show();
        });
}

});

/*


script: Fx.Elements.js

name: Fx.Elements

description: Effect to change any number of CSS properties of any number of Elements.

license: MIT-style license

authors:

- Valerio Proietti

requires:

- Core/Fx.CSS
- /MooTools.More

provides: [Fx.Elements]

/

Fx.Elements = new Class({

Extends: Fx.CSS,

initialize: function(elements, options){
        this.elements = this.subject = $$(elements);
        this.parent(options);
},

compute: function(from, to, delta){
        var now = {};

        for (var i in from){
                var iFrom = from[i], iTo = to[i], iNow = now[i] = {};
                for (var p in iFrom) iNow[p] = this.parent(iFrom[p], iTo[p], delta);
        }

        return now;
},

set: function(now){
        for (var i in now){
                if (!this.elements[i]) continue;

                var iNow = now[i];
                for (var p in iNow) this.render(this.elements[i], p, iNow[p], this.options.unit);
        }

        return this;
},

start: function(obj){
        if (!this.check(obj)) return this;
        var from = {}, to = {};

        for (var i in obj){
                if (!this.elements[i]) continue;

                var iProps = obj[i], iFrom = from[i] = {}, iTo = to[i] = {};

                for (var p in iProps){
                        var parsed = this.prepare(this.elements[i], p, iProps[p]);
                        iFrom[p] = parsed.from;
                        iTo[p] = parsed.to;
                }
        }

        return this.parent(from, to);
}

});

/*


script: Fx.Scroll.js

name: Fx.Scroll

description: Effect to smoothly scroll any element, including the window.

license: MIT-style license

authors:

- Valerio Proietti

requires:

- Core/Fx
- Core/Element.Event
- Core/Element.Dimensions
- /MooTools.More

provides: [Fx.Scroll]

/

(function(){

Fx.Scroll = new Class({

Extends: Fx,

options: {
        offset: {x: 0, y: 0},
        wheelStops: true
},

initialize: function(element, options){
        this.element = this.subject = document.id(element);
        this.parent(options);

        if (typeOf(this.element) != 'element') this.element = document.id(this.element.getDocument().body);

        if (this.options.wheelStops){
                var stopper = this.element,
                        cancel = this.cancel.pass(false, this);
                this.addEvent('start', function(){
                        stopper.addEvent('mousewheel', cancel);
                }, true);
                this.addEvent('complete', function(){
                        stopper.removeEvent('mousewheel', cancel);
                }, true);
        }
},

set: function(){
        var now = Array.flatten(arguments);
        if (Browser.firefox) now = [Math.round(now[0]), Math.round(now[1])]; // not needed anymore in newer firefox versions
        this.element.scrollTo(now[0], now[1]);
        return this;
},

compute: function(from, to, delta){
        return [0, 1].map(function(i){
                return Fx.compute(from[i], to[i], delta);
        });
},

start: function(x, y){
        if (!this.check(x, y)) return this;
        var scroll = this.element.getScroll();
        return this.parent([scroll.x, scroll.y], [x, y]);
},

calculateScroll: function(x, y){
        var element = this.element,
                scrollSize = element.getScrollSize(),
                scroll = element.getScroll(),
                size = element.getSize(),
                offset = this.options.offset,
                values = {x: x, y: y};

        for (var z in values){
                if (!values[z] && values[z] !== 0) values[z] = scroll[z];
                if (typeOf(values[z]) != 'number') values[z] = scrollSize[z] - size[z];
                values[z] += offset[z];
        }

        return [values.x, values.y];
},

toTop: function(){
        return this.start.apply(this, this.calculateScroll(false, 0));
},

toLeft: function(){
        return this.start.apply(this, this.calculateScroll(0, false));
},

toRight: function(){
        return this.start.apply(this, this.calculateScroll('right', false));
},

toBottom: function(){
        return this.start.apply(this, this.calculateScroll(false, 'bottom'));
},

toElement: function(el, axes){
        axes = axes ? Array.from(axes) : ['x', 'y'];
        var scroll = isBody(this.element) ? {x: 0, y: 0} : this.element.getScroll();
        var position = Object.map(document.id(el).getPosition(this.element), function(value, axis){
                return axes.contains(axis) ? value + scroll[axis] : false;
        });
        return this.start.apply(this, this.calculateScroll(position.x, position.y));
},

toElementEdge: function(el, axes, offset){
        axes = axes ? Array.from(axes) : ['x', 'y'];
        el = document.id(el);
        var to = {},
                position = el.getPosition(this.element),
                size = el.getSize(),
                scroll = this.element.getScroll(),
                containerSize = this.element.getSize(),
                edge = {
                        x: position.x + size.x,
                        y: position.y + size.y
                };

        ['x', 'y'].each(function(axis){
                if (axes.contains(axis)){
                        if (edge[axis] > scroll[axis] + containerSize[axis]) to[axis] = edge[axis] - containerSize[axis];
                        if (position[axis] < scroll[axis]) to[axis] = position[axis];
                }
                if (to[axis] == null) to[axis] = scroll[axis];
                if (offset && offset[axis]) to[axis] = to[axis] + offset[axis];
        }, this);

        if (to.x != scroll.x || to.y != scroll.y) this.start(to.x, to.y);
        return this;
},

toElementCenter: function(el, axes, offset){
        axes = axes ? Array.from(axes) : ['x', 'y'];
        el = document.id(el);
        var to = {},
                position = el.getPosition(this.element),
                size = el.getSize(),
                scroll = this.element.getScroll(),
                containerSize = this.element.getSize();

        ['x', 'y'].each(function(axis){
                if (axes.contains(axis)){
                        to[axis] = position[axis] - (containerSize[axis] - size[axis]) / 2;
                }
                if (to[axis] == null) to[axis] = scroll[axis];
                if (offset && offset[axis]) to[axis] = to[axis] + offset[axis];
        }, this);

        if (to.x != scroll.x || to.y != scroll.y) this.start(to.x, to.y);
        return this;
}

});

//<1.2compat> Fx.Scroll.implement({

scrollToCenter: function(){
        return this.toElementCenter.apply(this, arguments);
},
scrollIntoView: function(){
        return this.toElementEdge.apply(this, arguments);
}

}); //</1.2compat>

function isBody(element){

return (/^(?:body|html)$/i).test(element.tagName);

}

})();

/*


script: Fx.Slide.js

name: Fx.Slide

description: Effect to slide an element in and out of view.

license: MIT-style license

authors:

- Valerio Proietti

requires:

- Core/Fx
- Core/Element.Style
- /MooTools.More

provides: [Fx.Slide]

/

Fx.Slide = new Class({

Extends: Fx,

options: {
        mode: 'vertical',
        wrapper: false,
        hideOverflow: true,
        resetHeight: false
},

initialize: function(element, options){
        element = this.element = this.subject = document.id(element);
        this.parent(options);
        options = this.options;

        var wrapper = element.retrieve('wrapper'),
                styles = element.getStyles('margin', 'position', 'overflow');

        if (options.hideOverflow) styles = Object.append(styles, {overflow: 'hidden'});
        if (options.wrapper) wrapper = document.id(options.wrapper).setStyles(styles);

        if (!wrapper) wrapper = new Element('div', {
                styles: styles
        }).wraps(element);

        element.store('wrapper', wrapper).setStyle('margin', 0);
        if (element.getStyle('overflow') == 'visible') element.setStyle('overflow', 'hidden');

        this.now = [];
        this.open = true;
        this.wrapper = wrapper;

        this.addEvent('complete', function(){
                this.open = (wrapper['offset' + this.layout.capitalize()] != 0);
                if (this.open && this.options.resetHeight) wrapper.setStyle('height', '');
        }, true);
},

vertical: function(){
        this.margin = 'margin-top';
        this.layout = 'height';
        this.offset = this.element.offsetHeight;
},

horizontal: function(){
        this.margin = 'margin-left';
        this.layout = 'width';
        this.offset = this.element.offsetWidth;
},

set: function(now){
        this.element.setStyle(this.margin, now[0]);
        this.wrapper.setStyle(this.layout, now[1]);
        return this;
},

compute: function(from, to, delta){
        return [0, 1].map(function(i){
                return Fx.compute(from[i], to[i], delta);
        });
},

start: function(how, mode){
        if (!this.check(how, mode)) return this;
        this[mode || this.options.mode]();

        var margin = this.element.getStyle(this.margin).toInt(),
                layout = this.wrapper.getStyle(this.layout).toInt(),
                caseIn = [[margin, layout], [0, this.offset]],
                caseOut = [[margin, layout], [-this.offset, 0]],
                start;

        switch (how){
                case 'in': start = caseIn; break;
                case 'out': start = caseOut; break;
                case 'toggle': start = (layout == 0) ? caseIn : caseOut;
        }
        return this.parent(start[0], start[1]);
},

slideIn: function(mode){
        return this.start('in', mode);
},

slideOut: function(mode){
        return this.start('out', mode);
},

hide: function(mode){
        this[mode || this.options.mode]();
        this.open = false;
        return this.set([-this.offset, 0]);
},

show: function(mode){
        this[mode || this.options.mode]();
        this.open = true;
        return this.set([0, this.offset]);
},

toggle: function(mode){
        return this.start('toggle', mode);
}

});

Element.Properties.slide = {

set: function(options){
        this.get('slide').cancel().setOptions(options);
        return this;
},

get: function(){
        var slide = this.retrieve('slide');
        if (!slide){
                slide = new Fx.Slide(this, {link: 'cancel'});
                this.store('slide', slide);
        }
        return slide;
}

};

Element.implement({

slide: function(how, mode){
        how = how || 'toggle';
        var slide = this.get('slide'), toggle;
        switch (how){
                case 'hide': slide.hide(mode); break;
                case 'show': slide.show(mode); break;
                case 'toggle':
                        var flag = this.retrieve('slide:flag', slide.open);
                        slide[flag ? 'slideOut' : 'slideIn'](mode);
                        this.store('slide:flag', !flag);
                        toggle = true;
                break;
                default: slide.start(how, mode);
        }
        if (!toggle) this.eliminate('slide:flag');
        return this;
}

});

/*


script: Fx.SmoothScroll.js

name: Fx.SmoothScroll

description: Class for creating a smooth scrolling effect to all internal links on the page.

license: MIT-style license

authors:

- Valerio Proietti

requires:

- Core/Slick.Finder
- /Fx.Scroll

provides: [Fx.SmoothScroll]

/

/*<1.2compat>*/var SmoothScroll = /*</1.2compat>*/Fx.SmoothScroll = new Class({

Extends: Fx.Scroll,

options: {
        axes: ['x', 'y']
},

initialize: function(options, context){
        context = context || document;
        this.doc = context.getDocument();
        this.parent(this.doc, options);

        var win = context.getWindow(),
                location = win.location.href.match(/^[^#]*/)[0] + '#',
                links = $$(this.options.links || this.doc.links);

        links.each(function(link){
                if (link.href.indexOf(location) != 0) return;
                var anchor = link.href.substr(location.length);
                if (anchor) this.useLink(link, anchor);
        }, this);

        this.addEvent('complete', function(){
                win.location.hash = this.anchor;
                this.element.scrollTo(this.to[0], this.to[1]);
        }, true);
},

useLink: function(link, anchor){

        link.addEvent('click', function(event){
                var el = document.id(anchor) || this.doc.getElement('a[name=' + anchor + ']');
                if (!el) return;

                event.preventDefault();
                this.toElement(el, this.options.axes).chain(function(){
                        this.fireEvent('scrolledTo', [link, el]);
                }.bind(this));

                this.anchor = anchor;

        }.bind(this));

        return this;
}

});

/*


script: Fx.Sort.js

name: Fx.Sort

description: Defines Fx.Sort, a class that reorders lists with a transition.

license: MIT-style license

authors:

- Aaron Newton

requires:

- Core/Element.Dimensions
- /Fx.Elements
- /Element.Measure

provides: [Fx.Sort]

/

Fx.Sort = new Class({

Extends: Fx.Elements,

options: {
        mode: 'vertical'
},

initialize: function(elements, options){
        this.parent(elements, options);
        this.elements.each(function(el){
                if (el.getStyle('position') == 'static') el.setStyle('position', 'relative');
        });
        this.setDefaultOrder();
},

setDefaultOrder: function(){
        this.currentOrder = this.elements.map(function(el, index){
                return index;
        });
},

sort: function(){
        if (!this.check(arguments)) return this;
        var newOrder = Array.flatten(arguments);

        var top = 0,
                left = 0,
                next = {},
                zero = {},
                vert = this.options.mode == 'vertical';

        var current = this.elements.map(function(el, index){
                var size = el.getComputedSize({styles: ['border', 'padding', 'margin']});
                var val;
                if (vert){
                        val = {
                                top: top,
                                margin: size['margin-top'],
                                height: size.totalHeight
                        };
                        top += val.height - size['margin-top'];
                } else {
                        val = {
                                left: left,
                                margin: size['margin-left'],
                                width: size.totalWidth
                        };
                        left += val.width;
                }
                var plane = vert ? 'top' : 'left';
                zero[index] = {};
                var start = el.getStyle(plane).toInt();
                zero[index][plane] = start || 0;
                return val;
        }, this);

        this.set(zero);
        newOrder = newOrder.map(function(i){ return i.toInt(); });
        if (newOrder.length != this.elements.length){
                this.currentOrder.each(function(index){
                        if (!newOrder.contains(index)) newOrder.push(index);
                });
                if (newOrder.length > this.elements.length)
                        newOrder.splice(this.elements.length-1, newOrder.length - this.elements.length);
        }
        var margin = 0;
        top = left = 0;
        newOrder.each(function(item){
                var newPos = {};
                if (vert){
                        newPos.top = top - current[item].top - margin;
                        top += current[item].height;
                } else {
                        newPos.left = left - current[item].left;
                        left += current[item].width;
                }
                margin = margin + current[item].margin;
                next[item]=newPos;
        }, this);
        var mapped = {};
        Array.clone(newOrder).sort().each(function(index){
                mapped[index] = next[index];
        });
        this.start(mapped);
        this.currentOrder = newOrder;

        return this;
},

rearrangeDOM: function(newOrder){
        newOrder = newOrder || this.currentOrder;
        var parent = this.elements[0].getParent();
        var rearranged = [];
        this.elements.setStyle('opacity', 0);
        //move each element and store the new default order
        newOrder.each(function(index){
                rearranged.push(this.elements[index].inject(parent).setStyles({
                        top: 0,
                        left: 0
                }));
        }, this);
        this.elements.setStyle('opacity', 1);
        this.elements = $$(rearranged);
        this.setDefaultOrder();
        return this;
},

getDefaultOrder: function(){
        return this.elements.map(function(el, index){
                return index;
        });
},

getCurrentOrder: function(){
        return this.currentOrder;
},

forward: function(){
        return this.sort(this.getDefaultOrder());
},

backward: function(){
        return this.sort(this.getDefaultOrder().reverse());
},

reverse: function(){
        return this.sort(this.currentOrder.reverse());
},

sortByElements: function(elements){
        return this.sort(elements.map(function(el){
                return this.elements.indexOf(el);
        }, this));
},

swap: function(one, two){
        if (typeOf(one) == 'element') one = this.elements.indexOf(one);
        if (typeOf(two) == 'element') two = this.elements.indexOf(two);

        var newOrder = Array.clone(this.currentOrder);
        newOrder[this.currentOrder.indexOf(one)] = two;
        newOrder[this.currentOrder.indexOf(two)] = one;

        return this.sort(newOrder);
}

});

/*


script: Drag.js

name: Drag

description: The base Drag Class. Can be used to drag and resize Elements using mouse events.

license: MIT-style license

authors:

- Valerio Proietti
- Tom Occhinno
- Jan Kassens

requires:

- Core/Events
- Core/Options
- Core/Element.Event
- Core/Element.Style
- Core/Element.Dimensions
- /MooTools.More

provides: [Drag] …

/

var Drag = new Class({

Implements: [Events, Options],

options: {/*
        onBeforeStart: function(thisElement){},
        onStart: function(thisElement, event){},
        onSnap: function(thisElement){},
        onDrag: function(thisElement, event){},
        onCancel: function(thisElement){},
        onComplete: function(thisElement, event){},*/
        snap: 6,
        unit: 'px',
        grid: false,
        style: true,
        limit: false,
        handle: false,
        invert: false,
        preventDefault: false,
        stopPropagation: false,
        modifiers: {x: 'left', y: 'top'}
},

initialize: function(){
        var params = Array.link(arguments, {
                'options': Type.isObject,
                'element': function(obj){
                        return obj != null;
                }
        });

        this.element = document.id(params.element);
        this.document = this.element.getDocument();
        this.setOptions(params.options || {});
        var htype = typeOf(this.options.handle);
        this.handles = ((htype == 'array' || htype == 'collection') ? $$(this.options.handle) : document.id(this.options.handle)) || this.element;
        this.mouse = {'now': {}, 'pos': {}};
        this.value = {'start': {}, 'now': {}};

        this.selection = (Browser.ie) ? 'selectstart' : 'mousedown';

        if (Browser.ie && !Drag.ondragstartFixed){
                document.ondragstart = Function.from(false);
                Drag.ondragstartFixed = true;
        }

        this.bound = {
                start: this.start.bind(this),
                check: this.check.bind(this),
                drag: this.drag.bind(this),
                stop: this.stop.bind(this),
                cancel: this.cancel.bind(this),
                eventStop: Function.from(false)
        };
        this.attach();
},

attach: function(){
        this.handles.addEvent('mousedown', this.bound.start);
        return this;
},

detach: function(){
        this.handles.removeEvent('mousedown', this.bound.start);
        return this;
},

start: function(event){
        var options = this.options;

        if (event.rightClick) return;

        if (options.preventDefault) event.preventDefault();
        if (options.stopPropagation) event.stopPropagation();
        this.mouse.start = event.page;

        this.fireEvent('beforeStart', this.element);

        var limit = options.limit;
        this.limit = {x: [], y: []};

        var z, coordinates;
        for (z in options.modifiers){
                if (!options.modifiers[z]) continue;

                var style = this.element.getStyle(options.modifiers[z]);

                // Some browsers (IE and Opera) don't always return pixels.
                if (style && !style.match(/px$/)){
                        if (!coordinates) coordinates = this.element.getCoordinates(this.element.getOffsetParent());
                        style = coordinates[options.modifiers[z]];
                }

                if (options.style) this.value.now[z] = (style || 0).toInt();
                else this.value.now[z] = this.element[options.modifiers[z]];

                if (options.invert) this.value.now[z] *= -1;

                this.mouse.pos[z] = event.page[z] - this.value.now[z];

                if (limit && limit[z]){
                        var i = 2;
                        while (i--){
                                var limitZI = limit[z][i];
                                if (limitZI || limitZI === 0) this.limit[z][i] = (typeof limitZI == 'function') ? limitZI() : limitZI;
                        }
                }
        }

        if (typeOf(this.options.grid) == 'number') this.options.grid = {
                x: this.options.grid,
                y: this.options.grid
        };

        var events = {
                mousemove: this.bound.check,
                mouseup: this.bound.cancel
        };
        events[this.selection] = this.bound.eventStop;
        this.document.addEvents(events);
},

check: function(event){
        if (this.options.preventDefault) event.preventDefault();
        var distance = Math.round(Math.sqrt(Math.pow(event.page.x - this.mouse.start.x, 2) + Math.pow(event.page.y - this.mouse.start.y, 2)));
        if (distance > this.options.snap){
                this.cancel();
                this.document.addEvents({
                        mousemove: this.bound.drag,
                        mouseup: this.bound.stop
                });
                this.fireEvent('start', [this.element, event]).fireEvent('snap', this.element);
        }
},

drag: function(event){
        var options = this.options;

        if (options.preventDefault) event.preventDefault();
        this.mouse.now = event.page;

        for (var z in options.modifiers){
                if (!options.modifiers[z]) continue;
                this.value.now[z] = this.mouse.now[z] - this.mouse.pos[z];

                if (options.invert) this.value.now[z] *= -1;

                if (options.limit && this.limit[z]){
                        if ((this.limit[z][1] || this.limit[z][1] === 0) && (this.value.now[z] > this.limit[z][1])){
                                this.value.now[z] = this.limit[z][1];
                        } else if ((this.limit[z][0] || this.limit[z][0] === 0) && (this.value.now[z] < this.limit[z][0])){
                                this.value.now[z] = this.limit[z][0];
                        }
                }

                if (options.grid[z]) this.value.now[z] -= ((this.value.now[z] - (this.limit[z][0]||0)) % options.grid[z]);

                if (options.style) this.element.setStyle(options.modifiers[z], this.value.now[z] + options.unit);
                else this.element[options.modifiers[z]] = this.value.now[z];
        }

        this.fireEvent('drag', [this.element, event]);
},

cancel: function(event){
        this.document.removeEvents({
                mousemove: this.bound.check,
                mouseup: this.bound.cancel
        });
        if (event){
                this.document.removeEvent(this.selection, this.bound.eventStop);
                this.fireEvent('cancel', this.element);
        }
},

stop: function(event){
        var events = {
                mousemove: this.bound.drag,
                mouseup: this.bound.stop
        };
        events[this.selection] = this.bound.eventStop;
        this.document.removeEvents(events);
        if (event) this.fireEvent('complete', [this.element, event]);
}

});

Element.implement({

makeResizable: function(options){
        var drag = new Drag(this, Object.merge({
                modifiers: {
                        x: 'width',
                        y: 'height'
                }
        }, options));

        this.store('resizer', drag);
        return drag.addEvent('drag', function(){
                this.fireEvent('resize', drag);
        }.bind(this));
}

});

/*


script: Drag.Move.js

name: Drag.Move

description: A Drag extension that provides support for the constraining of draggables to containers and droppables.

license: MIT-style license

authors:

- Valerio Proietti
- Tom Occhinno
- Jan Kassens
- Aaron Newton
- Scott Kyle

requires:

- Core/Element.Dimensions
- /Drag

provides: [Drag.Move]

/

Drag.Move = new Class({

Extends: Drag,

options: {/*
        onEnter: function(thisElement, overed){},
        onLeave: function(thisElement, overed){},
        onDrop: function(thisElement, overed, event){},*/
        droppables: [],
        container: false,
        precalculate: false,
        includeMargins: true,
        checkDroppables: true
},

initialize: function(element, options){
        this.parent(element, options);
        element = this.element;

        this.droppables = $$(this.options.droppables);
        this.container = document.id(this.options.container);

        if (this.container && typeOf(this.container) != 'element')
                this.container = document.id(this.container.getDocument().body);

        if (this.options.style){
                if (this.options.modifiers.x == 'left' && this.options.modifiers.y == 'top'){
                        var parent = element.getOffsetParent(),
                                styles = element.getStyles('left', 'top');
                        if (parent && (styles.left == 'auto' || styles.top == 'auto')){
                                element.setPosition(element.getPosition(parent));
                        }
                }

                if (element.getStyle('position') == 'static') element.setStyle('position', 'absolute');
        }

        this.addEvent('start', this.checkDroppables, true);
        this.overed = null;
},

start: function(event){
        if (this.container) this.options.limit = this.calculateLimit();

        if (this.options.precalculate){
                this.positions = this.droppables.map(function(el){
                        return el.getCoordinates();
                });
        }

        this.parent(event);
},

calculateLimit: function(){
        var element = this.element,
                container = this.container,

                offsetParent = document.id(element.getOffsetParent()) || document.body,
                containerCoordinates = container.getCoordinates(offsetParent),
                elementMargin = {},
                elementBorder = {},
                containerMargin = {},
                containerBorder = {},
                offsetParentPadding = {};

        ['top', 'right', 'bottom', 'left'].each(function(pad){
                elementMargin[pad] = element.getStyle('margin-' + pad).toInt();
                elementBorder[pad] = element.getStyle('border-' + pad).toInt();
                containerMargin[pad] = container.getStyle('margin-' + pad).toInt();
                containerBorder[pad] = container.getStyle('border-' + pad).toInt();
                offsetParentPadding[pad] = offsetParent.getStyle('padding-' + pad).toInt();
        }, this);

        var width = element.offsetWidth + elementMargin.left + elementMargin.right,
                height = element.offsetHeight + elementMargin.top + elementMargin.bottom,
                left = 0,
                top = 0,
                right = containerCoordinates.right - containerBorder.right - width,
                bottom = containerCoordinates.bottom - containerBorder.bottom - height;

        if (this.options.includeMargins){
                left += elementMargin.left;
                top += elementMargin.top;
        } else {
                right += elementMargin.right;
                bottom += elementMargin.bottom;
        }

        if (element.getStyle('position') == 'relative'){
                var coords = element.getCoordinates(offsetParent);
                coords.left -= element.getStyle('left').toInt();
                coords.top -= element.getStyle('top').toInt();

                left -= coords.left;
                top -= coords.top;
                if (container.getStyle('position') != 'relative'){
                        left += containerBorder.left;
                        top += containerBorder.top;
                }
                right += elementMargin.left - coords.left;
                bottom += elementMargin.top - coords.top;

                if (container != offsetParent){
                        left += containerMargin.left + offsetParentPadding.left;
                        top += ((Browser.ie6 || Browser.ie7) ? 0 : containerMargin.top) + offsetParentPadding.top;
                }
        } else {
                left -= elementMargin.left;
                top -= elementMargin.top;
                if (container != offsetParent){
                        left += containerCoordinates.left + containerBorder.left;
                        top += containerCoordinates.top + containerBorder.top;
                }
        }

        return {
                x: [left, right],
                y: [top, bottom]
        };
},

getDroppableCoordinates: function(element){
        var position = element.getCoordinates();
        if (element.getStyle('position') == 'fixed'){
                var scroll = window.getScroll();
                position.left += scroll.x;
                position.right += scroll.x;
                position.top += scroll.y;
                position.bottom += scroll.y;
        }
        return position;
},

checkDroppables: function(){
        var overed = this.droppables.filter(function(el, i){
                el = this.positions ? this.positions[i] : this.getDroppableCoordinates(el);
                var now = this.mouse.now;
                return (now.x > el.left && now.x < el.right && now.y < el.bottom && now.y > el.top);
        }, this).getLast();

        if (this.overed != overed){
                if (this.overed) this.fireEvent('leave', [this.element, this.overed]);
                if (overed) this.fireEvent('enter', [this.element, overed]);
                this.overed = overed;
        }
},

drag: function(event){
        this.parent(event);
        if (this.options.checkDroppables && this.droppables.length) this.checkDroppables();
},

stop: function(event){
        this.checkDroppables();
        this.fireEvent('drop', [this.element, this.overed, event]);
        this.overed = null;
        return this.parent(event);
}

});

Element.implement({

makeDraggable: function(options){
        var drag = new Drag.Move(this, options);
        this.store('dragger', drag);
        return drag;
}

});

/*


script: Sortables.js

name: Sortables

description: Class for creating a drag and drop sorting interface for lists of items.

license: MIT-style license

authors:

- Tom Occhino

requires:

- Core/Fx.Morph
- /Drag.Move

provides: [Sortables]

/

var Sortables = new Class({

Implements: [Events, Options],

options: {/*
        onSort: function(element, clone){},
        onStart: function(element, clone){},
        onComplete: function(element){},*/
        opacity: 1,
        clone: false,
        revert: false,
        handle: false,
        dragOptions: {}/*<1.2compat>*/,
        snap: 4,
        constrain: false,
        preventDefault: false
        /*</1.2compat>*/
},

initialize: function(lists, options){
        this.setOptions(options);

        this.elements = [];
        this.lists = [];
        this.idle = true;

        this.addLists($$(document.id(lists) || lists));

        if (!this.options.clone) this.options.revert = false;
        if (this.options.revert) this.effect = new Fx.Morph(null, Object.merge({
                duration: 250,
                link: 'cancel'
        }, this.options.revert));
},

attach: function(){
        this.addLists(this.lists);
        return this;
},

detach: function(){
        this.lists = this.removeLists(this.lists);
        return this;
},

addItems: function(){
        Array.flatten(arguments).each(function(element){
                this.elements.push(element);
                var start = element.retrieve('sortables:start', function(event){
                        this.start.call(this, event, element);
                }.bind(this));
                (this.options.handle ? element.getElement(this.options.handle) || element : element).addEvent('mousedown', start);
        }, this);
        return this;
},

addLists: function(){
        Array.flatten(arguments).each(function(list){
                this.lists.include(list);
                this.addItems(list.getChildren());
        }, this);
        return this;
},

removeItems: function(){
        return $$(Array.flatten(arguments).map(function(element){
                this.elements.erase(element);
                var start = element.retrieve('sortables:start');
                (this.options.handle ? element.getElement(this.options.handle) || element : element).removeEvent('mousedown', start);

                return element;
        }, this));
},

removeLists: function(){
        return $$(Array.flatten(arguments).map(function(list){
                this.lists.erase(list);
                this.removeItems(list.getChildren());

                return list;
        }, this));
},

getClone: function(event, element){
        if (!this.options.clone) return new Element(element.tagName).inject(document.body);
        if (typeOf(this.options.clone) == 'function') return this.options.clone.call(this, event, element, this.list);
        var clone = element.clone(true).setStyles({
                margin: 0,
                position: 'absolute',
                visibility: 'hidden',
                width: element.getStyle('width')
        }).addEvent('mousedown', function(event){
                element.fireEvent('mousedown', event);
        });
        //prevent the duplicated radio inputs from unchecking the real one
        if (clone.get('html').test('radio')){
                clone.getElements('input[type=radio]').each(function(input, i){
                        input.set('name', 'clone_' + i);
                        if (input.get('checked')) element.getElements('input[type=radio]')[i].set('checked', true);
                });
        }

        return clone.inject(this.list).setPosition(element.getPosition(element.getOffsetParent()));
},

getDroppables: function(){
        var droppables = this.list.getChildren().erase(this.clone).erase(this.element);
        if (!this.options.constrain) droppables.append(this.lists).erase(this.list);
        return droppables;
},

insert: function(dragging, element){
        var where = 'inside';
        if (this.lists.contains(element)){
                this.list = element;
                this.drag.droppables = this.getDroppables();
        } else {
                where = this.element.getAllPrevious().contains(element) ? 'before' : 'after';
        }
        this.element.inject(element, where);
        this.fireEvent('sort', [this.element, this.clone]);
},

start: function(event, element){
        if (
                !this.idle ||
                event.rightClick ||
                ['button', 'input', 'a', 'textarea'].contains(event.target.get('tag'))
        ) return;

        this.idle = false;
        this.element = element;
        this.opacity = element.get('opacity');
        this.list = element.getParent();
        this.clone = this.getClone(event, element);

        this.drag = new Drag.Move(this.clone, Object.merge({
                /*<1.2compat>*/
                preventDefault: this.options.preventDefault,
                snap: this.options.snap,
                container: this.options.constrain && this.element.getParent(),
                /*</1.2compat>*/
                droppables: this.getDroppables()
        }, this.options.dragOptions)).addEvents({
                onSnap: function(){
                        event.stop();
                        this.clone.setStyle('visibility', 'visible');
                        this.element.set('opacity', this.options.opacity || 0);
                        this.fireEvent('start', [this.element, this.clone]);
                }.bind(this),
                onEnter: this.insert.bind(this),
                onCancel: this.end.bind(this),
                onComplete: this.end.bind(this)
        });

        this.clone.inject(this.element, 'before');
        this.drag.start(event);
},

end: function(){
        this.drag.detach();
        this.element.set('opacity', this.opacity);
        if (this.effect){
                var dim = this.element.getStyles('width', 'height'),
                        clone = this.clone,
                        pos = clone.computePosition(this.element.getPosition(this.clone.getOffsetParent()));

                var destroy = function(){
                        this.removeEvent('cancel', destroy);
                        clone.destroy();
                };

                this.effect.element = clone;
                this.effect.start({
                        top: pos.top,
                        left: pos.left,
                        width: dim.width,
                        height: dim.height,
                        opacity: 0.25
                }).addEvent('cancel', destroy).chain(destroy);
        } else {
                this.clone.destroy();
        }
        this.reset();
},

reset: function(){
        this.idle = true;
        this.fireEvent('complete', this.element);
},

serialize: function(){
        var params = Array.link(arguments, {
                modifier: Type.isFunction,
                index: function(obj){
                        return obj != null;
                }
        });
        var serial = this.lists.map(function(list){
                return list.getChildren().map(params.modifier || function(element){
                        return element.get('id');
                }, this);
        }, this);

        var index = params.index;
        if (this.lists.length == 1) index = 0;
        return (index || index === 0) && index >= 0 && index < this.lists.length ? serial[index] : serial;
}

});

/*


script: Request.JSONP.js

name: Request.JSONP

description: Defines Request.JSONP, a class for cross domain javascript via script injection.

license: MIT-style license

authors:

- Aaron Newton
- Guillermo Rauch
- Arian Stolwijk

requires:

- Core/Element
- Core/Request
- MooTools.More

provides: [Request.JSONP]

/

Request.JSONP = new Class({

Implements: [Chain, Events, Options],

options: {/*
        onRequest: function(src, scriptElement){},
        onComplete: function(data){},
        onSuccess: function(data){},
        onCancel: function(){},
        onTimeout: function(){},
        onError: function(){}, */
        onRequest: function(src){
                if (this.options.log && window.console && console.log){
                        console.log('JSONP retrieving script with url:' + src);
                }
        },
        onError: function(src){
                if (this.options.log && window.console && console.warn){
                        console.warn('JSONP '+ src +' will fail in Internet Explorer, which enforces a 2083 bytes length limit on URIs');
                }
        },
        url: '',
        callbackKey: 'callback',
        injectScript: document.head,
        data: '',
        link: 'ignore',
        timeout: 0,
        log: false
},

initialize: function(options){
        this.setOptions(options);
},

send: function(options){
        if (!Request.prototype.check.call(this, options)) return this;
        this.running = true;

        var type = typeOf(options);
        if (type == 'string' || type == 'element') options = {data: options};
        options = Object.merge(this.options, options || {});

        var data = options.data;
        switch (typeOf(data)){
                case 'element': data = document.id(data).toQueryString(); break;
                case 'object': case 'hash': data = Object.toQueryString(data);
        }

        var index = this.index = Request.JSONP.counter++;

        var src = options.url +
                (options.url.test('\\?') ? '&' :'?') +
                (options.callbackKey) +
                '=Request.JSONP.request_map.request_'+ index +
                (data ? '&' + data : '');

        if (src.length > 2083) this.fireEvent('error', src);

        Request.JSONP.request_map['request_' + index] = function(){
                this.success(arguments, index);
        }.bind(this);

        var script = this.getScript(src).inject(options.injectScript);
        this.fireEvent('request', [src, script]);

        if (options.timeout) this.timeout.delay(options.timeout, this);

        return this;
},

getScript: function(src){
        if (!this.script) this.script = new Element('script', {
                type: 'text/javascript',
                async: true,
                src: src
        });
        return this.script;
},

success: function(args, index){
        if (!this.running) return;
        this.clear()
                .fireEvent('complete', args).fireEvent('success', args)
                .callChain();
},

cancel: function(){
        if (this.running) this.clear().fireEvent('cancel');
        return this;
},

isRunning: function(){
        return !!this.running;
},

clear: function(){
        this.running = false;
        if (this.script){
                this.script.destroy();
                this.script = null;
        }
        return this;
},

timeout: function(){
        if (this.running){
                this.running = false;
                this.fireEvent('timeout', [this.script.get('src'), this.script]).fireEvent('failure').cancel();
        }
        return this;
}

});

Request.JSONP.counter = 0; Request.JSONP.request_map = {};

/*


script: HtmlTable.js

name: HtmlTable

description: Builds table elements with methods to add rows.

license: MIT-style license

authors:

- Aaron Newton

requires:

- Core/Options
- Core/Events
- /Class.Occlude

provides: [HtmlTable]

/

var HtmlTable = new Class({

Implements: [Options, Events, Class.Occlude],

options: {
        properties: {
                cellpadding: 0,
                cellspacing: 0,
                border: 0
        },
        rows: [],
        headers: [],
        footers: []
},

property: 'HtmlTable',

initialize: function(){
        var params = Array.link(arguments, {options: Type.isObject, table: Type.isElement, id: Type.isString});
        this.setOptions(params.options);
        if (!params.table && params.id) params.table = document.id(params.id);
        this.element = params.table || new Element('table', this.options.properties);
        if (this.occlude()) return this.occluded;
        this.build();
},

build: function(){
        this.element.store('HtmlTable', this);

        this.body = document.id(this.element.tBodies[0]) || new Element('tbody').inject(this.element);
        $$(this.body.rows);

        if (this.options.headers.length) this.setHeaders(this.options.headers);
        else this.thead = document.id(this.element.tHead);

        if (this.thead) this.head = this.getHead();
        if (this.options.footers.length) this.setFooters(this.options.footers);

        this.tfoot = document.id(this.element.tFoot);
        if (this.tfoot) this.foot = document.id(this.tfoot.rows[0]);

        this.options.rows.each(function(row){
                this.push(row);
        }, this);
},

toElement: function(){
        return this.element;
},

empty: function(){
        this.body.empty();
        return this;
},

set: function(what, items){
        var target = (what == 'headers') ? 'tHead' : 'tFoot',
                lower = target.toLowerCase();

        this[lower] = (document.id(this.element[target]) || new Element(lower).inject(this.element, 'top')).empty();
        var data = this.push(items, {}, this[lower], what == 'headers' ? 'th' : 'td');

        if (what == 'headers') this.head = this.getHead();
        else this.foot = this.getHead();

        return data;
},

getHead: function(){
        var rows = this.thead.rows;
        return rows.length > 1 ? $$(rows) : rows.length ? document.id(rows[0]) : false;
},

setHeaders: function(headers){
        this.set('headers', headers);
        return this;
},

setFooters: function(footers){
        this.set('footers', footers);
        return this;
},

update: function(tr, row, tag){
        var tds = tr.getChildren(tag || 'td'), last = tds.length - 1;

        row.each(function(data, index){
                var td = tds[index] || new Element(tag || 'td').inject(tr),
                        content = (data ? data.content : '') || data,
                        type = typeOf(content);

                if (data && data.properties) td.set(data.properties);
                if (/(element(s?)|array|collection)/.test(type)) td.empty().adopt(content);
                else td.set('html', content);

                if (index > last) tds.push(td);
                else tds[index] = td;
        });

        return {
                tr: tr,
                tds: tds
        };
},

push: function(row, rowProperties, target, tag, where){
        if (typeOf(row) == 'element' && row.get('tag') == 'tr'){
                row.inject(target || this.body, where);
                return {
                        tr: row,
                        tds: row.getChildren('td')
                };
        }
        return this.update(new Element('tr', rowProperties).inject(target || this.body, where), row, tag);
},

pushMany: function(rows, rowProperties, target, tag, where){
        return rows.map(function(row){
                return this.push(row, rowProperties, target, tag, where);
        }, this);
}

});

['adopt', 'inject', 'wraps', 'grab', 'replaces', 'dispose'].each(function(method){

HtmlTable.implement(method, function(){
        this.element[method].apply(this.element, arguments);
        return this;
});

});

/*


name: Element.Event.Pseudos.Keys

description: Adds functionality fire events if certain keycombinations are pressed

license: MIT-style license

authors:

- Arian Stolwijk

requires: [Element.Event.Pseudos]

provides: [Element.Event.Pseudos.Keys]

/

(function(){

var keysStoreKey = '$moo:keys-pressed',

keysKeyupStoreKey = '$moo:keys-keyup';

DOMEvent.definePseudo('keys', function(split, fn, args){

var event = args[0],
        keys = [],
        pressed = this.retrieve(keysStoreKey, []);

keys.append(split.value.replace('++', function(){
        keys.push('+'); // shift++ and shift+++a
        return '';
}).split('+'));

pressed.include(event.key);

if (keys.every(function(key){
        return pressed.contains(key);
})) fn.apply(this, args);

this.store(keysStoreKey, pressed);

if (!this.retrieve(keysKeyupStoreKey)){
        var keyup = function(event){
                (function(){
                        pressed = this.retrieve(keysStoreKey, []).erase(event.key);
                        this.store(keysStoreKey, pressed);
                }).delay(0, this); // Fix for IE
        };
        this.store(keysKeyupStoreKey, keyup).addEvent('keyup', keyup);
}

});

DOMEvent.defineKeys({

'16': 'shift',
'17': 'control',
'18': 'alt',
'20': 'capslock',
'33': 'pageup',
'34': 'pagedown',
'35': 'end',
'36': 'home',
'144': 'numlock',
'145': 'scrolllock',
'186': ';',
'187': '=',
'188': ',',
'190': '.',
'191': '/',
'192': '`',
'219': '[',
'220': '\\',
'221': ']',
'222': "'",
'107': '+'

}).defineKey(Browser.firefox ? 109 : 189, '-');

})();

/*


script: Keyboard.js

name: Keyboard

description: KeyboardEvents used to intercept events on a class for keyboard and format modifiers in a specific order so as to make alt+shift+c the same as shift+alt+c.

license: MIT-style license

authors:

- Perrin Westrich
- Aaron Newton
- Scott Kyle

requires:

- Core/Events
- Core/Options
- Core/Element.Event
- Element.Event.Pseudos.Keys

provides: [Keyboard]

/

(function(){

     var Keyboard = this.Keyboard = new Class({

             Extends: Events,

             Implements: [Options],

             options: {/*
                     onActivate: function(){},
                     onDeactivate: function(){},*/
                     defaultEventType: 'keydown',
                     active: false,
                     manager: null,
                     events: {},
                     nonParsedEvents: ['activate', 'deactivate', 'onactivate', 'ondeactivate', 'changed', 'onchanged']
             },

             initialize: function(options){
                     if (options && options.manager){
                             this._manager = options.manager;
                             delete options.manager;
                     }
                     this.setOptions(options);
                     this._setup();
             },

             addEvent: function(type, fn, internal){
                     return this.parent(Keyboard.parse(type, this.options.defaultEventType, this.options.nonParsedEvents), fn, internal);
             },

             removeEvent: function(type, fn){
                     return this.parent(Keyboard.parse(type, this.options.defaultEventType, this.options.nonParsedEvents), fn);
             },

             toggleActive: function(){
                     return this[this.isActive() ? 'deactivate' : 'activate']();
             },

             activate: function(instance){
                     if (instance){
                             if (instance.isActive()) return this;
                             //if we're stealing focus, store the last keyboard to have it so the relinquish command works
                             if (this._activeKB && instance != this._activeKB){
                                     this.previous = this._activeKB;
                                     this.previous.fireEvent('deactivate');
                             }
                             //if we're enabling a child, assign it so that events are now passed to it
                             this._activeKB = instance.fireEvent('activate');
                             Keyboard.manager.fireEvent('changed');
                     } else if (this._manager){
                             //else we're enabling ourselves, we must ask our parent to do it for us
                             this._manager.activate(this);
                     }
                     return this;
             },

             isActive: function(){
                     return this._manager ? (this._manager._activeKB == this) : (Keyboard.manager == this);
             },

             deactivate: function(instance){
                     if (instance){
                             if (instance === this._activeKB){
                                     this._activeKB = null;
                                     instance.fireEvent('deactivate');
                                     Keyboard.manager.fireEvent('changed');
                             }
                     } else if (this._manager){
                             this._manager.deactivate(this);
                     }
                     return this;
             },

             relinquish: function(){
                     if (this.isActive() && this._manager && this._manager.previous) this._manager.activate(this._manager.previous);
                     else this.deactivate();
                     return this;
             },

             //management logic
             manage: function(instance){
                     if (instance._manager) instance._manager.drop(instance);
                     this._instances.push(instance);
                     instance._manager = this;
                     if (!this._activeKB) this.activate(instance);
                     return this;
             },

             drop: function(instance){
                     instance.relinquish();
                     this._instances.erase(instance);
                     if (this._activeKB == instance){
                             if (this.previous && this._instances.contains(this.previous)) this.activate(this.previous);
                             else this._activeKB = this._instances[0];
                     }
                     return this;
             },

             trace: function(){
                     Keyboard.trace(this);
             },

             each: function(fn){
                     Keyboard.each(this, fn);
             },

             /*
                     PRIVATE METHODS
/

             _instances: [],

             _disable: function(instance){
                     if (this._activeKB == instance) this._activeKB = null;
             },

             _setup: function(){
                     this.addEvents(this.options.events);
                     //if this is the root manager, nothing manages it
                     if (Keyboard.manager && !this._manager) Keyboard.manager.manage(this);
                     if (this.options.active) this.activate();
                     else this.relinquish();
             },

             _handle: function(event, type){
                     //Keyboard.stop(event) prevents key propagation
                     if (event.preventKeyboardPropagation) return;

                     var bubbles = !!this._manager;
                     if (bubbles && this._activeKB){
                             this._activeKB._handle(event, type);
                             if (event.preventKeyboardPropagation) return;
                     }
                     this.fireEvent(type, event);

                     if (!bubbles && this._activeKB) this._activeKB._handle(event, type);
             }

     });

     var parsed = {};
     var modifiers = ['shift', 'control', 'alt', 'meta'];
     var regex = /^(?:shift|control|ctrl|alt|meta)$/;

     Keyboard.parse = function(type, eventType, ignore){
             if (ignore && ignore.contains(type.toLowerCase())) return type;

             type = type.toLowerCase().replace(/^(keyup|keydown):/, function($0, $1){
                     eventType = $1;
                     return '';
             });

             if (!parsed[type]){
                     var key, mods = {};
                     type.split('+').each(function(part){
                             if (regex.test(part)) mods[part] = true;
                             else key = part;
                     });

                     mods.control = mods.control || mods.ctrl; // allow both control and ctrl

                     var keys = [];
                     modifiers.each(function(mod){
                             if (mods[mod]) keys.push(mod);
                     });

                     if (key) keys.push(key);
                     parsed[type] = keys.join('+');
             }

             return eventType + ':keys(' + parsed[type] + ')';
     };

     Keyboard.each = function(keyboard, fn){
             var current = keyboard || Keyboard.manager;
             while (current){
                     fn.run(current);
                     current = current._activeKB;
             }
     };

     Keyboard.stop = function(event){
             event.preventKeyboardPropagation = true;
     };

     Keyboard.manager = new Keyboard({
             active: true
     });

     Keyboard.trace = function(keyboard){
             keyboard = keyboard || Keyboard.manager;
             var hasConsole = window.console && console.log;
             if (hasConsole) console.log('the following items have focus: ');
             Keyboard.each(keyboard, function(current){
                     if (hasConsole) console.log(document.id(current.widget) || current.wiget || current);
             });
     };

     var handler = function(event){
             var keys = [];
             modifiers.each(function(mod){
                     if (event[mod]) keys.push(mod);
             });

             if (!regex.test(event.key)) keys.push(event.key);
             Keyboard.manager._handle(event, event.type + ':keys(' + keys.join('+') + ')');
     };

     document.addEvents({
             'keyup': handler,
             'keydown': handler
     });

})();

/*


script: Keyboard.Extras.js

name: Keyboard.Extras

description: Enhances Keyboard by adding the ability to name and describe keyboard shortcuts, and the ability to grab shortcuts by name and bind the shortcut to different keys.

license: MIT-style license

authors:

- Perrin Westrich

requires:

- /Keyboard
- /MooTools.More

provides: [Keyboard.Extras]

/

Keyboard.prototype.options.nonParsedEvents.combine(['rebound', 'onrebound']);

Keyboard.implement({

      /*
              shortcut should be in the format of:
              {
                      'keys': 'shift+s', // the default to add as an event.
                      'description': 'blah blah blah', // a brief description of the functionality.
                      'handler': function(){} // the event handler to run when keys are pressed.
              }
/
      addShortcut: function(name, shortcut){
              this._shortcuts = this._shortcuts || [];
              this._shortcutIndex = this._shortcutIndex || {};

              shortcut.getKeyboard = Function.from(this);
              shortcut.name = name;
              this._shortcutIndex[name] = shortcut;
              this._shortcuts.push(shortcut);
              if (shortcut.keys) this.addEvent(shortcut.keys, shortcut.handler);
              return this;
      },

      addShortcuts: function(obj){
              for (var name in obj) this.addShortcut(name, obj[name]);
              return this;
      },

      removeShortcut: function(name){
              var shortcut = this.getShortcut(name);
              if (shortcut && shortcut.keys){
                      this.removeEvent(shortcut.keys, shortcut.handler);
                      delete this._shortcutIndex[name];
                      this._shortcuts.erase(shortcut);
              }
              return this;
      },

      removeShortcuts: function(names){
              names.each(this.removeShortcut, this);
              return this;
      },

      getShortcuts: function(){
              return this._shortcuts || [];
      },

      getShortcut: function(name){
              return (this._shortcutIndex || {})[name];
      }

});

Keyboard.rebind = function(newKeys, shortcuts){

Array.from(shortcuts).each(function(shortcut){
        shortcut.getKeyboard().removeEvent(shortcut.keys, shortcut.handler);
        shortcut.getKeyboard().addEvent(newKeys, shortcut.handler);
        shortcut.keys = newKeys;
        shortcut.getKeyboard().fireEvent('rebound');
});

};

Keyboard.getActiveShortcuts = function(keyboard){

var activeKBS = [], activeSCS = [];
Keyboard.each(keyboard, [].push.bind(activeKBS));
activeKBS.each(function(kb){ activeSCS.extend(kb.getShortcuts()); });
return activeSCS;

};

Keyboard.getShortcut = function(name, keyboard, opts){

opts = opts || {};
var shortcuts = opts.many ? [] : null,
        set = opts.many ? function(kb){
                        var shortcut = kb.getShortcut(name);
                        if (shortcut) shortcuts.push(shortcut);
                } : function(kb){
                        if (!shortcuts) shortcuts = kb.getShortcut(name);
                };
Keyboard.each(keyboard, set);
return shortcuts;

};

Keyboard.getShortcuts = function(name, keyboard){

return Keyboard.getShortcut(name, keyboard, { many: true });

};

/*


script: HtmlTable.Select.js

name: HtmlTable.Select

description: Builds a stripy, sortable table with methods to add rows. Rows can be selected with the mouse or keyboard navigation.

license: MIT-style license

authors:

- Harald Kirschner
- Aaron Newton

requires:

- /Keyboard
- /Keyboard.Extras
- /HtmlTable
- /Class.refactor
- /Element.Delegation
- /Element.Shortcuts

provides: [HtmlTable.Select]

/

HtmlTable = Class.refactor(HtmlTable, {

options: {
        /*onRowFocus: function(){},
        onRowUnfocus: function(){},*/
        useKeyboard: true,
        classRowSelected: 'table-tr-selected',
        classRowHovered: 'table-tr-hovered',
        classSelectable: 'table-selectable',
        shiftForMultiSelect: true,
        allowMultiSelect: true,
        selectable: false,
        selectHiddenRows: false
},

initialize: function(){
        this.previous.apply(this, arguments);
        if (this.occluded) return this.occluded;

        this.selectedRows = new Elements();

        if (!this.bound) this.bound = {};
        this.bound.mouseleave = this.mouseleave.bind(this);
        this.bound.clickRow = this.clickRow.bind(this);
        this.bound.activateKeyboard = function(){
                if (this.keyboard && this.selectEnabled) this.keyboard.activate();
        }.bind(this);

        if (this.options.selectable) this.enableSelect();
},

empty: function(){
        this.selectNone();
        return this.previous();
},

enableSelect: function(){
        this.selectEnabled = true;
        this.attachSelects();
        this.element.addClass(this.options.classSelectable);
        return this;
},

disableSelect: function(){
        this.selectEnabled = false;
        this.attachSelects(false);
        this.element.removeClass(this.options.classSelectable);
        return this;
},

push: function(){
        var ret = this.previous.apply(this, arguments);
        this.updateSelects();
        return ret;
},

toggleRow: function(row){
        return this[(this.isSelected(row) ? 'de' : '') + 'selectRow'](row);
},

selectRow: function(row, _nocheck){
        //private variable _nocheck: boolean whether or not to confirm the row is in the table body
        //added here for optimization when selecting ranges
        if (this.isSelected(row) || (!_nocheck && !this.body.getChildren().contains(row))) return;
        if (!this.options.allowMultiSelect) this.selectNone();

        if (!this.isSelected(row)){
                this.selectedRows.push(row);
                row.addClass(this.options.classRowSelected);
                this.fireEvent('rowFocus', [row, this.selectedRows]);
                this.fireEvent('stateChanged');
        }

        this.focused = row;
        document.clearSelection();

        return this;
},

isSelected: function(row){
        return this.selectedRows.contains(row);
},

getSelected: function(){
        return this.selectedRows;
},

getSelected: function(){
        return this.selectedRows;
},

serialize: function(){
        var previousSerialization = this.previous.apply(this, arguments) || {};
        if (this.options.selectable){
                previousSerialization.selectedRows = this.selectedRows.map(function(row){
                        return Array.indexOf(this.body.rows, row);
                }.bind(this));
        }
        return previousSerialization;
},

restore: function(tableState){
        if(this.options.selectable && tableState.selectedRows){
                tableState.selectedRows.each(function(index){
                        this.selectRow(this.body.rows[index]);
                }.bind(this));
        }
        this.previous.apply(this, arguments);
},

deselectRow: function(row, _nocheck){
        if (!this.isSelected(row) || (!_nocheck && !this.body.getChildren().contains(row))) return;

        this.selectedRows = new Elements(Array.from(this.selectedRows).erase(row));
        row.removeClass(this.options.classRowSelected);
        this.fireEvent('rowUnfocus', [row, this.selectedRows]);
        this.fireEvent('stateChanged');
        return this;
},

selectAll: function(selectNone){
        if (!selectNone && !this.options.allowMultiSelect) return;
        this.selectRange(0, this.body.rows.length, selectNone);
        return this;
},

selectNone: function(){
        return this.selectAll(true);
},

selectRange: function(startRow, endRow, _deselect){
        if (!this.options.allowMultiSelect && !_deselect) return;
        var method = _deselect ? 'deselectRow' : 'selectRow',
                rows = Array.clone(this.body.rows);

        if (typeOf(startRow) == 'element') startRow = rows.indexOf(startRow);
        if (typeOf(endRow) == 'element') endRow = rows.indexOf(endRow);
        endRow = endRow < rows.length - 1 ? endRow : rows.length - 1;

        if (endRow < startRow){
                var tmp = startRow;
                startRow = endRow;
                endRow = tmp;
        }

        for (var i = startRow; i <= endRow; i++){
                if (this.options.selectHiddenRows || rows[i].isDisplayed()) this[method](rows[i], true);
        }

        return this;
},

deselectRange: function(startRow, endRow){
        this.selectRange(startRow, endRow, true);
},

getSelected: function(){
        return this.selectedRows;
},

/*

       Private methods:
/

       enterRow: function(row){
               if (this.hovered) this.hovered = this.leaveRow(this.hovered);
               this.hovered = row.addClass(this.options.classRowHovered);
       },

       leaveRow: function(row){
               row.removeClass(this.options.classRowHovered);
       },

       updateSelects: function(){
               Array.each(this.body.rows, function(row){
                       var binders = row.retrieve('binders');
                       if (!binders && !this.selectEnabled) return;
                       if (!binders){
                               binders = {
                                       mouseenter: this.enterRow.pass([row], this),
                                       mouseleave: this.leaveRow.pass([row], this)
                               };
                               row.store('binders', binders);
                       }
                       if (this.selectEnabled) row.addEvents(binders);
                       else row.removeEvents(binders);
               }, this);
       },

       shiftFocus: function(offset, event){
               if (!this.focused) return this.selectRow(this.body.rows[0], event);
               var to = this.getRowByOffset(offset, this.options.selectHiddenRows);
               if (to === null || this.focused == this.body.rows[to]) return this;
               this.toggleRow(this.body.rows[to], event);
       },

       clickRow: function(event, row){
               var selecting = (event.shift || event.meta || event.control) && this.options.shiftForMultiSelect;
               if (!selecting && !(event.rightClick && this.isSelected(row) && this.options.allowMultiSelect)) this.selectNone();

               if (event.rightClick) this.selectRow(row);
               else this.toggleRow(row);

               if (event.shift){
                       this.selectRange(this.rangeStart || this.body.rows[0], row, this.rangeStart ? !this.isSelected(row) : true);
                       this.focused = row;
               }
               this.rangeStart = row;
       },

       getRowByOffset: function(offset, includeHiddenRows){
               if (!this.focused) return 0;
               var index = Array.indexOf(this.body.rows, this.focused);
               if ((index == 0 && offset < 0) || (index == this.body.rows.length -1 && offset > 0)) return null;
               if (includeHiddenRows){
                       index += offset;
               } else {
                       var limit = 0,
                           count = 0;
                       if (offset > 0){
                               while (count < offset && index < this.body.rows.length -1){
                                       if (this.body.rows[++index].isDisplayed()) count++;
                               }
                       } else {
                               while (count > offset && index > 0){
                                       if (this.body.rows[--index].isDisplayed()) count--;
                               }
                       }
               }
               return index;
       },

       attachSelects: function(attach){
               attach = attach != null ? attach : true;

               var method = attach ? 'addEvents' : 'removeEvents';
               this.element[method]({
                       mouseleave: this.bound.mouseleave,
                       click: this.bound.activateKeyboard
               });

               this.body[method]({
                       'click:relay(tr)': this.bound.clickRow,
                       'contextmenu:relay(tr)': this.bound.clickRow
               });

               if (this.options.useKeyboard || this.keyboard){
                       if (!this.keyboard) this.keyboard = new Keyboard();
                       if (!this.selectKeysDefined){
                               this.selectKeysDefined = true;
                               var timer, held;

                               var move = function(offset){
                                       var mover = function(e){
                                               clearTimeout(timer);
                                               e.preventDefault();
                                               var to = this.body.rows[this.getRowByOffset(offset, this.options.selectHiddenRows)];
                                               if (e.shift && to && this.isSelected(to)){
                                                       this.deselectRow(this.focused);
                                                       this.focused = to;
                                               } else {
                                                       if (to && (!this.options.allowMultiSelect || !e.shift)){
                                                               this.selectNone();
                                                       }
                                                       this.shiftFocus(offset, e);
                                               }

                                               if (held){
                                                       timer = mover.delay(100, this, e);
                                               } else {
                                                       timer = (function(){
                                                               held = true;
                                                               mover(e);
                                                       }).delay(400);
                                               }
                                       }.bind(this);
                                       return mover;
                               }.bind(this);

                               var clear = function(){
                                       clearTimeout(timer);
                                       held = false;
                               };

                               this.keyboard.addEvents({
                                       'keydown:shift+up': move(-1),
                                       'keydown:shift+down': move(1),
                                       'keyup:shift+up': clear,
                                       'keyup:shift+down': clear,
                                       'keyup:up': clear,
                                       'keyup:down': clear
                               });

                               var shiftHint = '';
                               if (this.options.allowMultiSelect && this.options.shiftForMultiSelect && this.options.useKeyboard){
                                       shiftHint = " (Shift multi-selects).";
                               }

                               this.keyboard.addShortcuts({
                                       'Select Previous Row': {
                                               keys: 'up',
                                               shortcut: 'up arrow',
                                               handler: move(-1),
                                               description: 'Select the previous row in the table.' + shiftHint
                                       },
                                       'Select Next Row': {
                                               keys: 'down',
                                               shortcut: 'down arrow',
                                               handler: move(1),
                                               description: 'Select the next row in the table.' + shiftHint
                                       }
                               });

                       }
                       this.keyboard[attach ? 'activate' : 'deactivate']();
               }
               this.updateSelects();
       },

       mouseleave: function(){
               if (this.hovered) this.leaveRow(this.hovered);
       }

});