/* MooTools: the javascript framework. license: MIT-style license. copyright: Copyright (c) 2006-2018 [Valerio Proietti](https://mootools.net/).*/ 
/*!
Web Build: https://mootools.net/core/builder/b7c3eeae94f1c893ddb863093e8282ef
*/
/*
---

name: Core

description: The heart of MooTools.

license: MIT-style license.

copyright: Copyright (c) 2006-2015 [Valerio Proietti](https://github.com/kamicane/).

authors: The MooTools production team (http://mootools.net/developers/)

inspiration:
  - Class implementation inspired by [Base.js](http://dean.edwards.name/weblog/2006/03/base/) Copyright (c) 2006 Dean Edwards, [GNU Lesser General Public License](http://opensource.org/licenses/lgpl-license.php)
  - Some functionality inspired by [Prototype.js](http://prototypejs.org) Copyright (c) 2005-2007 Sam Stephenson, [MIT License](http://opensource.org/licenses/mit-license.php)

provides: [Core, MooTools, Type, typeOf, instanceOf, Native]

...
*/
/*! MooTools: the javascript framework. license: MIT-style license. copyright: Copyright (c) 2006-2015 [Valerio Proietti](https://github.com/kamicane/).*/
(function(){

this.MooTools = {
	version: '1.6.0',
	build: '529422872adfff401b901b8b6c7ca5114ee95e2b'
};

// typeOf, instanceOf

var typeOf = this.typeOf = function(item){
	if (item == null) return 'null';
	if (item.$family != null) return item.$family();

	if (item.nodeName){
		if (item.nodeType == 1) return 'element';
		if (item.nodeType == 3) return (/\S/).test(item.nodeValue) ? 'textnode' : 'whitespace';
	} else if (typeof item.length == 'number'){
		if ('callee' in item) return 'arguments';
		if ('item' in item) return 'collection';
	}

	return typeof item;
};

var instanceOf = this.instanceOf = function(item, object){
	if (item == null) return false;
	var constructor = item.$constructor || item.constructor;
	while (constructor){
		if (constructor === object) return true;
		constructor = constructor.parent;
	}
	/*<ltIE8>*/
	if (!item.hasOwnProperty) return false;
	/*</ltIE8>*/
	return item instanceof object;
};

var hasOwnProperty = Object.prototype.hasOwnProperty;

/*<ltIE8>*/
var enumerables = true;
for (var i in {toString: 1}) enumerables = null;
if (enumerables) enumerables = ['hasOwnProperty', 'valueOf', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'constructor'];
function forEachObjectEnumberableKey(object, fn, bind){
	if (enumerables) for (var i = enumerables.length; i--;){
		var k = enumerables[i];
		// signature has key-value, so overloadSetter can directly pass the
		// method function, without swapping arguments.
		if (hasOwnProperty.call(object, k)) fn.call(bind, k, object[k]);
	}
}
/*</ltIE8>*/

// Function overloading

var Function = this.Function;

Function.prototype.overloadSetter = function(usePlural){
	var self = this;
	return function(a, b){
		if (a == null) return this;
		if (usePlural || typeof a != 'string'){
			for (var k in a) self.call(this, k, a[k]);
			/*<ltIE8>*/
			forEachObjectEnumberableKey(a, self, this);
			/*</ltIE8>*/
		} else {
			self.call(this, a, b);
		}
		return this;
	};
};

Function.prototype.overloadGetter = function(usePlural){
	var self = this;
	return function(a){
		var args, result;
		if (typeof a != 'string') args = a;
		else if (arguments.length > 1) args = arguments;
		else if (usePlural) args = [a];
		if (args){
			result = {};
			for (var i = 0; i < args.length; i++) result[args[i]] = self.call(this, args[i]);
		} else {
			result = self.call(this, a);
		}
		return result;
	};
};

Function.prototype.extend = function(key, value){
	this[key] = value;
}.overloadSetter();

Function.prototype.implement = function(key, value){
	this.prototype[key] = value;
}.overloadSetter();

// From

var slice = Array.prototype.slice;

Array.convert = function(item){
	if (item == null) return [];
	return (Type.isEnumerable(item) && typeof item != 'string') ? (typeOf(item) == 'array') ? item : slice.call(item) : [item];
};

Function.convert = function(item){
	return (typeOf(item) == 'function') ? item : function(){
		return item;
	};
};


Number.convert = function(item){
	var number = parseFloat(item);
	return isFinite(number) ? number : null;
};

String.convert = function(item){
	return item + '';
};



Function.from = Function.convert;
Number.from = Number.convert;
String.from = String.convert;

// hide, protect

Function.implement({

	hide: function(){
		this.$hidden = true;
		return this;
	},

	protect: function(){
		this.$protected = true;
		return this;
	}

});

// Type

var Type = this.Type = function(name, object){
	if (name){
		var lower = name.toLowerCase();
		var typeCheck = function(item){
			return (typeOf(item) == lower);
		};

		Type['is' + name] = typeCheck;
		if (object != null){
			object.prototype.$family = (function(){
				return lower;
			}).hide();
			
		}
	}

	if (object == null) return null;

	object.extend(this);
	object.$constructor = Type;
	object.prototype.$constructor = object;

	return object;
};

var toString = Object.prototype.toString;

Type.isEnumerable = function(item){
	return (item != null && typeof item.length == 'number' && toString.call(item) != '[object Function]' );
};

var hooks = {};

var hooksOf = function(object){
	var type = typeOf(object.prototype);
	return hooks[type] || (hooks[type] = []);
};

var implement = function(name, method){
	if (method && method.$hidden) return;

	var hooks = hooksOf(this);

	for (var i = 0; i < hooks.length; i++){
		var hook = hooks[i];
		if (typeOf(hook) == 'type') implement.call(hook, name, method);
		else hook.call(this, name, method);
	}

	var previous = this.prototype[name];
	if (previous == null || !previous.$protected) this.prototype[name] = method;

	if (this[name] == null && typeOf(method) == 'function') extend.call(this, name, function(item){
		return method.apply(item, slice.call(arguments, 1));
	});
};

var extend = function(name, method){
	if (method && method.$hidden) return;
	var previous = this[name];
	if (previous == null || !previous.$protected) this[name] = method;
};

Type.implement({

	implement: implement.overloadSetter(),

	extend: extend.overloadSetter(),

	alias: function(name, existing){
		implement.call(this, name, this.prototype[existing]);
	}.overloadSetter(),

	mirror: function(hook){
		hooksOf(this).push(hook);
		return this;
	}

});

new Type('Type', Type);

// Default Types

var force = function(name, object, methods){
	var isType = (object != Object),
		prototype = object.prototype;

	if (isType) object = new Type(name, object);

	for (var i = 0, l = methods.length; i < l; i++){
		var key = methods[i],
			generic = object[key],
			proto = prototype[key];

		if (generic) generic.protect();
		if (isType && proto) object.implement(key, proto.protect());
	}

	if (isType){
		var methodsEnumerable = prototype.propertyIsEnumerable(methods[0]);
		object.forEachMethod = function(fn){
			if (!methodsEnumerable) for (var i = 0, l = methods.length; i < l; i++){
				fn.call(prototype, prototype[methods[i]], methods[i]);
			}
			for (var key in prototype) fn.call(prototype, prototype[key], key);
		};
	}

	return force;
};

force('String', String, [
	'charAt', 'charCodeAt', 'concat', 'contains', 'indexOf', 'lastIndexOf', 'match', 'quote', 'replace', 'search',
	'slice', 'split', 'substr', 'substring', 'trim', 'toLowerCase', 'toUpperCase'
])('Array', Array, [
	'pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift', 'concat', 'join', 'slice',
	'indexOf', 'lastIndexOf', 'filter', 'forEach', 'every', 'map', 'some', 'reduce', 'reduceRight', 'contains'
])('Number', Number, [
	'toExponential', 'toFixed', 'toLocaleString', 'toPrecision'
])('Function', Function, [
	'apply', 'call', 'bind'
])('RegExp', RegExp, [
	'exec', 'test'
])('Object', Object, [
	'create', 'defineProperty', 'defineProperties', 'keys',
	'getPrototypeOf', 'getOwnPropertyDescriptor', 'getOwnPropertyNames',
	'preventExtensions', 'isExtensible', 'seal', 'isSealed', 'freeze', 'isFrozen'
])('Date', Date, ['now']);

Object.extend = extend.overloadSetter();

Date.extend('now', function(){
	return +(new Date);
});

new Type('Boolean', Boolean);

// fixes NaN returning as Number

Number.prototype.$family = function(){
	return isFinite(this) ? 'number' : 'null';
}.hide();

// Number.random

Number.extend('random', function(min, max){
	return Math.floor(Math.random() * (max - min + 1) + min);
});

// forEach, each, keys

Array.implement({

	/*<!ES5>*/
	forEach: function(fn, bind){
		for (var i = 0, l = this.length; i < l; i++){
			if (i in this) fn.call(bind, this[i], i, this);
		}
	},
	/*</!ES5>*/

	each: function(fn, bind){
		Array.forEach(this, fn, bind);
		return this;
	}

});

Object.extend({

	keys: function(object){
		var keys = [];
		for (var k in object){
			if (hasOwnProperty.call(object, k)) keys.push(k);
		}
		/*<ltIE8>*/
		forEachObjectEnumberableKey(object, function(k){
			keys.push(k);
		});
		/*</ltIE8>*/
		return keys;
	},

	forEach: function(object, fn, bind){
		Object.keys(object).forEach(function(key){
			fn.call(bind, object[key], key, object);
		});
	}

});

Object.each = Object.forEach;


// Array & Object cloning, Object merging and appending

var cloneOf = function(item){
	switch (typeOf(item)){
		case 'array': return item.clone();
		case 'object': return Object.clone(item);
		default: return item;
	}
};

Array.implement('clone', function(){
	var i = this.length, clone = new Array(i);
	while (i--) clone[i] = cloneOf(this[i]);
	return clone;
});

var mergeOne = function(source, key, current){
	switch (typeOf(current)){
		case 'object':
			if (typeOf(source[key]) == 'object') Object.merge(source[key], current);
			else source[key] = Object.clone(current);
			break;
		case 'array': source[key] = current.clone(); break;
		default: source[key] = current;
	}
	return source;
};

Object.extend({

	merge: function(source, k, v){
		if (typeOf(k) == 'string') return mergeOne(source, k, v);
		for (var i = 1, l = arguments.length; i < l; i++){
			var object = arguments[i];
			for (var key in object) mergeOne(source, key, object[key]);
		}
		return source;
	},

	clone: function(object){
		var clone = {};
		for (var key in object) clone[key] = cloneOf(object[key]);
		return clone;
	},

	append: function(original){
		for (var i = 1, l = arguments.length; i < l; i++){
			var extended = arguments[i] || {};
			for (var key in extended) original[key] = extended[key];
		}
		return original;
	}

});

// Object-less types

['Object', 'WhiteSpace', 'TextNode', 'Collection', 'Arguments'].each(function(name){
	new Type(name);
});

// Unique ID

var UID = Date.now();

String.extend('uniqueID', function(){
	return (UID++).toString(36);
});



})();

/*
---

name: Array

description: Contains Array Prototypes like each, contains, and erase.

license: MIT-style license.

requires: [Type]

provides: Array

...
*/

Array.implement({

	/*<!ES5>*/
	every: function(fn, bind){
		for (var i = 0, l = this.length >>> 0; i < l; i++){
			if ((i in this) && !fn.call(bind, this[i], i, this)) return false;
		}
		return true;
	},

	filter: function(fn, bind){
		var results = [];
		for (var value, i = 0, l = this.length >>> 0; i < l; i++) if (i in this){
			value = this[i];
			if (fn.call(bind, value, i, this)) results.push(value);
		}
		return results;
	},

	indexOf: function(item, from){
		var length = this.length >>> 0;
		for (var i = (from < 0) ? Math.max(0, length + from) : from || 0; i < length; i++){
			if (this[i] === item) return i;
		}
		return -1;
	},

	map: function(fn, bind){
		var length = this.length >>> 0, results = Array(length);
		for (var i = 0; i < length; i++){
			if (i in this) results[i] = fn.call(bind, this[i], i, this);
		}
		return results;
	},

	some: function(fn, bind){
		for (var i = 0, l = this.length >>> 0; i < l; i++){
			if ((i in this) && fn.call(bind, this[i], i, this)) return true;
		}
		return false;
	},
	/*</!ES5>*/

	clean: function(){
		return this.filter(function(item){
			return item != null;
		});
	},

	invoke: function(methodName){
		var args = Array.slice(arguments, 1);
		return this.map(function(item){
			return item[methodName].apply(item, args);
		});
	},

	associate: function(keys){
		var obj = {}, length = Math.min(this.length, keys.length);
		for (var i = 0; i < length; i++) obj[keys[i]] = this[i];
		return obj;
	},

	link: function(object){
		var result = {};
		for (var i = 0, l = this.length; i < l; i++){
			for (var key in object){
				if (object[key](this[i])){
					result[key] = this[i];
					delete object[key];
					break;
				}
			}
		}
		return result;
	},

	contains: function(item, from){
		return this.indexOf(item, from) != -1;
	},

	append: function(array){
		this.push.apply(this, array);
		return this;
	},

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

	getRandom: function(){
		return (this.length) ? this[Number.random(0, this.length - 1)] : null;
	},

	include: function(item){
		if (!this.contains(item)) this.push(item);
		return this;
	},

	combine: function(array){
		for (var i = 0, l = array.length; i < l; i++) this.include(array[i]);
		return this;
	},

	erase: function(item){
		for (var i = this.length; i--;){
			if (this[i] === item) this.splice(i, 1);
		}
		return this;
	},

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

	flatten: function(){
		var array = [];
		for (var i = 0, l = this.length; i < l; i++){
			var type = typeOf(this[i]);
			if (type == 'null') continue;
			array = array.concat((type == 'array' || type == 'collection' || type == 'arguments' || instanceOf(this[i], Array)) ? Array.flatten(this[i]) : this[i]);
		}
		return array;
	},

	pick: function(){
		for (var i = 0, l = this.length; i < l; i++){
			if (this[i] != null) return this[i];
		}
		return null;
	},

	hexToRgb: function(array){
		if (this.length != 3) return null;
		var rgb = this.map(function(value){
			if (value.length == 1) value += value;
			return parseInt(value, 16);
		});
		return (array) ? rgb : 'rgb(' + rgb + ')';
	},

	rgbToHex: function(array){
		if (this.length < 3) return null;
		if (this.length == 4 && this[3] == 0 && !array) return 'transparent';
		var hex = [];
		for (var i = 0; i < 3; i++){
			var bit = (this[i] - 0).toString(16);
			hex.push((bit.length == 1) ? '0' + bit : bit);
		}
		return (array) ? hex : '#' + hex.join('');
	}

});



/*
---

name: Function

description: Contains Function Prototypes like create, bind, pass, and delay.

license: MIT-style license.

requires: Type

provides: Function

...
*/

Function.extend({

	attempt: function(){
		for (var i = 0, l = arguments.length; i < l; i++){
			try {
				return arguments[i]();
			} catch (e){}
		}
		return null;
	}

});

Function.implement({

	attempt: function(args, bind){
		try {
			return this.apply(bind, Array.convert(args));
		} catch (e){}

		return null;
	},

	/*<!ES5-bind>*/
	bind: function(that){
		var self = this,
			args = arguments.length > 1 ? Array.slice(arguments, 1) : null,
			F = function(){};

		var bound = function(){
			var context = that, length = arguments.length;
			if (this instanceof bound){
				F.prototype = self.prototype;
				context = new F;
			}
			var result = (!args && !length)
				? self.call(context)
				: self.apply(context, args && length ? args.concat(Array.slice(arguments)) : args || arguments);
			return context == that ? result : context;
		};
		return bound;
	},
	/*</!ES5-bind>*/

	pass: function(args, bind){
		var self = this;
		if (args != null) args = Array.convert(args);
		return function(){
			return self.apply(bind, args || arguments);
		};
	},

	delay: function(delay, bind, args){
		return setTimeout(this.pass((args == null ? [] : args), bind), delay);
	},

	periodical: function(periodical, bind, args){
		return setInterval(this.pass((args == null ? [] : args), bind), periodical);
	}

});



/*
---

name: Number

description: Contains Number Prototypes like limit, round, times, and ceil.

license: MIT-style license.

requires: Type

provides: Number

...
*/

Number.implement({

	limit: function(min, max){
		return Math.min(max, Math.max(min, this));
	},

	round: function(precision){
		precision = Math.pow(10, precision || 0).toFixed(precision < 0 ? -precision : 0);
		return Math.round(this * precision) / precision;
	},

	times: function(fn, bind){
		for (var i = 0; i < this; i++) fn.call(bind, i, this);
	},

	toFloat: function(){
		return parseFloat(this);
	},

	toInt: function(base){
		return parseInt(this, base || 10);
	}

});

Number.alias('each', 'times');

(function(math){

var methods = {};

math.each(function(name){
	if (!Number[name]) methods[name] = function(){
		return Math[name].apply(null, [this].concat(Array.convert(arguments)));
	};
});

Number.implement(methods);

})(['abs', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'exp', 'floor', 'log', 'max', 'min', 'pow', 'sin', 'sqrt', 'tan']);

/*
---

name: String

description: Contains String Prototypes like camelCase, capitalize, test, and toInt.

license: MIT-style license.

requires: [Type, Array]

provides: String

...
*/

String.implement({

	//<!ES6>
	contains: function(string, index){
		return (index ? String(this).slice(index) : String(this)).indexOf(string) > -1;
	},
	//</!ES6>

	test: function(regex, params){
		return ((typeOf(regex) == 'regexp') ? regex : new RegExp('' + regex, params)).test(this);
	},

	trim: function(){
		return String(this).replace(/^\s+|\s+$/g, '');
	},

	clean: function(){
		return String(this).replace(/\s+/g, ' ').trim();
	},

	camelCase: function(){
		return String(this).replace(/-\D/g, function(match){
			return match.charAt(1).toUpperCase();
		});
	},

	hyphenate: function(){
		return String(this).replace(/[A-Z]/g, function(match){
			return ('-' + match.charAt(0).toLowerCase());
		});
	},

	capitalize: function(){
		return String(this).replace(/\b[a-z]/g, function(match){
			return match.toUpperCase();
		});
	},

	escapeRegExp: function(){
		return String(this).replace(/([-.*+?^${}()|[\]\/\\])/g, '\\$1');
	},

	toInt: function(base){
		return parseInt(this, base || 10);
	},

	toFloat: function(){
		return parseFloat(this);
	},

	hexToRgb: function(array){
		var hex = String(this).match(/^#?(\w{1,2})(\w{1,2})(\w{1,2})$/);
		return (hex) ? hex.slice(1).hexToRgb(array) : null;
	},

	rgbToHex: function(array){
		var rgb = String(this).match(/\d{1,3}/g);
		return (rgb) ? rgb.rgbToHex(array) : null;
	},

	substitute: function(object, regexp){
		return String(this).replace(regexp || (/\\?\{([^{}]+)\}/g), function(match, name){
			if (match.charAt(0) == '\\') return match.slice(1);
			return (object[name] != null) ? object[name] : '';
		});
	}

});



/*
---

name: Browser

description: The Browser Object. Contains Browser initialization, Window and Document, and the Browser Hash.

license: MIT-style license.

requires: [Array, Function, Number, String]

provides: [Browser, Window, Document]

...
*/

(function(){

var document = this.document;
var window = document.window = this;

var parse = function(ua, platform){
	ua = ua.toLowerCase();
	platform = (platform ? platform.toLowerCase() : '');

	// chrome is included in the edge UA, so need to check for edge first,
	// before checking if it's chrome.
	var UA = ua.match(/(edge)[\s\/:]([\w\d\.]+)/);
	if (!UA){
		UA = ua.match(/(opera|ie|firefox|chrome|trident|crios|version)[\s\/:]([\w\d\.]+)?.*?(safari|(?:rv[\s\/:]|version[\s\/:])([\w\d\.]+)|$)/) || [null, 'unknown', 0];
	}

	if (UA[1] == 'trident'){
		UA[1] = 'ie';
		if (UA[4]) UA[2] = UA[4];
	} else if (UA[1] == 'crios'){
		UA[1] = 'chrome';
	}

	platform = ua.match(/ip(?:ad|od|hone)/) ? 'ios' : (ua.match(/(?:webos|android)/) || ua.match(/mac|win|linux/) || ['other'])[0];
	if (platform == 'win') platform = 'windows';

	return {
		extend: Function.prototype.extend,
		name: (UA[1] == 'version') ? UA[3] : UA[1],
		version: parseFloat((UA[1] == 'opera' && UA[4]) ? UA[4] : UA[2]),
		platform: platform
	};
};

var Browser = this.Browser = parse(navigator.userAgent, navigator.platform);

if (Browser.name == 'ie' && document.documentMode){
	Browser.version = document.documentMode;
}

Browser.extend({
	Features: {
		xpath: !!(document.evaluate),
		air: !!(window.runtime),
		query: !!(document.querySelector),
		json: !!(window.JSON)
	},
	parseUA: parse
});



// Request

Browser.Request = (function(){

	var XMLHTTP = function(){
		return new XMLHttpRequest();
	};

	var MSXML2 = function(){
		return new ActiveXObject('MSXML2.XMLHTTP');
	};

	var MSXML = function(){
		return new ActiveXObject('Microsoft.XMLHTTP');
	};

	return Function.attempt(function(){
		XMLHTTP();
		return XMLHTTP;
	}, function(){
		MSXML2();
		return MSXML2;
	}, function(){
		MSXML();
		return MSXML;
	});

})();

Browser.Features.xhr = !!(Browser.Request);



// String scripts

Browser.exec = function(text){
	if (!text) return text;
	if (window.execScript){
		window.execScript(text);
	} else {
		var script = document.createElement('script');
		script.setAttribute('type', 'text/javascript');
		script.text = text;
		document.head.appendChild(script);
		document.head.removeChild(script);
	}
	return text;
};

String.implement('stripScripts', function(exec){
	var scripts = '';
	var text = this.replace(/<script[^>]*>([\s\S]*?)<\/script>/gi, function(all, code){
		scripts += code + '\n';
		return '';
	});
	if (exec === true) Browser.exec(scripts);
	else if (typeOf(exec) == 'function') exec(scripts, text);
	return text;
});

// Window, Document

Browser.extend({
	Document: this.Document,
	Window: this.Window,
	Element: this.Element,
	Event: this.Event
});

this.Window = this.$constructor = new Type('Window', function(){});

this.$family = Function.convert('window').hide();

Window.mirror(function(name, method){
	window[name] = method;
});

this.Document = document.$constructor = new Type('Document', function(){});

document.$family = Function.convert('document').hide();

Document.mirror(function(name, method){
	document[name] = method;
});

document.html = document.documentElement;
if (!document.head) document.head = document.getElementsByTagName('head')[0];

if (document.execCommand) try {
	document.execCommand('BackgroundImageCache', false, true);
} catch (e){}

/*<ltIE9>*/
if (this.attachEvent && !this.addEventListener){
	var unloadEvent = function(){
		this.detachEvent('onunload', unloadEvent);
		document.head = document.html = document.window = null;
		window = this.Window = document = null;
	};
	this.attachEvent('onunload', unloadEvent);
}

// IE fails on collections and <select>.options (refers to <select>)
var arrayFrom = Array.convert;
try {
	arrayFrom(document.html.childNodes);
} catch (e){
	Array.convert = function(item){
		if (typeof item != 'string' && Type.isEnumerable(item) && typeOf(item) != 'array'){
			var i = item.length, array = new Array(i);
			while (i--) array[i] = item[i];
			return array;
		}
		return arrayFrom(item);
	};

	var prototype = Array.prototype,
		slice = prototype.slice;
	['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift', 'concat', 'join', 'slice'].each(function(name){
		var method = prototype[name];
		Array[name] = function(item){
			return method.apply(Array.convert(item), slice.call(arguments, 1));
		};
	});
}
/*</ltIE9>*/



})();

/*
---

name: Class

description: Contains the Class Function for easily creating, extending, and implementing reusable Classes.

license: MIT-style license.

requires: [Array, String, Function, Number]

provides: Class

...
*/

(function(){

var Class = this.Class = new Type('Class', function(params){
	if (instanceOf(params, Function)) params = {initialize: params};

	var newClass = function(){
		reset(this);
		if (newClass.$prototyping) return this;
		this.$caller = null;
		this.$family = null;
		var value = (this.initialize) ? this.initialize.apply(this, arguments) : this;
		this.$caller = this.caller = null;
		return value;
	}.extend(this).implement(params);

	newClass.$constructor = Class;
	newClass.prototype.$constructor = newClass;
	newClass.prototype.parent = parent;

	return newClass;
});

var parent = function(){
	if (!this.$caller) throw new Error('The method "parent" cannot be called.');
	var name = this.$caller.$name,
		parent = this.$caller.$owner.parent,
		previous = (parent) ? parent.prototype[name] : null;
	if (!previous) throw new Error('The method "' + name + '" has no parent.');
	return previous.apply(this, arguments);
};

var reset = function(object){
	for (var key in object){
		var value = object[key];
		switch (typeOf(value)){
			case 'object':
				var F = function(){};
				F.prototype = value;
				object[key] = reset(new F);
				break;
			case 'array': object[key] = value.clone(); break;
		}
	}
	return object;
};

var wrap = function(self, key, method){
	if (method.$origin) method = method.$origin;
	var wrapper = function(){
		if (method.$protected && this.$caller == null) throw new Error('The method "' + key + '" cannot be called.');
		var caller = this.caller, current = this.$caller;
		this.caller = current; this.$caller = wrapper;
		var result = method.apply(this, arguments);
		this.$caller = current; this.caller = caller;
		return result;
	}.extend({$owner: self, $origin: method, $name: key});
	return wrapper;
};

var implement = function(key, value, retain){
	if (Class.Mutators.hasOwnProperty(key)){
		value = Class.Mutators[key].call(this, value);
		if (value == null) return this;
	}

	if (typeOf(value) == 'function'){
		if (value.$hidden) return this;
		this.prototype[key] = (retain) ? value : wrap(this, key, value);
	} else {
		Object.merge(this.prototype, key, value);
	}

	return this;
};

var getInstance = function(klass){
	klass.$prototyping = true;
	var proto = new klass;
	delete klass.$prototyping;
	return proto;
};

Class.implement('implement', implement.overloadSetter());

Class.Mutators = {

	Extends: function(parent){
		this.parent = parent;
		this.prototype = getInstance(parent);
	},

	Implements: function(items){
		Array.convert(items).each(function(item){
			var instance = new item;
			for (var key in instance) implement.call(this, key, instance[key], true);
		}, this);
	}
};

})();

/*
---

name: Class.Extras

description: Contains Utility Classes that can be implemented into your own Classes to ease the execution of many common tasks.

license: MIT-style license.

requires: Class

provides: [Class.Extras, Chain, Events, Options]

...
*/

(function(){

this.Chain = new Class({

	$chain: [],

	chain: function(){
		this.$chain.append(Array.flatten(arguments));
		return this;
	},

	callChain: function(){
		return (this.$chain.length) ? this.$chain.shift().apply(this, arguments) : false;
	},

	clearChain: function(){
		this.$chain.empty();
		return this;
	}

});

var removeOn = function(string){
	return string.replace(/^on([A-Z])/, function(full, first){
		return first.toLowerCase();
	});
};

this.Events = new Class({

	$events: {},

	addEvent: function(type, fn, internal){
		type = removeOn(type);

		

		this.$events[type] = (this.$events[type] || []).include(fn);
		if (internal) fn.internal = true;
		return this;
	},

	addEvents: function(events){
		for (var type in events) this.addEvent(type, events[type]);
		return this;
	},

	fireEvent: function(type, args, delay){
		type = removeOn(type);
		var events = this.$events[type];
		if (!events) return this;
		args = Array.convert(args);
		events.each(function(fn){
			if (delay) fn.delay(delay, this, args);
			else fn.apply(this, args);
		}, this);
		return this;
	},

	removeEvent: function(type, fn){
		type = removeOn(type);
		var events = this.$events[type];
		if (events && !fn.internal){
			var index = events.indexOf(fn);
			if (index != -1) delete events[index];
		}
		return this;
	},

	removeEvents: function(events){
		var type;
		if (typeOf(events) == 'object'){
			for (type in events) this.removeEvent(type, events[type]);
			return this;
		}
		if (events) events = removeOn(events);
		for (type in this.$events){
			if (events && events != type) continue;
			var fns = this.$events[type];
			for (var i = fns.length; i--;) if (i in fns){
				this.removeEvent(type, fns[i]);
			}
		}
		return this;
	}

});

this.Options = new Class({

	setOptions: function(){
		var options = this.options = Object.merge.apply(null, [{}, this.options].append(arguments));
		if (this.addEvent) for (var option in options){
			if (typeOf(options[option]) != 'function' || !(/^on[A-Z]/).test(option)) continue;
			this.addEvent(option, options[option]);
			delete options[option];
		}
		return this;
	}

});

})();

/*
---

name: Class.Thenable

description: Contains a Utility Class that can be implemented into your own Classes to make them "thenable".

license: MIT-style license.

requires: Class

provides: [Class.Thenable]

...
*/

(function(){

var STATE_PENDING = 0,
	STATE_FULFILLED = 1,
	STATE_REJECTED = 2;

var Thenable = Class.Thenable = new Class({

	$thenableState: STATE_PENDING,
	$thenableResult: null,
	$thenableReactions: [],

	resolve: function(value){
		resolve(this, value);
		return this;
	},

	reject: function(reason){
		reject(this, reason);
		return this;
	},

	getThenableState: function(){
		switch (this.$thenableState){
			case STATE_PENDING:
				return 'pending';

			case STATE_FULFILLED:
				return 'fulfilled';

			case STATE_REJECTED:
				return 'rejected';
		}
	},

	resetThenable: function(reason){
		reject(this, reason);
		reset(this);
		return this;
	},

	then: function(onFulfilled, onRejected){
		if (typeof onFulfilled !== 'function') onFulfilled = 'Identity';
		if (typeof onRejected !== 'function') onRejected = 'Thrower';

		var thenable = new Thenable();

		this.$thenableReactions.push({
			thenable: thenable,
			fulfillHandler: onFulfilled,
			rejectHandler: onRejected
		});

		if (this.$thenableState !== STATE_PENDING){
			react(this);
		}

		return thenable;
	},

	'catch': function(onRejected){
		return this.then(null, onRejected);
	}

});

Thenable.extend({
	resolve: function(value){
		var thenable;
		if (value instanceof Thenable){
			thenable = value;
		} else {
			thenable = new Thenable();
			resolve(thenable, value);
		}
		return thenable;
	},
	reject: function(reason){
		var thenable = new Thenable();
		reject(thenable, reason);
		return thenable;
	}
});

// Private functions

function resolve(thenable, value){
	if (thenable.$thenableState === STATE_PENDING){
		if (thenable === value){
			reject(thenable, new TypeError('Tried to resolve a thenable with itself.'));
		} else if (value && (typeof value === 'object' || typeof value === 'function')){
			var then;
			try {
				then = value.then;
			} catch (exception){
				reject(thenable, exception);
			}
			if (typeof then === 'function'){
				var resolved = false;
				defer(function(){
					try {
						then.call(
							value,
							function(nextValue){
								if (!resolved){
									resolved = true;
									resolve(thenable, nextValue);
								}
							},
							function(reason){
								if (!resolved){
									resolved = true;
									reject(thenable, reason);
								}
							}
						);
					} catch (exception){
						if (!resolved){
							resolved = true;
							reject(thenable, exception);
						}
					}
				});
			} else {
				fulfill(thenable, value);
			}
		} else {
			fulfill(thenable, value);
		}
	}
}

function fulfill(thenable, value){
	if (thenable.$thenableState === STATE_PENDING){
		thenable.$thenableResult = value;
		thenable.$thenableState = STATE_FULFILLED;

		react(thenable);
	}
}

function reject(thenable, reason){
	if (thenable.$thenableState === STATE_PENDING){
		thenable.$thenableResult = reason;
		thenable.$thenableState = STATE_REJECTED;

		react(thenable);
	}
}

function reset(thenable){
	if (thenable.$thenableState !== STATE_PENDING){
		thenable.$thenableResult = null;
		thenable.$thenableState = STATE_PENDING;
	}
}

function react(thenable){
	var state = thenable.$thenableState,
		result = thenable.$thenableResult,
		reactions = thenable.$thenableReactions,
		type;

	if (state === STATE_FULFILLED){
		thenable.$thenableReactions = [];
		type = 'fulfillHandler';
	} else if (state == STATE_REJECTED){
		thenable.$thenableReactions = [];
		type = 'rejectHandler';
	}

	if (type){
		defer(handle.pass([result, reactions, type]));
	}
}

function handle(result, reactions, type){
	for (var i = 0, l = reactions.length; i < l; ++i){
		var reaction = reactions[i],
			handler = reaction[type];

		if (handler === 'Identity'){
			resolve(reaction.thenable, result);
		} else if (handler === 'Thrower'){
			reject(reaction.thenable, result);
		} else {
			try {
				resolve(reaction.thenable, handler(result));
			} catch (exception){
				reject(reaction.thenable, exception);
			}
		}
	}
}

var defer;
if (typeof process !== 'undefined' && typeof process.nextTick === 'function'){
	defer = process.nextTick;
} else if (typeof setImmediate !== 'undefined'){
	defer = setImmediate;
} else {
	defer = function(fn){
		setTimeout(fn, 0);
	};
}

})();

/*
---

name: Object

description: Object generic methods

license: MIT-style license.

requires: Type

provides: [Object, Hash]

...
*/

(function(){

Object.extend({

	subset: function(object, keys){
		var results = {};
		for (var i = 0, l = keys.length; i < l; i++){
			var k = keys[i];
			if (k in object) results[k] = object[k];
		}
		return results;
	},

	map: function(object, fn, bind){
		var results = {};
		var keys = Object.keys(object);
		for (var i = 0; i < keys.length; i++){
			var key = keys[i];
			results[key] = fn.call(bind, object[key], key, object);
		}
		return results;
	},

	filter: function(object, fn, bind){
		var results = {};
		var keys = Object.keys(object);
		for (var i = 0; i < keys.length; i++){
			var key = keys[i], value = object[key];
			if (fn.call(bind, value, key, object)) results[key] = value;
		}
		return results;
	},

	every: function(object, fn, bind){
		var keys = Object.keys(object);
		for (var i = 0; i < keys.length; i++){
			var key = keys[i];
			if (!fn.call(bind, object[key], key)) return false;
		}
		return true;
	},

	some: function(object, fn, bind){
		var keys = Object.keys(object);
		for (var i = 0; i < keys.length; i++){
			var key = keys[i];
			if (fn.call(bind, object[key], key)) return true;
		}
		return false;
	},

	values: function(object){
		var values = [];
		var keys = Object.keys(object);
		for (var i = 0; i < keys.length; i++){
			var k = keys[i];
			values.push(object[k]);
		}
		return values;
	},

	getLength: function(object){
		return Object.keys(object).length;
	},

	keyOf: function(object, value){
		var keys = Object.keys(object);
		for (var i = 0; i < keys.length; i++){
			var key = keys[i];
			if (object[key] === value) return key;
		}
		return null;
	},

	contains: function(object, value){
		return Object.keyOf(object, value) != null;
	},

	toQueryString: function(object, base){
		var queryString = [];

		Object.each(object, function(value, key){
			if (base) key = base + '[' + key + ']';
			var result;
			switch (typeOf(value)){
				case 'object': result = Object.toQueryString(value, key); break;
				case 'array':
					var qs = {};
					value.each(function(val, i){
						qs[i] = val;
					});
					result = Object.toQueryString(qs, key);
					break;
				default: result = key + '=' + encodeURIComponent(value);
			}
			if (value != null) queryString.push(result);
		});

		return queryString.join('&');
	}

});

})();



/*
---
name: Slick.Parser
description: Standalone CSS3 Selector parser
provides: Slick.Parser
...
*/

;(function(){

var parsed,
	separatorIndex,
	combinatorIndex,
	reversed,
	cache = {},
	reverseCache = {},
	reUnescape = /\\/g;

var parse = function(expression, isReversed){
	if (expression == null) return null;
	if (expression.Slick === true) return expression;
	expression = ('' + expression).replace(/^\s+|\s+$/g, '');
	reversed = !!isReversed;
	var currentCache = (reversed) ? reverseCache : cache;
	if (currentCache[expression]) return currentCache[expression];
	parsed = {
		Slick: true,
		expressions: [],
		raw: expression,
		reverse: function(){
			return parse(this.raw, true);
		}
	};
	separatorIndex = -1;
	while (expression != (expression = expression.replace(regexp, parser)));
	parsed.length = parsed.expressions.length;
	return currentCache[parsed.raw] = (reversed) ? reverse(parsed) : parsed;
};

var reverseCombinator = function(combinator){
	if (combinator === '!') return ' ';
	else if (combinator === ' ') return '!';
	else if ((/^!/).test(combinator)) return combinator.replace(/^!/, '');
	else return '!' + combinator;
};

var reverse = function(expression){
	var expressions = expression.expressions;
	for (var i = 0; i < expressions.length; i++){
		var exp = expressions[i];
		var last = {parts: [], tag: '*', combinator: reverseCombinator(exp[0].combinator)};

		for (var j = 0; j < exp.length; j++){
			var cexp = exp[j];
			if (!cexp.reverseCombinator) cexp.reverseCombinator = ' ';
			cexp.combinator = cexp.reverseCombinator;
			delete cexp.reverseCombinator;
		}

		exp.reverse().push(last);
	}
	return expression;
};

var escapeRegExp = function(string){// Credit: XRegExp 0.6.1 (c) 2007-2008 Steven Levithan <http://stevenlevithan.com/regex/xregexp/> MIT License
	return string.replace(/[-[\]{}()*+?.\\^$|,#\s]/g, function(match){
		return '\\' + match;
	});
};

var regexp = new RegExp(
/*
#!/usr/bin/env ruby
puts "\t\t" + DATA.read.gsub(/\(\?x\)|\s+#.*$|\s+|\\$|\\n/,'')
__END__
	"(?x)^(?:\
	  \\s* ( , ) \\s*               # Separator          \n\
	| \\s* ( <combinator>+ ) \\s*   # Combinator         \n\
	|      ( \\s+ )                 # CombinatorChildren \n\
	|      ( <unicode>+ | \\* )     # Tag                \n\
	| \\#  ( <unicode>+       )     # ID                 \n\
	| \\.  ( <unicode>+       )     # ClassName          \n\
	|                               # Attribute          \n\
	\\[  \
		\\s* (<unicode1>+)  (?:  \
			\\s* ([*^$!~|]?=)  (?:  \
				\\s* (?:\
					([\"']?)(.*?)\\9 \
				)\
			)  \
		)?  \\s*  \
	\\](?!\\]) \n\
	|   :+ ( <unicode>+ )(?:\
	\\( (?:\
		(?:([\"'])([^\\12]*)\\12)|((?:\\([^)]+\\)|[^()]*)+)\
	) \\)\
	)?\
	)"
*/
	"^(?:\\s*(,)\\s*|\\s*(<combinator>+)\\s*|(\\s+)|(<unicode>+|\\*)|\\#(<unicode>+)|\\.(<unicode>+)|\\[\\s*(<unicode1>+)(?:\\s*([*^$!~|]?=)(?:\\s*(?:([\"']?)(.*?)\\9)))?\\s*\\](?!\\])|(:+)(<unicode>+)(?:\\((?:(?:([\"'])([^\\13]*)\\13)|((?:\\([^)]+\\)|[^()]*)+))\\))?)"
	.replace(/<combinator>/, '[' + escapeRegExp('>+~`!@$%^&={}\\;</') + ']')
	.replace(/<unicode>/g, '(?:[\\w\\u00a1-\\uFFFF-]|\\\\[^\\s0-9a-f])')
	.replace(/<unicode1>/g, '(?:[:\\w\\u00a1-\\uFFFF-]|\\\\[^\\s0-9a-f])')
);

function parser(
	rawMatch,

	separator,
	combinator,
	combinatorChildren,

	tagName,
	id,
	className,

	attributeKey,
	attributeOperator,
	attributeQuote,
	attributeValue,

	pseudoMarker,
	pseudoClass,
	pseudoQuote,
	pseudoClassQuotedValue,
	pseudoClassValue
){
	if (separator || separatorIndex === -1){
		parsed.expressions[++separatorIndex] = [];
		combinatorIndex = -1;
		if (separator) return '';
	}

	if (combinator || combinatorChildren || combinatorIndex === -1){
		combinator = combinator || ' ';
		var currentSeparator = parsed.expressions[separatorIndex];
		if (reversed && currentSeparator[combinatorIndex])
			currentSeparator[combinatorIndex].reverseCombinator = reverseCombinator(combinator);
		currentSeparator[++combinatorIndex] = {combinator: combinator, tag: '*'};
	}

	var currentParsed = parsed.expressions[separatorIndex][combinatorIndex];

	if (tagName){
		currentParsed.tag = tagName.replace(reUnescape, '');

	} else if (id){
		currentParsed.id = id.replace(reUnescape, '');

	} else if (className){
		className = className.replace(reUnescape, '');

		if (!currentParsed.classList) currentParsed.classList = [];
		if (!currentParsed.classes) currentParsed.classes = [];
		currentParsed.classList.push(className);
		currentParsed.classes.push({
			value: className,
			regexp: new RegExp('(^|\\s)' + escapeRegExp(className) + '(\\s|$)')
		});

	} else if (pseudoClass){
		pseudoClassValue = pseudoClassValue || pseudoClassQuotedValue;
		pseudoClassValue = pseudoClassValue ? pseudoClassValue.replace(reUnescape, '') : null;

		if (!currentParsed.pseudos) currentParsed.pseudos = [];
		currentParsed.pseudos.push({
			key: pseudoClass.replace(reUnescape, ''),
			value: pseudoClassValue,
			type: pseudoMarker.length == 1 ? 'class' : 'element'
		});

	} else if (attributeKey){
		attributeKey = attributeKey.replace(reUnescape, '');
		attributeValue = (attributeValue || '').replace(reUnescape, '');

		var test, regexp;

		switch (attributeOperator){
			case '^=' : regexp = new RegExp(       '^'+ escapeRegExp(attributeValue)            ); break;
			case '$=' : regexp = new RegExp(            escapeRegExp(attributeValue) +'$'       ); break;
			case '~=' : regexp = new RegExp( '(^|\\s)'+ escapeRegExp(attributeValue) +'(\\s|$)' ); break;
			case '|=' : regexp = new RegExp(       '^'+ escapeRegExp(attributeValue) +'(-|$)'   ); break;
			case  '=' : test = function(value){
				return attributeValue == value;
			}; break;
			case '*=' : test = function(value){
				return value && value.indexOf(attributeValue) > -1;
			}; break;
			case '!=' : test = function(value){
				return attributeValue != value;
			}; break;
			default   : test = function(value){
				return !!value;
			};
		}

		if (attributeValue == '' && (/^[*$^]=$/).test(attributeOperator)) test = function(){
			return false;
		};

		if (!test) test = function(value){
			return value && regexp.test(value);
		};

		if (!currentParsed.attributes) currentParsed.attributes = [];
		currentParsed.attributes.push({
			key: attributeKey,
			operator: attributeOperator,
			value: attributeValue,
			test: test
		});

	}

	return '';
};

// Slick NS

var Slick = (this.Slick || {});

Slick.parse = function(expression){
	return parse(expression);
};

Slick.escapeRegExp = escapeRegExp;

if (!this.Slick) this.Slick = Slick;

}).apply(/*<CommonJS>*/(typeof exports != 'undefined') ? exports : /*</CommonJS>*/this);

/*
---
name: Slick.Finder
description: The new, superfast css selector engine.
provides: Slick.Finder
requires: Slick.Parser
...
*/

;(function(){

var local = {},
	featuresCache = {},
	toString = Object.prototype.toString;

// Feature / Bug detection

local.isNativeCode = function(fn){
	return (/\{\s*\[native code\]\s*\}/).test('' + fn);
};

local.isXML = function(document){
	return (!!document.xmlVersion) || (!!document.xml) || (toString.call(document) == '[object XMLDocument]') ||
	(document.nodeType == 9 && document.documentElement.nodeName != 'HTML');
};

local.setDocument = function(document){

	// convert elements / window arguments to document. if document cannot be extrapolated, the function returns.
	var nodeType = document.nodeType;
	if (nodeType == 9); // document
	else if (nodeType) document = document.ownerDocument; // node
	else if (document.navigator) document = document.document; // window
	else return;

	// check if it's the old document

	if (this.document === document) return;
	this.document = document;

	// check if we have done feature detection on this document before

	var root = document.documentElement,
		rootUid = this.getUIDXML(root),
		features = featuresCache[rootUid],
		feature;

	if (features){
		for (feature in features){
			this[feature] = features[feature];
		}
		return;
	}

	features = featuresCache[rootUid] = {};

	features.root = root;
	features.isXMLDocument = this.isXML(document);

	features.brokenStarGEBTN
	= features.starSelectsClosedQSA
	= features.idGetsName
	= features.brokenMixedCaseQSA
	= features.brokenGEBCN
	= features.brokenCheckedQSA
	= features.brokenEmptyAttributeQSA
	= features.isHTMLDocument
	= features.nativeMatchesSelector
	= false;

	var starSelectsClosed, starSelectsComments,
		brokenSecondClassNameGEBCN, cachedGetElementsByClassName,
		brokenFormAttributeGetter;

	var selected, id = 'slick_uniqueid';
	var testNode = document.createElement('div');

	var testRoot = document.body || document.getElementsByTagName('body')[0] || root;
	testRoot.appendChild(testNode);

	// on non-HTML documents innerHTML and getElementsById doesnt work properly
	try {
		testNode.innerHTML = '<a id="'+id+'"></a>';
		features.isHTMLDocument = !!document.getElementById(id);
	} catch (e){}

	if (features.isHTMLDocument){

		testNode.style.display = 'none';

		// IE returns comment nodes for getElementsByTagName('*') for some documents
		testNode.appendChild(document.createComment(''));
		starSelectsComments = (testNode.getElementsByTagName('*').length > 1);

		// IE returns closed nodes (EG:"</foo>") for getElementsByTagName('*') for some documents
		try {
			testNode.innerHTML = 'foo</foo>';
			selected = testNode.getElementsByTagName('*');
			starSelectsClosed = (selected && !!selected.length && selected[0].nodeName.charAt(0) == '/');
		} catch (e){};

		features.brokenStarGEBTN = starSelectsComments || starSelectsClosed;

		// IE returns elements with the name instead of just id for getElementsById for some documents
		try {
			testNode.innerHTML = '<a name="'+ id +'"></a><b id="'+ id +'"></b>';
			features.idGetsName = document.getElementById(id) === testNode.firstChild;
		} catch (e){}

		if (testNode.getElementsByClassName){

			// Safari 3.2 getElementsByClassName caches results
			try {
				testNode.innerHTML = '<a class="f"></a><a class="b"></a>';
				testNode.getElementsByClassName('b').length;
				testNode.firstChild.className = 'b';
				cachedGetElementsByClassName = (testNode.getElementsByClassName('b').length != 2);
			} catch (e){};

			// Opera 9.6 getElementsByClassName doesnt detects the class if its not the first one
			try {
				testNode.innerHTML = '<a class="a"></a><a class="f b a"></a>';
				brokenSecondClassNameGEBCN = (testNode.getElementsByClassName('a').length != 2);
			} catch (e){}

			features.brokenGEBCN = cachedGetElementsByClassName || brokenSecondClassNameGEBCN;
		}

		if (testNode.querySelectorAll){
			// IE 8 returns closed nodes (EG:"</foo>") for querySelectorAll('*') for some documents
			try {
				testNode.innerHTML = 'foo</foo>';
				selected = testNode.querySelectorAll('*');
				features.starSelectsClosedQSA = (selected && !!selected.length && selected[0].nodeName.charAt(0) == '/');
			} catch (e){}

			// Safari 3.2 querySelectorAll doesnt work with mixedcase on quirksmode
			try {
				testNode.innerHTML = '<a class="MiX"></a>';
				features.brokenMixedCaseQSA = !testNode.querySelectorAll('.MiX').length;
			} catch (e){}

			// Webkit and Opera dont return selected options on querySelectorAll
			try {
				testNode.innerHTML = '<select><option selected="selected">a</option></select>';
				features.brokenCheckedQSA = (testNode.querySelectorAll(':checked').length == 0);
			} catch (e){};

			// IE returns incorrect results for attr[*^$]="" selectors on querySelectorAll
			try {
				testNode.innerHTML = '<a class=""></a>';
				features.brokenEmptyAttributeQSA = (testNode.querySelectorAll('[class*=""]').length != 0);
			} catch (e){}

		}

		// IE6-7, if a form has an input of id x, form.getAttribute(x) returns a reference to the input
		try {
			testNode.innerHTML = '<form action="s"><input id="action"/></form>';
			brokenFormAttributeGetter = (testNode.firstChild.getAttribute('action') != 's');
		} catch (e){}

		// native matchesSelector function

		features.nativeMatchesSelector = root.matches || /*root.msMatchesSelector ||*/ root.mozMatchesSelector || root.webkitMatchesSelector;
		if (features.nativeMatchesSelector) try {
			// if matchesSelector trows errors on incorrect sintaxes we can use it
			features.nativeMatchesSelector.call(root, ':slick');
			features.nativeMatchesSelector = null;
		} catch (e){}

	}

	try {
		root.slick_expando = 1;
		delete root.slick_expando;
		features.getUID = this.getUIDHTML;
	} catch (e){
		features.getUID = this.getUIDXML;
	}

	testRoot.removeChild(testNode);
	testNode = selected = testRoot = null;

	// getAttribute

	features.getAttribute = (features.isHTMLDocument && brokenFormAttributeGetter) ? function(node, name){
		var method = this.attributeGetters[name];
		if (method) return method.call(node);
		var attributeNode = node.getAttributeNode(name);
		return (attributeNode) ? attributeNode.nodeValue : null;
	} : function(node, name){
		var method = this.attributeGetters[name];
		return (method) ? method.call(node) : node.getAttribute(name);
	};

	// hasAttribute

	features.hasAttribute = (root && this.isNativeCode(root.hasAttribute)) ? function(node, attribute){
		return node.hasAttribute(attribute);
	} : function(node, attribute){
		node = node.getAttributeNode(attribute);
		return !!(node && (node.specified || node.nodeValue));
	};

	// contains
	// FIXME: Add specs: local.contains should be different for xml and html documents?
	var nativeRootContains = root && this.isNativeCode(root.contains),
		nativeDocumentContains = document && this.isNativeCode(document.contains);

	features.contains = (nativeRootContains && nativeDocumentContains) ? function(context, node){
		return context.contains(node);
	} : (nativeRootContains && !nativeDocumentContains) ? function(context, node){
		// IE8 does not have .contains on document.
		return context === node || ((context === document) ? document.documentElement : context).contains(node);
	} : (root && root.compareDocumentPosition) ? function(context, node){
		return context === node || !!(context.compareDocumentPosition(node) & 16);
	} : function(context, node){
		if (node) do {
			if (node === context) return true;
		} while ((node = node.parentNode));
		return false;
	};

	// document order sorting
	// credits to Sizzle (http://sizzlejs.com/)

	features.documentSorter = (root.compareDocumentPosition) ? function(a, b){
		if (!a.compareDocumentPosition || !b.compareDocumentPosition) return 0;
		return a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
	} : ('sourceIndex' in root) ? function(a, b){
		if (!a.sourceIndex || !b.sourceIndex) return 0;
		return a.sourceIndex - b.sourceIndex;
	} : (document.createRange) ? function(a, b){
		if (!a.ownerDocument || !b.ownerDocument) return 0;
		var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange();
		aRange.setStart(a, 0);
		aRange.setEnd(a, 0);
		bRange.setStart(b, 0);
		bRange.setEnd(b, 0);
		return aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
	} : null;

	root = null;

	for (feature in features){
		this[feature] = features[feature];
	}
};

// Main Method

var reSimpleSelector = /^([#.]?)((?:[\w-]+|\*))$/,
	reEmptyAttribute = /\[.+[*$^]=(?:""|'')?\]/,
	qsaFailExpCache = {};

local.search = function(context, expression, append, first){

	var found = this.found = (first) ? null : (append || []);

	if (!context) return found;
	else if (context.navigator) context = context.document; // Convert the node from a window to a document
	else if (!context.nodeType) return found;

	// setup

	var parsed, i, node, nodes,
		uniques = this.uniques = {},
		hasOthers = !!(append && append.length),
		contextIsDocument = (context.nodeType == 9);

	if (this.document !== (contextIsDocument ? context : context.ownerDocument)) this.setDocument(context);

	// avoid duplicating items already in the append array
	if (hasOthers) for (i = found.length; i--;) uniques[this.getUID(found[i])] = true;

	// expression checks

	if (typeof expression == 'string'){ // expression is a string

		/*<simple-selectors-override>*/
		var simpleSelector = expression.match(reSimpleSelector);
		simpleSelectors: if (simpleSelector){

			var symbol = simpleSelector[1],
				name = simpleSelector[2];

			if (!symbol){

				if (name == '*' && this.brokenStarGEBTN) break simpleSelectors;
				nodes = context.getElementsByTagName(name);
				if (first) return nodes[0] || null;
				for (i = 0; node = nodes[i++];){
					if (!(hasOthers && uniques[this.getUID(node)])) found.push(node);
				}

			} else if (symbol == '#'){

				if (!this.isHTMLDocument || !contextIsDocument) break simpleSelectors;
				node = context.getElementById(name);
				if (!node) return found;
				if (this.idGetsName && node.getAttributeNode('id').nodeValue != name) break simpleSelectors;
				if (first) return node || null;
				if (!(hasOthers && uniques[this.getUID(node)])) found.push(node);

			} else if (symbol == '.'){

				if (!this.isHTMLDocument || ((!context.getElementsByClassName || this.brokenGEBCN) && context.querySelectorAll)) break simpleSelectors;
				if (context.getElementsByClassName && !this.brokenGEBCN){
					nodes = context.getElementsByClassName(name);
					if (first) return nodes[0] || null;
					for (i = 0; node = nodes[i++];){
						if (!(hasOthers && uniques[this.getUID(node)])) found.push(node);
					}
				} else {
					var matchClass = new RegExp('(^|\\s)'+ Slick.escapeRegExp(name) +'(\\s|$)');
					nodes = context.getElementsByTagName('*');
					for (i = 0; node = nodes[i++];){
						className = node.className;
						if (!(className && matchClass.test(className))) continue;
						if (first) return node;
						if (!(hasOthers && uniques[this.getUID(node)])) found.push(node);
					}
				}

			}

			if (hasOthers) this.sort(found);
			return (first) ? null : found;

		}
		/*</simple-selectors-override>*/

		/*<query-selector-override>*/
		querySelector: if (context.querySelectorAll){

			if (!this.isHTMLDocument
				|| qsaFailExpCache[expression]
				//TODO: only skip when expression is actually mixed case
				|| this.brokenMixedCaseQSA
				|| (this.brokenCheckedQSA && expression.indexOf(':checked') > -1)
				|| (this.brokenEmptyAttributeQSA && reEmptyAttribute.test(expression))
				|| (!contextIsDocument //Abort when !contextIsDocument and...
					//  there are multiple expressions in the selector
					//  since we currently only fix non-document rooted QSA for single expression selectors
					&& expression.indexOf(',') > -1
				)
				|| Slick.disableQSA
			) break querySelector;

			var _expression = expression, _context = context, currentId;
			if (!contextIsDocument){
				// non-document rooted QSA
				// credits to Andrew Dupont
				currentId = _context.getAttribute('id'), slickid = 'slickid__';
				_context.setAttribute('id', slickid);
				_expression = '#' + slickid + ' ' + _expression;
				context = _context.parentNode;
			}

			try {
				if (first) return context.querySelector(_expression) || null;
				else nodes = context.querySelectorAll(_expression);
			} catch (e){
				qsaFailExpCache[expression] = 1;
				break querySelector;
			} finally {
				if (!contextIsDocument){
					if (currentId) _context.setAttribute('id', currentId);
					else _context.removeAttribute('id');
					context = _context;
				}
			}

			if (this.starSelectsClosedQSA) for (i = 0; node = nodes[i++];){
				if (node.nodeName > '@' && !(hasOthers && uniques[this.getUID(node)])) found.push(node);
			} else for (i = 0; node = nodes[i++];){
				if (!(hasOthers && uniques[this.getUID(node)])) found.push(node);
			}

			if (hasOthers) this.sort(found);
			return found;

		}
		/*</query-selector-override>*/

		parsed = this.Slick.parse(expression);
		if (!parsed.length) return found;
	} else if (expression == null){ // there is no expression
		return found;
	} else if (expression.Slick){ // expression is a parsed Slick object
		parsed = expression;
	} else if (this.contains(context.documentElement || context, expression)){ // expression is a node
		(found) ? found.push(expression) : found = expression;
		return found;
	} else { // other junk
		return found;
	}

	/*<pseudo-selectors>*//*<nth-pseudo-selectors>*/

	// cache elements for the nth selectors

	this.posNTH = {};
	this.posNTHLast = {};
	this.posNTHType = {};
	this.posNTHTypeLast = {};

	/*</nth-pseudo-selectors>*//*</pseudo-selectors>*/

	// if append is null and there is only a single selector with one expression use pushArray, else use pushUID
	this.push = (!hasOthers && (first || (parsed.length == 1 && parsed.expressions[0].length == 1))) ? this.pushArray : this.pushUID;

	if (found == null) found = [];

	// default engine

	var j, m, n;
	var combinator, tag, id, classList, classes, attributes, pseudos;
	var currentItems, currentExpression, currentBit, lastBit, expressions = parsed.expressions;

	search: for (i = 0; (currentExpression = expressions[i]); i++) for (j = 0; (currentBit = currentExpression[j]); j++){

		combinator = 'combinator:' + currentBit.combinator;
		if (!this[combinator]) continue search;

		tag        = (this.isXMLDocument) ? currentBit.tag : currentBit.tag.toUpperCase();
		id         = currentBit.id;
		classList  = currentBit.classList;
		classes    = currentBit.classes;
		attributes = currentBit.attributes;
		pseudos    = currentBit.pseudos;
		lastBit    = (j === (currentExpression.length - 1));

		this.bitUniques = {};

		if (lastBit){
			this.uniques = uniques;
			this.found = found;
		} else {
			this.uniques = {};
			this.found = [];
		}

		if (j === 0){
			this[combinator](context, tag, id, classes, attributes, pseudos, classList);
			if (first && lastBit && found.length) break search;
		} else {
			if (first && lastBit) for (m = 0, n = currentItems.length; m < n; m++){
				this[combinator](currentItems[m], tag, id, classes, attributes, pseudos, classList);
				if (found.length) break search;
			} else for (m = 0, n = currentItems.length; m < n; m++) this[combinator](currentItems[m], tag, id, classes, attributes, pseudos, classList);
		}

		currentItems = this.found;
	}

	// should sort if there are nodes in append and if you pass multiple expressions.
	if (hasOthers || (parsed.expressions.length > 1)) this.sort(found);

	return (first) ? (found[0] || null) : found;
};

// Utils

local.uidx = 1;
local.uidk = 'slick-uniqueid';

local.getUIDXML = function(node){
	var uid = node.getAttribute(this.uidk);
	if (!uid){
		uid = this.uidx++;
		node.setAttribute(this.uidk, uid);
	}
	return uid;
};

local.getUIDHTML = function(node){
	return node.uniqueNumber || (node.uniqueNumber = this.uidx++);
};

// sort based on the setDocument documentSorter method.

local.sort = function(results){
	if (!this.documentSorter) return results;
	results.sort(this.documentSorter);
	return results;
};

/*<pseudo-selectors>*//*<nth-pseudo-selectors>*/

local.cacheNTH = {};

local.matchNTH = /^([+-]?\d*)?([a-z]+)?([+-]\d+)?$/;

local.parseNTHArgument = function(argument){
	var parsed = argument.match(this.matchNTH);
	if (!parsed) return false;
	var special = parsed[2] || false;
	var a = parsed[1] || 1;
	if (a == '-') a = -1;
	var b = +parsed[3] || 0;
	parsed =
		(special == 'n')	? {a: a, b: b} :
		(special == 'odd')	? {a: 2, b: 1} :
		(special == 'even')	? {a: 2, b: 0} : {a: 0, b: a};

	return (this.cacheNTH[argument] = parsed);
};

local.createNTHPseudo = function(child, sibling, positions, ofType){
	return function(node, argument){
		var uid = this.getUID(node);
		if (!this[positions][uid]){
			var parent = node.parentNode;
			if (!parent) return false;
			var el = parent[child], count = 1;
			if (ofType){
				var nodeName = node.nodeName;
				do {
					if (el.nodeName != nodeName) continue;
					this[positions][this.getUID(el)] = count++;
				} while ((el = el[sibling]));
			} else {
				do {
					if (el.nodeType != 1) continue;
					this[positions][this.getUID(el)] = count++;
				} while ((el = el[sibling]));
			}
		}
		argument = argument || 'n';
		var parsed = this.cacheNTH[argument] || this.parseNTHArgument(argument);
		if (!parsed) return false;
		var a = parsed.a, b = parsed.b, pos = this[positions][uid];
		if (a == 0) return b == pos;
		if (a > 0){
			if (pos < b) return false;
		} else {
			if (b < pos) return false;
		}
		return ((pos - b) % a) == 0;
	};
};

/*</nth-pseudo-selectors>*//*</pseudo-selectors>*/

local.pushArray = function(node, tag, id, classes, attributes, pseudos){
	if (this.matchSelector(node, tag, id, classes, attributes, pseudos)) this.found.push(node);
};

local.pushUID = function(node, tag, id, classes, attributes, pseudos){
	var uid = this.getUID(node);
	if (!this.uniques[uid] && this.matchSelector(node, tag, id, classes, attributes, pseudos)){
		this.uniques[uid] = true;
		this.found.push(node);
	}
};

local.matchNode = function(node, selector){
	if (this.isHTMLDocument && this.nativeMatchesSelector){
		try {
			return this.nativeMatchesSelector.call(node, selector.replace(/\[([^=]+)=\s*([^'"\]]+?)\s*\]/g, '[$1="$2"]'));
		} catch (matchError){}
	}

	var parsed = this.Slick.parse(selector);
	if (!parsed) return true;

	// simple (single) selectors
	var expressions = parsed.expressions, simpleExpCounter = 0, i, currentExpression;
	for (i = 0; (currentExpression = expressions[i]); i++){
		if (currentExpression.length == 1){
			var exp = currentExpression[0];
			if (this.matchSelector(node, (this.isXMLDocument) ? exp.tag : exp.tag.toUpperCase(), exp.id, exp.classes, exp.attributes, exp.pseudos)) return true;
			simpleExpCounter++;
		}
	}

	if (simpleExpCounter == parsed.length) return false;

	var nodes = this.search(this.document, parsed), item;
	for (i = 0; item = nodes[i++];){
		if (item === node) return true;
	}
	return false;
};

local.matchPseudo = function(node, name, argument){
	var pseudoName = 'pseudo:' + name;
	if (this[pseudoName]) return this[pseudoName](node, argument);
	var attribute = this.getAttribute(node, name);
	return (argument) ? argument == attribute : !!attribute;
};

local.matchSelector = function(node, tag, id, classes, attributes, pseudos){
	if (tag){
		var nodeName = (this.isXMLDocument) ? node.nodeName : node.nodeName.toUpperCase();
		if (tag == '*'){
			if (nodeName < '@') return false; // Fix for comment nodes and closed nodes
		} else {
			if (nodeName != tag) return false;
		}
	}

	if (id && node.getAttribute('id') != id) return false;

	var i, part, cls;
	if (classes) for (i = classes.length; i--;){
		cls = this.getAttribute(node, 'class');
		if (!(cls && classes[i].regexp.test(cls))) return false;
	}
	if (attributes) for (i = attributes.length; i--;){
		part = attributes[i];
		if (part.operator ? !part.test(this.getAttribute(node, part.key)) : !this.hasAttribute(node, part.key)) return false;
	}
	if (pseudos) for (i = pseudos.length; i--;){
		part = pseudos[i];
		if (!this.matchPseudo(node, part.key, part.value)) return false;
	}
	return true;
};

var combinators = {

	' ': function(node, tag, id, classes, attributes, pseudos, classList){ // all child nodes, any level

		var i, item, children;

		if (this.isHTMLDocument){
			getById: if (id){
				item = this.document.getElementById(id);
				if ((!item && node.all) || (this.idGetsName && item && item.getAttributeNode('id').nodeValue != id)){
					// all[id] returns all the elements with that name or id inside node
					// if theres just one it will return the element, else it will be a collection
					children = node.all[id];
					if (!children) return;
					if (!children[0]) children = [children];
					for (i = 0; item = children[i++];){
						var idNode = item.getAttributeNode('id');
						if (idNode && idNode.nodeValue == id){
							this.push(item, tag, null, classes, attributes, pseudos);
							break;
						}
					}
					return;
				}
				if (!item){
					// if the context is in the dom we return, else we will try GEBTN, breaking the getById label
					if (this.contains(this.root, node)) return;
					else break getById;
				} else if (this.document !== node && !this.contains(node, item)) return;
				this.push(item, tag, null, classes, attributes, pseudos);
				return;
			}
			getByClass: if (classes && node.getElementsByClassName && !this.brokenGEBCN){
				children = node.getElementsByClassName(classList.join(' '));
				if (!(children && children.length)) break getByClass;
				for (i = 0; item = children[i++];) this.push(item, tag, id, null, attributes, pseudos);
				return;
			}
		}
		getByTag: {
			children = node.getElementsByTagName(tag);
			if (!(children && children.length)) break getByTag;
			if (!this.brokenStarGEBTN) tag = null;
			for (i = 0; item = children[i++];) this.push(item, tag, id, classes, attributes, pseudos);
		}
	},

	'>': function(node, tag, id, classes, attributes, pseudos){ // direct children
		if ((node = node.firstChild)) do {
			if (node.nodeType == 1) this.push(node, tag, id, classes, attributes, pseudos);
		} while ((node = node.nextSibling));
	},

	'+': function(node, tag, id, classes, attributes, pseudos){ // next sibling
		while ((node = node.nextSibling)) if (node.nodeType == 1){
			this.push(node, tag, id, classes, attributes, pseudos);
			break;
		}
	},

	'^': function(node, tag, id, classes, attributes, pseudos){ // first child
		node = node.firstChild;
		if (node){
			if (node.nodeType == 1) this.push(node, tag, id, classes, attributes, pseudos);
			else this['combinator:+'](node, tag, id, classes, attributes, pseudos);
		}
	},

	'~': function(node, tag, id, classes, attributes, pseudos){ // next siblings
		while ((node = node.nextSibling)){
			if (node.nodeType != 1) continue;
			var uid = this.getUID(node);
			if (this.bitUniques[uid]) break;
			this.bitUniques[uid] = true;
			this.push(node, tag, id, classes, attributes, pseudos);
		}
	},

	'++': function(node, tag, id, classes, attributes, pseudos){ // next sibling and previous sibling
		this['combinator:+'](node, tag, id, classes, attributes, pseudos);
		this['combinator:!+'](node, tag, id, classes, attributes, pseudos);
	},

	'~~': function(node, tag, id, classes, attributes, pseudos){ // next siblings and previous siblings
		this['combinator:~'](node, tag, id, classes, attributes, pseudos);
		this['combinator:!~'](node, tag, id, classes, attributes, pseudos);
	},

	'!': function(node, tag, id, classes, attributes, pseudos){ // all parent nodes up to document
		while ((node = node.parentNode)) if (node !== this.document) this.push(node, tag, id, classes, attributes, pseudos);
	},

	'!>': function(node, tag, id, classes, attributes, pseudos){ // direct parent (one level)
		node = node.parentNode;
		if (node !== this.document) this.push(node, tag, id, classes, attributes, pseudos);
	},

	'!+': function(node, tag, id, classes, attributes, pseudos){ // previous sibling
		while ((node = node.previousSibling)) if (node.nodeType == 1){
			this.push(node, tag, id, classes, attributes, pseudos);
			break;
		}
	},

	'!^': function(node, tag, id, classes, attributes, pseudos){ // last child
		node = node.lastChild;
		if (node){
			if (node.nodeType == 1) this.push(node, tag, id, classes, attributes, pseudos);
			else this['combinator:!+'](node, tag, id, classes, attributes, pseudos);
		}
	},

	'!~': function(node, tag, id, classes, attributes, pseudos){ // previous siblings
		while ((node = node.previousSibling)){
			if (node.nodeType != 1) continue;
			var uid = this.getUID(node);
			if (this.bitUniques[uid]) break;
			this.bitUniques[uid] = true;
			this.push(node, tag, id, classes, attributes, pseudos);
		}
	}

};

for (var c in combinators) local['combinator:' + c] = combinators[c];

var pseudos = {

	/*<pseudo-selectors>*/

	'empty': function(node){
		var child = node.firstChild;
		return !(child && child.nodeType == 1) && !(node.innerText || node.textContent || '').length;
	},

	'not': function(node, expression){
		return !this.matchNode(node, expression);
	},

	'contains': function(node, text){
		return (node.innerText || node.textContent || '').indexOf(text) > -1;
	},

	'first-child': function(node){
		while ((node = node.previousSibling)) if (node.nodeType == 1) return false;
		return true;
	},

	'last-child': function(node){
		while ((node = node.nextSibling)) if (node.nodeType == 1) return false;
		return true;
	},

	'only-child': function(node){
		var prev = node;
		while ((prev = prev.previousSibling)) if (prev.nodeType == 1) return false;
		var next = node;
		while ((next = next.nextSibling)) if (next.nodeType == 1) return false;
		return true;
	},

	/*<nth-pseudo-selectors>*/

	'nth-child': local.createNTHPseudo('firstChild', 'nextSibling', 'posNTH'),

	'nth-last-child': local.createNTHPseudo('lastChild', 'previousSibling', 'posNTHLast'),

	'nth-of-type': local.createNTHPseudo('firstChild', 'nextSibling', 'posNTHType', true),

	'nth-last-of-type': local.createNTHPseudo('lastChild', 'previousSibling', 'posNTHTypeLast', true),

	'index': function(node, index){
		return this['pseudo:nth-child'](node, '' + (index + 1));
	},

	'even': function(node){
		return this['pseudo:nth-child'](node, '2n');
	},

	'odd': function(node){
		return this['pseudo:nth-child'](node, '2n+1');
	},

	/*</nth-pseudo-selectors>*/

	/*<of-type-pseudo-selectors>*/

	'first-of-type': function(node){
		var nodeName = node.nodeName;
		while ((node = node.previousSibling)) if (node.nodeName == nodeName) return false;
		return true;
	},

	'last-of-type': function(node){
		var nodeName = node.nodeName;
		while ((node = node.nextSibling)) if (node.nodeName == nodeName) return false;
		return true;
	},

	'only-of-type': function(node){
		var prev = node, nodeName = node.nodeName;
		while ((prev = prev.previousSibling)) if (prev.nodeName == nodeName) return false;
		var next = node;
		while ((next = next.nextSibling)) if (next.nodeName == nodeName) return false;
		return true;
	},

	/*</of-type-pseudo-selectors>*/

	// custom pseudos

	'enabled': function(node){
		return !node.disabled;
	},

	'disabled': function(node){
		return node.disabled;
	},

	'checked': function(node){
		return node.checked || node.selected;
	},

	'focus': function(node){
		return this.isHTMLDocument && this.document.activeElement === node && (node.href || node.type || this.hasAttribute(node, 'tabindex'));
	},

	'root': function(node){
		return (node === this.root);
	},

	'selected': function(node){
		return node.selected;
	}

	/*</pseudo-selectors>*/
};

for (var p in pseudos) local['pseudo:' + p] = pseudos[p];

// attributes methods

var attributeGetters = local.attributeGetters = {

	'for': function(){
		return ('htmlFor' in this) ? this.htmlFor : this.getAttribute('for');
	},

	'href': function(){
		return ('href' in this) ? this.getAttribute('href', 2) : this.getAttribute('href');
	},

	'style': function(){
		return (this.style) ? this.style.cssText : this.getAttribute('style');
	},

	'tabindex': function(){
		var attributeNode = this.getAttributeNode('tabindex');
		return (attributeNode && attributeNode.specified) ? attributeNode.nodeValue : null;
	},

	'type': function(){
		return this.getAttribute('type');
	},

	'maxlength': function(){
		var attributeNode = this.getAttributeNode('maxLength');
		return (attributeNode && attributeNode.specified) ? attributeNode.nodeValue : null;
	}

};

attributeGetters.MAXLENGTH = attributeGetters.maxLength = attributeGetters.maxlength;

// Slick

var Slick = local.Slick = (this.Slick || {});

Slick.version = '1.1.7';

// Slick finder

Slick.search = function(context, expression, append){
	return local.search(context, expression, append);
};

Slick.find = function(context, expression){
	return local.search(context, expression, null, true);
};

// Slick containment checker

Slick.contains = function(container, node){
	local.setDocument(container);
	return local.contains(container, node);
};

// Slick attribute getter

Slick.getAttribute = function(node, name){
	local.setDocument(node);
	return local.getAttribute(node, name);
};

Slick.hasAttribute = function(node, name){
	local.setDocument(node);
	return local.hasAttribute(node, name);
};

// Slick matcher

Slick.match = function(node, selector){
	if (!(node && selector)) return false;
	if (!selector || selector === node) return true;
	local.setDocument(node);
	return local.matchNode(node, selector);
};

// Slick attribute accessor

Slick.defineAttributeGetter = function(name, fn){
	local.attributeGetters[name] = fn;
	return this;
};

Slick.lookupAttributeGetter = function(name){
	return local.attributeGetters[name];
};

// Slick pseudo accessor

Slick.definePseudo = function(name, fn){
	local['pseudo:' + name] = function(node, argument){
		return fn.call(node, argument);
	};
	return this;
};

Slick.lookupPseudo = function(name){
	var pseudo = local['pseudo:' + name];
	if (pseudo) return function(argument){
		return pseudo.call(this, argument);
	};
	return null;
};

// Slick overrides accessor

Slick.override = function(regexp, fn){
	local.override(regexp, fn);
	return this;
};

Slick.isXML = local.isXML;

Slick.uidOf = function(node){
	return local.getUIDHTML(node);
};

if (!this.Slick) this.Slick = Slick;

}).apply(/*<CommonJS>*/(typeof exports != 'undefined') ? exports : /*</CommonJS>*/this);

/*
---

name: Element

description: One of the most important items in MooTools. Contains the dollar function, the dollars function, and an handful of cross-browser, time-saver methods to let you easily work with HTML Elements.

license: MIT-style license.

requires: [Window, Document, Array, String, Function, Object, Number, Slick.Parser, Slick.Finder]

provides: [Element, Elements, $, $$, IFrame, Selectors]

...
*/

var Element = this.Element = function(tag, props){
	var konstructor = Element.Constructors[tag];
	if (konstructor) return konstructor(props);
	if (typeof tag != 'string') return document.id(tag).set(props);

	if (!props) props = {};

	if (!(/^[\w-]+$/).test(tag)){
		var parsed = Slick.parse(tag).expressions[0][0];
		tag = (parsed.tag == '*') ? 'div' : parsed.tag;
		if (parsed.id && props.id == null) props.id = parsed.id;

		var attributes = parsed.attributes;
		if (attributes) for (var attr, i = 0, l = attributes.length; i < l; i++){
			attr = attributes[i];
			if (props[attr.key] != null) continue;

			if (attr.value != null && attr.operator == '=') props[attr.key] = attr.value;
			else if (!attr.value && !attr.operator) props[attr.key] = true;
		}

		if (parsed.classList && props['class'] == null) props['class'] = parsed.classList.join(' ');
	}

	return document.newElement(tag, props);
};


if (Browser.Element){
	Element.prototype = Browser.Element.prototype;
	// IE8 and IE9 require the wrapping.
	Element.prototype._fireEvent = (function(fireEvent){
		return function(type, event){
			return fireEvent.call(this, type, event);
		};
	})(Element.prototype.fireEvent);
}

new Type('Element', Element).mirror(function(name){
	if (Array.prototype[name]) return;

	var obj = {};
	obj[name] = function(){
		var results = [], args = arguments, elements = true;
		for (var i = 0, l = this.length; i < l; i++){
			var element = this[i], result = results[i] = element[name].apply(element, args);
			elements = (elements && typeOf(result) == 'element');
		}
		return (elements) ? new Elements(results) : results;
	};

	Elements.implement(obj);
});

if (!Browser.Element){
	Element.parent = Object;

	Element.Prototype = {
		'$constructor': Element,
		'$family': Function.convert('element').hide()
	};

	Element.mirror(function(name, method){
		Element.Prototype[name] = method;
	});
}

Element.Constructors = {};



var IFrame = new Type('IFrame', function(){
	var params = Array.link(arguments, {
		properties: Type.isObject,
		iframe: function(obj){
			return (obj != null);
		}
	});

	var props = params.properties || {}, iframe;
	if (params.iframe) iframe = document.id(params.iframe);
	var onload = props.onload || function(){};
	delete props.onload;
	props.id = props.name = [props.id, props.name, iframe ? (iframe.id || iframe.name) : 'IFrame_' + String.uniqueID()].pick();
	iframe = new Element(iframe || 'iframe', props);

	var onLoad = function(){
		onload.call(iframe.contentWindow);
	};

	if (window.frames[props.id]) onLoad();
	else iframe.addListener('load', onLoad);
	return iframe;
});

var Elements = this.Elements = function(nodes){
	if (nodes && nodes.length){
		var uniques = {}, node;
		for (var i = 0; node = nodes[i++];){
			var uid = Slick.uidOf(node);
			if (!uniques[uid]){
				uniques[uid] = true;
				this.push(node);
			}
		}
	}
};

Elements.prototype = {length: 0};
Elements.parent = Array;

new Type('Elements', Elements).implement({

	filter: function(filter, bind){
		if (!filter) return this;
		return new Elements(Array.filter(this, (typeOf(filter) == 'string') ? function(item){
			return item.match(filter);
		} : filter, bind));
	}.protect(),

	push: function(){
		var length = this.length;
		for (var i = 0, l = arguments.length; i < l; i++){
			var item = document.id(arguments[i]);
			if (item) this[length++] = item;
		}
		return (this.length = length);
	}.protect(),

	unshift: function(){
		var items = [];
		for (var i = 0, l = arguments.length; i < l; i++){
			var item = document.id(arguments[i]);
			if (item) items.push(item);
		}
		return Array.prototype.unshift.apply(this, items);
	}.protect(),

	concat: function(){
		var newElements = new Elements(this);
		for (var i = 0, l = arguments.length; i < l; i++){
			var item = arguments[i];
			if (Type.isEnumerable(item)) newElements.append(item);
			else newElements.push(item);
		}
		return newElements;
	}.protect(),

	append: function(collection){
		for (var i = 0, l = collection.length; i < l; i++) this.push(collection[i]);
		return this;
	}.protect(),

	empty: function(){
		while (this.length) delete this[--this.length];
		return this;
	}.protect()

});



(function(){

// FF, IE
var splice = Array.prototype.splice, object = {'0': 0, '1': 1, length: 2};

splice.call(object, 1, 1);
if (object[1] == 1) Elements.implement('splice', function(){
	var length = this.length;
	var result = splice.apply(this, arguments);
	while (length >= this.length) delete this[length--];
	return result;
}.protect());

Array.forEachMethod(function(method, name){
	Elements.implement(name, method);
});

Array.mirror(Elements);

/*<ltIE8>*/
var createElementAcceptsHTML;
try {
	createElementAcceptsHTML = (document.createElement('<input name=x>').name == 'x');
} catch (e){}

var escapeQuotes = function(html){
	return ('' + html).replace(/&/g, '&amp;').replace(/"/g, '&quot;');
};
/*</ltIE8>*/

/*<ltIE9>*/
// #2479 - IE8 Cannot set HTML of style element
var canChangeStyleHTML = (function(){
	var div = document.createElement('style'),
		flag = false;
	try {
		div.innerHTML = '#justTesing{margin: 0px;}';
		flag = !!div.innerHTML;
	} catch (e){}
	return flag;
})();
/*</ltIE9>*/

Document.implement({

	newElement: function(tag, props){
		if (props){
			if (props.checked != null) props.defaultChecked = props.checked;
			if ((props.type == 'checkbox' || props.type == 'radio') && props.value == null) props.value = 'on';
			/*<ltIE9>*/ // IE needs the type to be set before changing content of style element
			if (!canChangeStyleHTML && tag == 'style'){
				var styleElement = document.createElement('style');
				styleElement.setAttribute('type', 'text/css');
				if (props.type) delete props.type;
				return this.id(styleElement).set(props);
			}
			/*</ltIE9>*/
			/*<ltIE8>*/// Fix for readonly name and type properties in IE < 8
			if (createElementAcceptsHTML){
				tag = '<' + tag;
				if (props.name) tag += ' name="' + escapeQuotes(props.name) + '"';
				if (props.type) tag += ' type="' + escapeQuotes(props.type) + '"';
				tag += '>';
				delete props.name;
				delete props.type;
			}
			/*</ltIE8>*/
		}
		return this.id(this.createElement(tag)).set(props);
	}

});

})();

(function(){

Slick.uidOf(window);
Slick.uidOf(document);

Document.implement({

	newTextNode: function(text){
		return this.createTextNode(text);
	},

	getDocument: function(){
		return this;
	},

	getWindow: function(){
		return this.window;
	},

	id: (function(){

		var types = {

			string: function(id, nocash, doc){
				id = Slick.find(doc, '#' + id.replace(/(\W)/g, '\\$1'));
				return (id) ? types.element(id, nocash) : null;
			},

			element: function(el, nocash){
				Slick.uidOf(el);
				if (!nocash && !el.$family && !(/^(?:object|embed)$/i).test(el.tagName)){
					var fireEvent = el.fireEvent;
					// wrapping needed in IE7, or else crash
					el._fireEvent = function(type, event){
						return fireEvent(type, event);
					};
					Object.append(el, Element.Prototype);
				}
				return el;
			},

			object: function(obj, nocash, doc){
				if (obj.toElement) return types.element(obj.toElement(doc), nocash);
				return null;
			}

		};

		types.textnode = types.whitespace = types.window = types.document = function(zero){
			return zero;
		};

		return function(el, nocash, doc){
			if (el && el.$family && el.uniqueNumber) return el;
			var type = typeOf(el);
			return (types[type]) ? types[type](el, nocash, doc || document) : null;
		};

	})()

});

if (window.$ == null) Window.implement('$', function(el, nc){
	return document.id(el, nc, this.document);
});

Window.implement({

	getDocument: function(){
		return this.document;
	},

	getWindow: function(){
		return this;
	}

});

[Document, Element].invoke('implement', {

	getElements: function(expression){
		return Slick.search(this, expression, new Elements);
	},

	getElement: function(expression){
		return document.id(Slick.find(this, expression));
	}

});

var contains = {contains: function(element){
	return Slick.contains(this, element);
}};

if (!document.contains) Document.implement(contains);
if (!document.createElement('div').contains) Element.implement(contains);



// tree walking

var injectCombinator = function(expression, combinator){
	if (!expression) return combinator;

	expression = Object.clone(Slick.parse(expression));

	var expressions = expression.expressions;
	for (var i = expressions.length; i--;)
		expressions[i][0].combinator = combinator;

	return expression;
};

Object.forEach({
	getNext: '~',
	getPrevious: '!~',
	getParent: '!'
}, function(combinator, method){
	Element.implement(method, function(expression){
		return this.getElement(injectCombinator(expression, combinator));
	});
});

Object.forEach({
	getAllNext: '~',
	getAllPrevious: '!~',
	getSiblings: '~~',
	getChildren: '>',
	getParents: '!'
}, function(combinator, method){
	Element.implement(method, function(expression){
		return this.getElements(injectCombinator(expression, combinator));
	});
});

Element.implement({

	getFirst: function(expression){
		return document.id(Slick.search(this, injectCombinator(expression, '>'))[0]);
	},

	getLast: function(expression){
		return document.id(Slick.search(this, injectCombinator(expression, '>')).getLast());
	},

	getWindow: function(){
		return this.ownerDocument.window;
	},

	getDocument: function(){
		return this.ownerDocument;
	},

	getElementById: function(id){
		return document.id(Slick.find(this, '#' + ('' + id).replace(/(\W)/g, '\\$1')));
	},

	match: function(expression){
		return !expression || Slick.match(this, expression);
	}

});



if (window.$$ == null) Window.implement('$$', function(selector){
	if (arguments.length == 1){
		if (typeof selector == 'string') return Slick.search(this.document, selector, new Elements);
		else if (Type.isEnumerable(selector)) return new Elements(selector);
	}
	return new Elements(arguments);
});

// Inserters

var inserters = {

	before: function(context, element){
		var parent = element.parentNode;
		if (parent) parent.insertBefore(context, element);
	},

	after: function(context, element){
		var parent = element.parentNode;
		if (parent) parent.insertBefore(context, element.nextSibling);
	},

	bottom: function(context, element){
		element.appendChild(context);
	},

	top: function(context, element){
		element.insertBefore(context, element.firstChild);
	}

};

inserters.inside = inserters.bottom;



// getProperty / setProperty

var propertyGetters = {}, propertySetters = {};

// properties

var properties = {};
Array.forEach([
	'type', 'value', 'defaultValue', 'accessKey', 'cellPadding', 'cellSpacing', 'colSpan',
	'frameBorder', 'rowSpan', 'tabIndex', 'useMap'
], function(property){
	properties[property.toLowerCase()] = property;
});

properties.html = 'innerHTML';
properties.text = (document.createElement('div').textContent == null) ? 'innerText': 'textContent';

Object.forEach(properties, function(real, key){
	propertySetters[key] = function(node, value){
		node[real] = value;
	};
	propertyGetters[key] = function(node){
		return node[real];
	};
});

/*<ltIE9>*/
propertySetters.text = (function(){
	return function(node, value){
		if (node.get('tag') == 'style') node.set('html', value);
		else node[properties.text] = value;
	};
})(propertySetters.text);

propertyGetters.text = (function(getter){
	return function(node){
		return (node.get('tag') == 'style') ? node.innerHTML : getter(node);
	};
})(propertyGetters.text);
/*</ltIE9>*/

// Booleans

var bools = [
	'compact', 'nowrap', 'ismap', 'declare', 'noshade', 'checked',
	'disabled', 'readOnly', 'multiple', 'selected', 'noresize',
	'defer', 'defaultChecked', 'autofocus', 'controls', 'autoplay',
	'loop'
];

var booleans = {};
Array.forEach(bools, function(bool){
	var lower = bool.toLowerCase();
	booleans[lower] = bool;
	propertySetters[lower] = function(node, value){
		node[bool] = !!value;
	};
	propertyGetters[lower] = function(node){
		return !!node[bool];
	};
});

// Special cases

Object.append(propertySetters, {

	'class': function(node, value){
		('className' in node) ? node.className = (value || '') : node.setAttribute('class', value);
	},

	'for': function(node, value){
		('htmlFor' in node) ? node.htmlFor = value : node.setAttribute('for', value);
	},

	'style': function(node, value){
		(node.style) ? node.style.cssText = value : node.setAttribute('style', value);
	},

	'value': function(node, value){
		node.value = (value != null) ? value : '';
	}

});

propertyGetters['class'] = function(node){
	return ('className' in node) ? node.className || null : node.getAttribute('class');
};

/* <webkit> */
var el = document.createElement('button');
// IE sets type as readonly and throws
try { el.type = 'button'; } catch (e){}
if (el.type != 'button') propertySetters.type = function(node, value){
	node.setAttribute('type', value);
};
el = null;
/* </webkit> */

/*<IE>*/

/*<ltIE9>*/
// #2479 - IE8 Cannot set HTML of style element
var canChangeStyleHTML = (function(){
	var div = document.createElement('style'),
		flag = false;
	try {
		div.innerHTML = '#justTesing{margin: 0px;}';
		flag = !!div.innerHTML;
	} catch (e){}
	return flag;
})();
/*</ltIE9>*/

var input = document.createElement('input'), volatileInputValue, html5InputSupport;

// #2178
input.value = 't';
input.type = 'submit';
volatileInputValue = input.value != 't';

// #2443 - IE throws "Invalid Argument" when trying to use html5 input types
try {
	input.value = '';
	input.type = 'email';
	html5InputSupport = input.type == 'email';
} catch (e){}

input = null;

if (volatileInputValue || !html5InputSupport) propertySetters.type = function(node, type){
	try {
		var value = node.value;
		node.type = type;
		node.value = value;
	} catch (e){}
};
/*</IE>*/

/* getProperty, setProperty */

/* <ltIE9> */
var pollutesGetAttribute = (function(div){
	div.random = 'attribute';
	return (div.getAttribute('random') == 'attribute');
})(document.createElement('div'));

var hasCloneBug = (function(test){
	test.innerHTML = '<object><param name="should_fix" value="the unknown" /></object>';
	return test.cloneNode(true).firstChild.childNodes.length != 1;
})(document.createElement('div'));
/* </ltIE9> */

var hasClassList = !!document.createElement('div').classList;

var classes = function(className){
	var classNames = (className || '').clean().split(' '), uniques = {};
	return classNames.filter(function(className){
		if (className !== '' && !uniques[className]) return uniques[className] = className;
	});
};

var addToClassList = function(name){
	this.classList.add(name);
};

var removeFromClassList = function(name){
	this.classList.remove(name);
};

Element.implement({

	setProperty: function(name, value){
		var setter = propertySetters[name.toLowerCase()];
		if (setter){
			setter(this, value);
		} else {
			/* <ltIE9> */
			var attributeWhiteList;
			if (pollutesGetAttribute) attributeWhiteList = this.retrieve('$attributeWhiteList', {});
			/* </ltIE9> */

			if (value == null){
				this.removeAttribute(name);
				/* <ltIE9> */
				if (pollutesGetAttribute) delete attributeWhiteList[name];
				/* </ltIE9> */
			} else {
				this.setAttribute(name, '' + value);
				/* <ltIE9> */
				if (pollutesGetAttribute) attributeWhiteList[name] = true;
				/* </ltIE9> */
			}
		}
		return this;
	},

	setProperties: function(attributes){
		for (var attribute in attributes) this.setProperty(attribute, attributes[attribute]);
		return this;
	},

	getProperty: function(name){
		var getter = propertyGetters[name.toLowerCase()];
		if (getter) return getter(this);
		/* <ltIE9> */
		if (pollutesGetAttribute){
			var attr = this.getAttributeNode(name), attributeWhiteList = this.retrieve('$attributeWhiteList', {});
			if (!attr) return null;
			if (attr.expando && !attributeWhiteList[name]){
				var outer = this.outerHTML;
				// segment by the opening tag and find mention of attribute name
				if (outer.substr(0, outer.search(/\/?['"]?>(?![^<]*<['"])/)).indexOf(name) < 0) return null;
				attributeWhiteList[name] = true;
			}
		}
		/* </ltIE9> */
		var result = Slick.getAttribute(this, name);
		return (!result && !Slick.hasAttribute(this, name)) ? null : result;
	},

	getProperties: function(){
		var args = Array.convert(arguments);
		return args.map(this.getProperty, this).associate(args);
	},

	removeProperty: function(name){
		return this.setProperty(name, null);
	},

	removeProperties: function(){
		Array.each(arguments, this.removeProperty, this);
		return this;
	},

	set: function(prop, value){
		var property = Element.Properties[prop];
		(property && property.set) ? property.set.call(this, value) : this.setProperty(prop, value);
	}.overloadSetter(),

	get: function(prop){
		var property = Element.Properties[prop];
		return (property && property.get) ? property.get.apply(this) : this.getProperty(prop);
	}.overloadGetter(),

	erase: function(prop){
		var property = Element.Properties[prop];
		(property && property.erase) ? property.erase.apply(this) : this.removeProperty(prop);
		return this;
	},

	hasClass: hasClassList ? function(className){
		return this.classList.contains(className);
	} : function(className){
		return classes(this.className).contains(className);
	},

	addClass: hasClassList ? function(className){
		classes(className).forEach(addToClassList, this);
		return this;
	} : function(className){
		this.className = classes(className + ' ' + this.className).join(' ');
		return this;
	},

	removeClass: hasClassList ? function(className){
		classes(className).forEach(removeFromClassList, this);
		return this;
	} : function(className){
		var classNames = classes(this.className);
		classes(className).forEach(classNames.erase, classNames);
		this.className = classNames.join(' ');
		return this;
	},

	toggleClass: function(className, force){
		if (force == null) force = !this.hasClass(className);
		return (force) ? this.addClass(className) : this.removeClass(className);
	},

	adopt: function(){
		var parent = this, fragment, elements = Array.flatten(arguments), length = elements.length;
		if (length > 1) parent = fragment = document.createDocumentFragment();

		for (var i = 0; i < length; i++){
			var element = document.id(elements[i], true);
			if (element) parent.appendChild(element);
		}

		if (fragment) this.appendChild(fragment);

		return this;
	},

	appendText: function(text, where){
		return this.grab(this.getDocument().newTextNode(text), where);
	},

	grab: function(el, where){
		inserters[where || 'bottom'](document.id(el, true), this);
		return this;
	},

	inject: function(el, where){
		inserters[where || 'bottom'](this, document.id(el, true));
		return this;
	},

	replaces: function(el){
		el = document.id(el, true);
		el.parentNode.replaceChild(this, el);
		return this;
	},

	wraps: function(el, where){
		el = document.id(el, true);
		return this.replaces(el).grab(el, where);
	},

	getSelected: function(){
		this.selectedIndex; // Safari 3.2.1
		return new Elements(Array.convert(this.options).filter(function(option){
			return option.selected;
		}));
	},

	toQueryString: function(){
		var queryString = [];
		this.getElements('input, select, textarea').each(function(el){
			var type = el.type;
			if (!el.name || el.disabled || type == 'submit' || type == 'reset' || type == 'file' || type == 'image') return;

			var value = (el.get('tag') == 'select') ? el.getSelected().map(function(opt){
				// IE
				return document.id(opt).get('value');
			}) : ((type == 'radio' || type == 'checkbox') && !el.checked) ? null : el.get('value');

			Array.convert(value).each(function(val){
				if (typeof val != 'undefined') queryString.push(encodeURIComponent(el.name) + '=' + encodeURIComponent(val));
			});
		});
		return queryString.join('&');
	}

});


// appendHTML

var appendInserters = {
	before: 'beforeBegin',
	after: 'afterEnd',
	bottom: 'beforeEnd',
	top: 'afterBegin',
	inside: 'beforeEnd'
};

Element.implement('appendHTML', ('insertAdjacentHTML' in document.createElement('div')) ? function(html, where){
	this.insertAdjacentHTML(appendInserters[where || 'bottom'], html);
	return this;
} : function(html, where){
	var temp = new Element('div', {html: html}),
		children = temp.childNodes,
		fragment = temp.firstChild;

	if (!fragment) return this;
	if (children.length > 1){
		fragment = document.createDocumentFragment();
		for (var i = 0, l = children.length; i < l; i++){
			fragment.appendChild(children[i]);
		}
	}

	inserters[where || 'bottom'](fragment, this);
	return this;
});

var collected = {}, storage = {};

var get = function(uid){
	return (storage[uid] || (storage[uid] = {}));
};

var clean = function(item){
	var uid = item.uniqueNumber;
	if (item.removeEvents) item.removeEvents();
	if (item.clearAttributes) item.clearAttributes();
	if (uid != null){
		delete collected[uid];
		delete storage[uid];
	}
	return item;
};

var formProps = {input: 'checked', option: 'selected', textarea: 'value'};

Element.implement({

	destroy: function(){
		var children = clean(this).getElementsByTagName('*');
		Array.each(children, clean);
		Element.dispose(this);
		return null;
	},

	empty: function(){
		Array.convert(this.childNodes).each(Element.dispose);
		return this;
	},

	dispose: function(){
		return (this.parentNode) ? this.parentNode.removeChild(this) : this;
	},

	clone: function(contents, keepid){
		contents = contents !== false;
		var clone = this.cloneNode(contents), ce = [clone], te = [this], i;

		if (contents){
			ce.append(Array.convert(clone.getElementsByTagName('*')));
			te.append(Array.convert(this.getElementsByTagName('*')));
		}

		for (i = ce.length; i--;){
			var node = ce[i], element = te[i];
			if (!keepid) node.removeAttribute('id');
			/*<ltIE9>*/
			if (node.clearAttributes){
				node.clearAttributes();
				node.mergeAttributes(element);
				node.removeAttribute('uniqueNumber');
				if (node.options){
					var no = node.options, eo = element.options;
					for (var j = no.length; j--;) no[j].selected = eo[j].selected;
				}
			}
			/*</ltIE9>*/
			var prop = formProps[element.tagName.toLowerCase()];
			if (prop && element[prop]) node[prop] = element[prop];
		}

		/*<ltIE9>*/
		if (hasCloneBug){
			var co = clone.getElementsByTagName('object'), to = this.getElementsByTagName('object');
			for (i = co.length; i--;) co[i].outerHTML = to[i].outerHTML;
		}
		/*</ltIE9>*/
		return document.id(clone);
	}

});

[Element, Window, Document].invoke('implement', {

	addListener: function(type, fn){
		if (window.attachEvent && !window.addEventListener){
			collected[Slick.uidOf(this)] = this;
		}
		if (this.addEventListener) this.addEventListener(type, fn, !!arguments[2]);
		else this.attachEvent('on' + type, fn);
		return this;
	},

	removeListener: function(type, fn){
		if (this.removeEventListener) this.removeEventListener(type, fn, !!arguments[2]);
		else this.detachEvent('on' + type, fn);
		return this;
	},

	retrieve: function(property, dflt){
		var storage = get(Slick.uidOf(this)), prop = storage[property];
		if (dflt != null && prop == null) prop = storage[property] = dflt;
		return prop != null ? prop : null;
	},

	store: function(property, value){
		var storage = get(Slick.uidOf(this));
		storage[property] = value;
		return this;
	},

	eliminate: function(property){
		var storage = get(Slick.uidOf(this));
		delete storage[property];
		return this;
	}

});

/*<ltIE9>*/
if (window.attachEvent && !window.addEventListener){
	var gc = function(){
		Object.each(collected, clean);
		if (window.CollectGarbage) CollectGarbage();
		window.removeListener('unload', gc);
	};
	window.addListener('unload', gc);
}
/*</ltIE9>*/

Element.Properties = {};



Element.Properties.style = {

	set: function(style){
		this.style.cssText = style;
	},

	get: function(){
		return this.style.cssText;
	},

	erase: function(){
		this.style.cssText = '';
	}

};

Element.Properties.tag = {

	get: function(){
		return this.tagName.toLowerCase();
	}

};

Element.Properties.html = {

	set: function(html){
		if (html == null) html = '';
		else if (typeOf(html) == 'array') html = html.join('');

		/*<ltIE9>*/
		if (this.styleSheet && !canChangeStyleHTML) this.styleSheet.cssText = html;
		else /*</ltIE9>*/this.innerHTML = html;
	},
	erase: function(){
		this.set('html', '');
	}

};

var supportsHTML5Elements = true, supportsTableInnerHTML = true, supportsTRInnerHTML = true;

/*<ltIE9>*/
// technique by jdbarlett - http://jdbartlett.com/innershiv/
var div = document.createElement('div');
var fragment;
div.innerHTML = '<nav></nav>';
supportsHTML5Elements = (div.childNodes.length == 1);
if (!supportsHTML5Elements){
	var tags = 'abbr article aside audio canvas datalist details figcaption figure footer header hgroup mark meter nav output progress section summary time video'.split(' ');
	fragment = document.createDocumentFragment(), l = tags.length;
	while (l--) fragment.createElement(tags[l]);
}
div = null;
/*</ltIE9>*/

/*<IE>*/
supportsTableInnerHTML = Function.attempt(function(){
	var table = document.createElement('table');
	table.innerHTML = '<tr><td></td></tr>';
	return true;
});

/*<ltFF4>*/
var tr = document.createElement('tr'), html = '<td></td>';
tr.innerHTML = html;
supportsTRInnerHTML = (tr.innerHTML == html);
tr = null;
/*</ltFF4>*/

if (!supportsTableInnerHTML || !supportsTRInnerHTML || !supportsHTML5Elements){

	Element.Properties.html.set = (function(set){

		var translations = {
			table: [1, '<table>', '</table>'],
			select: [1, '<select>', '</select>'],
			tbody: [2, '<table><tbody>', '</tbody></table>'],
			tr: [3, '<table><tbody><tr>', '</tr></tbody></table>']
		};

		translations.thead = translations.tfoot = translations.tbody;

		return function(html){

			/*<ltIE9>*/
			if (this.styleSheet) return set.call(this, html);
			/*</ltIE9>*/
			var wrap = translations[this.get('tag')];
			if (!wrap && !supportsHTML5Elements) wrap = [0, '', ''];
			if (!wrap) return set.call(this, html);

			var level = wrap[0], wrapper = document.createElement('div'), target = wrapper;
			if (!supportsHTML5Elements) fragment.appendChild(wrapper);
			wrapper.innerHTML = [wrap[1], html, wrap[2]].flatten().join('');
			while (level--) target = target.firstChild;
			this.empty().adopt(target.childNodes);
			if (!supportsHTML5Elements) fragment.removeChild(wrapper);
			wrapper = null;
		};

	})(Element.Properties.html.set);
}
/*</IE>*/

/*<ltIE9>*/
var testForm = document.createElement('form');
testForm.innerHTML = '<select><option>s</option></select>';

if (testForm.firstChild.value != 's') Element.Properties.value = {

	set: function(value){
		var tag = this.get('tag');
		if (tag != 'select') return this.setProperty('value', value);
		var options = this.getElements('option');
		value = String(value);
		for (var i = 0; i < options.length; i++){
			var option = options[i],
				attr = option.getAttributeNode('value'),
				optionValue = (attr && attr.specified) ? option.value : option.get('text');
			if (optionValue === value) return option.selected = true;
		}
	},

	get: function(){
		var option = this, tag = option.get('tag');

		if (tag != 'select' && tag != 'option') return this.getProperty('value');

		if (tag == 'select' && !(option = option.getSelected()[0])) return '';

		var attr = option.getAttributeNode('value');
		return (attr && attr.specified) ? option.value : option.get('text');
	}

};
testForm = null;
/*</ltIE9>*/

/*<IE>*/
if (document.createElement('div').getAttributeNode('id')) Element.Properties.id = {
	set: function(id){
		this.id = this.getAttributeNode('id').value = id;
	},
	get: function(){
		return this.id || null;
	},
	erase: function(){
		this.id = this.getAttributeNode('id').value = '';
	}
};
/*</IE>*/

})();

/*
---

name: Event

description: Contains the Event Type, to make the event object cross-browser.

license: MIT-style license.

requires: [Window, Document, Array, Function, String, Object]

provides: Event

...
*/

(function(){

var _keys = {};
var normalizeWheelSpeed = function(event){
	var normalized;
	if (event.wheelDelta){
		normalized = event.wheelDelta % 120 == 0 ? event.wheelDelta / 120 : event.wheelDelta / 12;
	} else {
		var rawAmount = event.deltaY || event.detail || 0;
		normalized = -(rawAmount % 3 == 0 ? rawAmount / 3 : rawAmount * 10);
	}
	return normalized;
};

var DOMEvent = this.DOMEvent = new Type('DOMEvent', function(event, win){
	if (!win) win = window;
	event = event || win.event;
	if (event.$extended) return event;
	this.event = event;
	this.$extended = true;
	this.shift = event.shiftKey;
	this.control = event.ctrlKey;
	this.alt = event.altKey;
	this.meta = event.metaKey;
	var type = this.type = event.type;
	var target = event.target || event.srcElement;
	while (target && target.nodeType == 3) target = target.parentNode;
	this.target = document.id(target);

	if (type.indexOf('key') == 0){
		var code = this.code = (event.which || event.keyCode);
		if (!this.shift || type != 'keypress') this.key = _keys[code];
		if (type == 'keydown' || type == 'keyup'){
			if (code > 111 && code < 124) this.key = 'f' + (code - 111);
			else if (code > 95 && code < 106) this.key = code - 96;
		}
		if (this.key == null) this.key = String.fromCharCode(code).toLowerCase();
	} else if (type == 'click' || type == 'dblclick' || type == 'contextmenu' || type == 'wheel' || type == 'DOMMouseScroll' || type.indexOf('mouse') == 0){
		var doc = win.document;
		doc = (!doc.compatMode || doc.compatMode == 'CSS1Compat') ? doc.html : doc.body;
		this.page = {
			x: (event.pageX != null) ? event.pageX : event.clientX + doc.scrollLeft,
			y: (event.pageY != null) ? event.pageY : event.clientY + doc.scrollTop
		};
		this.client = {
			x: (event.pageX != null) ? event.pageX - win.pageXOffset : event.clientX,
			y: (event.pageY != null) ? event.pageY - win.pageYOffset : event.clientY
		};
		if (type == 'DOMMouseScroll' || type == 'wheel' || type == 'mousewheel') this.wheel = normalizeWheelSpeed(event);
		this.rightClick = (event.which == 3 || event.button == 2);
		if (type == 'mouseover' || type == 'mouseout' || type == 'mouseenter' || type == 'mouseleave'){
			var overTarget = type == 'mouseover' || type == 'mouseenter';
			var related = event.relatedTarget || event[(overTarget ? 'from' : 'to') + 'Element'];
			while (related && related.nodeType == 3) related = related.parentNode;
			this.relatedTarget = document.id(related);
		}
	} else if (type.indexOf('touch') == 0 || type.indexOf('gesture') == 0){
		this.rotation = event.rotation;
		this.scale = event.scale;
		this.targetTouches = event.targetTouches;
		this.changedTouches = event.changedTouches;
		var touches = this.touches = event.touches;
		if (touches && touches[0]){
			var touch = touches[0];
			this.page = {x: touch.pageX, y: touch.pageY};
			this.client = {x: touch.clientX, y: touch.clientY};
		}
	}

	if (!this.client) this.client = {};
	if (!this.page) this.page = {};
});

DOMEvent.implement({

	stop: function(){
		return this.preventDefault().stopPropagation();
	},

	stopPropagation: function(){
		if (this.event.stopPropagation) this.event.stopPropagation();
		else this.event.cancelBubble = true;
		return this;
	},

	preventDefault: function(){
		if (this.event.preventDefault) this.event.preventDefault();
		else this.event.returnValue = false;
		return this;
	}

});

DOMEvent.defineKey = function(code, key){
	_keys[code] = key;
	return this;
};

DOMEvent.defineKeys = DOMEvent.defineKey.overloadSetter(true);

DOMEvent.defineKeys({
	'38': 'up', '40': 'down', '37': 'left', '39': 'right',
	'27': 'esc', '32': 'space', '8': 'backspace', '9': 'tab',
	'46': 'delete', '13': 'enter'
});

})();





/*
---

name: Element.Event

description: Contains Element methods for dealing with events. This file also includes mouseenter and mouseleave custom Element Events, if necessary.

license: MIT-style license.

requires: [Element, Event]

provides: Element.Event

...
*/

(function(){

Element.Properties.events = {set: function(events){
	this.addEvents(events);
}};

[Element, Window, Document].invoke('implement', {

	addEvent: function(type, fn){
		var events = this.retrieve('events', {});
		if (!events[type]) events[type] = {keys: [], values: []};
		if (events[type].keys.contains(fn)) return this;
		events[type].keys.push(fn);
		var realType = type,
			custom = Element.Events[type],
			condition = fn,
			self = this;
		if (custom){
			if (custom.onAdd) custom.onAdd.call(this, fn, type);
			if (custom.condition){
				condition = function(event){
					if (custom.condition.call(this, event, type)) return fn.call(this, event);
					return true;
				};
			}
			if (custom.base) realType = Function.convert(custom.base).call(this, type);
		}
		var defn = function(){
			return fn.call(self);
		};
		var nativeEvent = Element.NativeEvents[realType];
		if (nativeEvent){
			if (nativeEvent == 2){
				defn = function(event){
					event = new DOMEvent(event, self.getWindow());
					if (condition.call(self, event) === false) event.stop();
				};
			}
			this.addListener(realType, defn, arguments[2]);
		}
		events[type].values.push(defn);
		return this;
	},

	removeEvent: function(type, fn){
		var events = this.retrieve('events');
		if (!events || !events[type]) return this;
		var list = events[type];
		var index = list.keys.indexOf(fn);
		if (index == -1) return this;
		var value = list.values[index];
		delete list.keys[index];
		delete list.values[index];
		var custom = Element.Events[type];
		if (custom){
			if (custom.onRemove) custom.onRemove.call(this, fn, type);
			if (custom.base) type = Function.convert(custom.base).call(this, type);
		}
		return (Element.NativeEvents[type]) ? this.removeListener(type, value, arguments[2]) : this;
	},

	addEvents: function(events){
		for (var event in events) this.addEvent(event, events[event]);
		return this;
	},

	removeEvents: function(events){
		var type;
		if (typeOf(events) == 'object'){
			for (type in events) this.removeEvent(type, events[type]);
			return this;
		}
		var attached = this.retrieve('events');
		if (!attached) return this;
		if (!events){
			for (type in attached) this.removeEvents(type);
			this.eliminate('events');
		} else if (attached[events]){
			attached[events].keys.each(function(fn){
				this.removeEvent(events, fn);
			}, this);
			delete attached[events];
		}
		return this;
	},

	fireEvent: function(type, args, delay){
		var events = this.retrieve('events');
		if (!events || !events[type]) return this;
		args = Array.convert(args);

		events[type].keys.each(function(fn){
			if (delay) fn.delay(delay, this, args);
			else fn.apply(this, args);
		}, this);
		return this;
	},

	cloneEvents: function(from, type){
		from = document.id(from);
		var events = from.retrieve('events');
		if (!events) return this;
		if (!type){
			for (var eventType in events) this.cloneEvents(from, eventType);
		} else if (events[type]){
			events[type].keys.each(function(fn){
				this.addEvent(type, fn);
			}, this);
		}
		return this;
	}

});

Element.NativeEvents = {
	click: 2, dblclick: 2, mouseup: 2, mousedown: 2, contextmenu: 2, //mouse buttons
	wheel: 2, mousewheel: 2, DOMMouseScroll: 2, //mouse wheel
	mouseover: 2, mouseout: 2, mousemove: 2, selectstart: 2, selectend: 2, //mouse movement
	keydown: 2, keypress: 2, keyup: 2, //keyboard
	orientationchange: 2, // mobile
	touchstart: 2, touchmove: 2, touchend: 2, touchcancel: 2, // touch
	gesturestart: 2, gesturechange: 2, gestureend: 2, // gesture
	focus: 2, blur: 2, change: 2, reset: 2, select: 2, submit: 2, paste: 2, input: 2, //form elements
	load: 2, unload: 1, beforeunload: 2, resize: 1, move: 1, DOMContentLoaded: 1, readystatechange: 1, //window
	hashchange: 1, popstate: 2, pageshow: 2, pagehide: 2, // history
	error: 1, abort: 1, scroll: 1, message: 2 //misc
};

Element.Events = {
	mousewheel: {
		base: 'onwheel' in document ? 'wheel' : 'onmousewheel' in document ? 'mousewheel' : 'DOMMouseScroll'
	}
};

var check = function(event){
	var related = event.relatedTarget;
	if (related == null) return true;
	if (!related) return false;
	return (related != this && related.prefix != 'xul' && typeOf(this) != 'document' && !this.contains(related));
};

if ('onmouseenter' in document.documentElement){
	Element.NativeEvents.mouseenter = Element.NativeEvents.mouseleave = 2;
	Element.MouseenterCheck = check;
} else {
	Element.Events.mouseenter = {
		base: 'mouseover',
		condition: check
	};

	Element.Events.mouseleave = {
		base: 'mouseout',
		condition: check
	};
}

/*<ltIE9>*/
if (!window.addEventListener){
	Element.NativeEvents.propertychange = 2;
	Element.Events.change = {
		base: function(){
			var type = this.type;
			return (this.get('tag') == 'input' && (type == 'radio' || type == 'checkbox')) ? 'propertychange' : 'change';
		},
		condition: function(event){
			return event.type != 'propertychange' || event.event.propertyName == 'checked';
		}
	};
}
/*</ltIE9>*/



})();

/*
---

name: Element.Delegation

description: Extends the Element native object to include the delegate method for more efficient event management.

license: MIT-style license.

requires: [Element.Event]

provides: [Element.Delegation]

...
*/

(function(){

var eventListenerSupport = !!window.addEventListener;

Element.NativeEvents.focusin = Element.NativeEvents.focusout = 2;

var bubbleUp = function(self, match, fn, event, target){
	while (target && target != self){
		if (match(target, event)) return fn.call(target, event, target);
		target = document.id(target.parentNode);
	}
};

var map = {
	mouseenter: {
		base: 'mouseover',
		condition: Element.MouseenterCheck
	},
	mouseleave: {
		base: 'mouseout',
		condition: Element.MouseenterCheck
	},
	focus: {
		base: 'focus' + (eventListenerSupport ? '' : 'in'),
		capture: true
	},
	blur: {
		base: eventListenerSupport ? 'blur' : 'focusout',
		capture: true
	}
};

/*<ltIE9>*/
var _key = '$delegation:';
var formObserver = function(type){

	return {

		base: 'focusin',

		remove: function(self, uid){
			var list = self.retrieve(_key + type + 'listeners', {})[uid];
			if (list && list.forms) for (var i = list.forms.length; i--;){
				// the form may have been destroyed, so it won't have the
				// removeEvent method anymore. In that case the event was
				// removed as well.
				if (list.forms[i].removeEvent) list.forms[i].removeEvent(type, list.fns[i]);
			}
		},

		listen: function(self, match, fn, event, target, uid){
			var form = (target.get('tag') == 'form') ? target : event.target.getParent('form');
			if (!form) return;

			var listeners = self.retrieve(_key + type + 'listeners', {}),
				listener = listeners[uid] || {forms: [], fns: []},
				forms = listener.forms, fns = listener.fns;

			if (forms.indexOf(form) != -1) return;
			forms.push(form);

			var _fn = function(event){
				bubbleUp(self, match, fn, event, target);
			};
			form.addEvent(type, _fn);
			fns.push(_fn);

			listeners[uid] = listener;
			self.store(_key + type + 'listeners', listeners);
		}
	};
};

var inputObserver = function(type){
	return {
		base: 'focusin',
		listen: function(self, match, fn, event, target){
			var events = {blur: function(){
				this.removeEvents(events);
			}};
			events[type] = function(event){
				bubbleUp(self, match, fn, event, target);
			};
			event.target.addEvents(events);
		}
	};
};

if (!eventListenerSupport) Object.append(map, {
	submit: formObserver('submit'),
	reset: formObserver('reset'),
	change: inputObserver('change'),
	select: inputObserver('select')
});
/*</ltIE9>*/

var proto = Element.prototype,
	addEvent = proto.addEvent,
	removeEvent = proto.removeEvent;

var relay = function(old, method){
	return function(type, fn, useCapture){
		if (type.indexOf(':relay') == -1) return old.call(this, type, fn, useCapture);
		var parsed = Slick.parse(type).expressions[0][0];
		if (parsed.pseudos[0].key != 'relay') return old.call(this, type, fn, useCapture);
		var newType = parsed.tag;
		parsed.pseudos.slice(1).each(function(pseudo){
			newType += ':' + pseudo.key + (pseudo.value ? '(' + pseudo.value + ')' : '');
		});
		old.call(this, type, fn);
		return method.call(this, newType, parsed.pseudos[0].value, fn);
	};
};

var delegation = {

	addEvent: function(type, match, fn){
		var storage = this.retrieve('$delegates', {}), stored = storage[type];
		if (stored) for (var _uid in stored){
			if (stored[_uid].fn == fn && stored[_uid].match == match) return this;
		}

		var _type = type, _match = match, _fn = fn, _map = map[type] || {};
		type = _map.base || _type;

		match = function(target){
			return Slick.match(target, _match);
		};

		var elementEvent = Element.Events[_type];
		if (_map.condition || elementEvent && elementEvent.condition){
			var __match = match, condition = _map.condition || elementEvent.condition;
			match = function(target, event){
				return __match(target, event) && condition.call(target, event, type);
			};
		}

		var self = this, uid = String.uniqueID();
		var delegator = _map.listen ? function(event, target){
			if (!target && event && event.target) target = event.target;
			if (target) _map.listen(self, match, fn, event, target, uid);
		} : function(event, target){
			if (!target && event && event.target) target = event.target;
			if (target) bubbleUp(self, match, fn, event, target);
		};

		if (!stored) stored = {};
		stored[uid] = {
			match: _match,
			fn: _fn,
			delegator: delegator
		};
		storage[_type] = stored;
		return addEvent.call(this, type, delegator, _map.capture);
	},

	removeEvent: function(type, match, fn, _uid){
		var storage = this.retrieve('$delegates', {}), stored = storage[type];
		if (!stored) return this;

		if (_uid){
			var _type = type, delegator = stored[_uid].delegator, _map = map[type] || {};
			type = _map.base || _type;
			if (_map.remove) _map.remove(this, _uid);
			delete stored[_uid];
			storage[_type] = stored;
			return removeEvent.call(this, type, delegator, _map.capture);
		}

		var __uid, s;
		if (fn) for (__uid in stored){
			s = stored[__uid];
			if (s.match == match && s.fn == fn) return delegation.removeEvent.call(this, type, match, fn, __uid);
		} else for (__uid in stored){
			s = stored[__uid];
			if (s.match == match) delegation.removeEvent.call(this, type, match, s.fn, __uid);
		}
		return this;
	}

};

[Element, Window, Document].invoke('implement', {
	addEvent: relay(addEvent, delegation.addEvent),
	removeEvent: relay(removeEvent, delegation.removeEvent)
});

})();

/*
---

name: Element.Style

description: Contains methods for interacting with the styles of Elements in a fashionable way.

license: MIT-style license.

requires: Element

provides: Element.Style

...
*/

(function(){

var html = document.html, el;

//<ltIE9>
// Check for oldIE, which does not remove styles when they're set to null
el = document.createElement('div');
el.style.color = 'red';
el.style.color = null;
var doesNotRemoveStyles = el.style.color == 'red';

// check for oldIE, which returns border* shorthand styles in the wrong order (color-width-style instead of width-style-color)
var border = '1px solid #123abc';
el.style.border = border;
var returnsBordersInWrongOrder = el.style.border != border;
el = null;
//</ltIE9>

var hasGetComputedStyle = !!window.getComputedStyle,
	supportBorderRadius = document.createElement('div').style.borderRadius != null;

Element.Properties.styles = {set: function(styles){
	this.setStyles(styles);
}};

var hasOpacity = (html.style.opacity != null),
	hasFilter = (html.style.filter != null),
	reAlpha = /alpha\(opacity=([\d.]+)\)/i;

var setVisibility = function(element, opacity){
	element.store('$opacity', opacity);
	element.style.visibility = opacity > 0 || opacity == null ? 'visible' : 'hidden';
};

//<ltIE9>
var setFilter = function(element, regexp, value){
	var style = element.style,
		filter = style.filter || element.getComputedStyle('filter') || '';
	style.filter = (regexp.test(filter) ? filter.replace(regexp, value) : filter + ' ' + value).trim();
	if (!style.filter) style.removeAttribute('filter');
};
//</ltIE9>

var setOpacity = (hasOpacity ? function(element, opacity){
	element.style.opacity = opacity;
} : (hasFilter ? function(element, opacity){
	if (!element.currentStyle || !element.currentStyle.hasLayout) element.style.zoom = 1;
	if (opacity == null || opacity == 1){
		setFilter(element, reAlpha, '');
		if (opacity == 1 && getOpacity(element) != 1) setFilter(element, reAlpha, 'alpha(opacity=100)');
	} else {
		setFilter(element, reAlpha, 'alpha(opacity=' + (opacity * 100).limit(0, 100).round() + ')');
	}
} : setVisibility));

var getOpacity = (hasOpacity ? function(element){
	var opacity = element.style.opacity || element.getComputedStyle('opacity');
	return (opacity == '') ? 1 : opacity.toFloat();
} : (hasFilter ? function(element){
	var filter = (element.style.filter || element.getComputedStyle('filter')),
		opacity;
	if (filter) opacity = filter.match(reAlpha);
	return (opacity == null || filter == null) ? 1 : (opacity[1] / 100);
} : function(element){
	var opacity = element.retrieve('$opacity');
	if (opacity == null) opacity = (element.style.visibility == 'hidden' ? 0 : 1);
	return opacity;
}));

var floatName = (html.style.cssFloat == null) ? 'styleFloat' : 'cssFloat',
	namedPositions = {left: '0%', top: '0%', center: '50%', right: '100%', bottom: '100%'},
	hasBackgroundPositionXY = (html.style.backgroundPositionX != null),
	prefixPattern = /^-(ms)-/;

var camelCase = function(property){
	return property.replace(prefixPattern, '$1-').camelCase();
};

//<ltIE9>
var removeStyle = function(style, property){
	if (property == 'backgroundPosition'){
		style.removeAttribute(property + 'X');
		property += 'Y';
	}
	style.removeAttribute(property);
};
//</ltIE9>

Element.implement({

	getComputedStyle: function(property){
		if (!hasGetComputedStyle && this.currentStyle) return this.currentStyle[camelCase(property)];
		var defaultView = Element.getDocument(this).defaultView,
			computed = defaultView ? defaultView.getComputedStyle(this, null) : null;
		return (computed) ? computed.getPropertyValue((property == floatName) ? 'float' : property.hyphenate()) : '';
	},

	setStyle: function(property, value){
		if (property == 'opacity'){
			if (value != null) value = parseFloat(value);
			setOpacity(this, value);
			return this;
		}
		property = camelCase(property == 'float' ? floatName : property);
		if (typeOf(value) != 'string'){
			var map = (Element.Styles[property] || '@').split(' ');
			value = Array.convert(value).map(function(val, i){
				if (!map[i]) return '';
				return (typeOf(val) == 'number') ? map[i].replace('@', Math.round(val)) : val;
			}).join(' ');
		} else if (value == String(Number(value))){
			value = Math.round(value);
		}
		this.style[property] = value;
		//<ltIE9>
		if ((value == '' || value == null) && doesNotRemoveStyles && this.style.removeAttribute){
			removeStyle(this.style, property);
		}
		//</ltIE9>
		return this;
	},

	getStyle: function(property){
		if (property == 'opacity') return getOpacity(this);
		property = camelCase(property == 'float' ? floatName : property);
		if (supportBorderRadius && property.indexOf('borderRadius') != -1){
			return ['borderTopLeftRadius', 'borderTopRightRadius', 'borderBottomRightRadius', 'borderBottomLeftRadius'].map(function(corner){
				return this.style[corner] || '0px';
			}, this).join(' ');
		}
		var result = this.style[property];
		if (!result || property == 'zIndex'){
			if (Element.ShortStyles.hasOwnProperty(property)){
				result = [];
				for (var s in Element.ShortStyles[property]) result.push(this.getStyle(s));
				return result.join(' ');
			}
			result = this.getComputedStyle(property);
		}
		if (hasBackgroundPositionXY && /^backgroundPosition[XY]?$/.test(property)){
			return result.replace(/(top|right|bottom|left)/g, function(position){
				return namedPositions[position];
			}) || '0px';
		}
		if (!result && property == 'backgroundPosition') return '0px 0px';
		if (result){
			result = String(result);
			var color = result.match(/rgba?\([\d\s,]+\)/);
			if (color) result = result.replace(color[0], color[0].rgbToHex());
		}
		if (!hasGetComputedStyle && !this.style[property]){
			if ((/^(height|width)$/).test(property) && !(/px$/.test(result))){
				var values = (property == 'width') ? ['left', 'right'] : ['top', 'bottom'], size = 0;
				values.each(function(value){
					size += this.getStyle('border-' + value + '-width').toInt() + this.getStyle('padding-' + value).toInt();
				}, this);
				return this['offset' + property.capitalize()] - size + 'px';
			}
			if ((/^border(.+)Width|margin|padding/).test(property) && isNaN(parseFloat(result))){
				return '0px';
			}
		}
		//<ltIE9>
		if (returnsBordersInWrongOrder && /^border(Top|Right|Bottom|Left)?$/.test(property) && /^#/.test(result)){
			return result.replace(/^(.+)\s(.+)\s(.+)$/, '$2 $3 $1');
		}
		//</ltIE9>

		return result;
	},

	setStyles: function(styles){
		for (var style in styles) this.setStyle(style, styles[style]);
		return this;
	},

	getStyles: function(){
		var result = {};
		Array.flatten(arguments).each(function(key){
			result[key] = this.getStyle(key);
		}, this);
		return result;
	}

});

Element.Styles = {
	left: '@px', top: '@px', bottom: '@px', right: '@px',
	width: '@px', height: '@px', maxWidth: '@px', maxHeight: '@px', minWidth: '@px', minHeight: '@px',
	backgroundColor: 'rgb(@, @, @)', backgroundSize: '@px', backgroundPosition: '@px @px', color: 'rgb(@, @, @)',
	fontSize: '@px', letterSpacing: '@px', lineHeight: '@px', clip: 'rect(@px @px @px @px)',
	margin: '@px @px @px @px', padding: '@px @px @px @px', border: '@px @ rgb(@, @, @) @px @ rgb(@, @, @) @px @ rgb(@, @, @)',
	borderWidth: '@px @px @px @px', borderStyle: '@ @ @ @', borderColor: 'rgb(@, @, @) rgb(@, @, @) rgb(@, @, @) rgb(@, @, @)',
	zIndex: '@', 'zoom': '@', fontWeight: '@', textIndent: '@px', opacity: '@', borderRadius: '@px @px @px @px'
};





Element.ShortStyles = {margin: {}, padding: {}, border: {}, borderWidth: {}, borderStyle: {}, borderColor: {}};

['Top', 'Right', 'Bottom', 'Left'].each(function(direction){
	var Short = Element.ShortStyles;
	var All = Element.Styles;
	['margin', 'padding'].each(function(style){
		var sd = style + direction;
		Short[style][sd] = All[sd] = '@px';
	});
	var bd = 'border' + direction;
	Short.border[bd] = All[bd] = '@px @ rgb(@, @, @)';
	var bdw = bd + 'Width', bds = bd + 'Style', bdc = bd + 'Color';
	Short[bd] = {};
	Short.borderWidth[bdw] = Short[bd][bdw] = All[bdw] = '@px';
	Short.borderStyle[bds] = Short[bd][bds] = All[bds] = '@';
	Short.borderColor[bdc] = Short[bd][bdc] = All[bdc] = 'rgb(@, @, @)';
});

if (hasBackgroundPositionXY) Element.ShortStyles.backgroundPosition = {backgroundPositionX: '@', backgroundPositionY: '@'};
})();

/*
---

name: Element.Dimensions

description: Contains methods to work with size, scroll, or positioning of Elements and the window object.

license: MIT-style license.

credits:
  - Element positioning based on the [qooxdoo](http://qooxdoo.org/) code and smart browser fixes, [LGPL License](http://www.gnu.org/licenses/lgpl.html).
  - Viewport dimensions based on [YUI](http://developer.yahoo.com/yui/) code, [BSD License](http://developer.yahoo.com/yui/license.html).

requires: [Element, Element.Style]

provides: [Element.Dimensions]

...
*/

(function(){

var element = document.createElement('div'),
	child = document.createElement('div');
element.style.height = '0';
element.appendChild(child);
var brokenOffsetParent = (child.offsetParent === element);
element = child = null;

var heightComponents = ['height', 'paddingTop', 'paddingBottom', 'borderTopWidth', 'borderBottomWidth'],
	widthComponents = ['width', 'paddingLeft', 'paddingRight', 'borderLeftWidth', 'borderRightWidth'];

var svgCalculateSize = function(el){

	var gCS = window.getComputedStyle(el),
		bounds = {x: 0, y: 0};

	heightComponents.each(function(css){
		bounds.y += parseFloat(gCS[css]);
	});
	widthComponents.each(function(css){
		bounds.x += parseFloat(gCS[css]);
	});
	return bounds;
};

var isOffset = function(el){
	return styleString(el, 'position') != 'static' || isBody(el);
};

var isOffsetStatic = function(el){
	return isOffset(el) || (/^(?:table|td|th)$/i).test(el.tagName);
};

Element.implement({

	scrollTo: function(x, y){
		if (isBody(this)){
			this.getWindow().scrollTo(x, y);
		} else {
			this.scrollLeft = x;
			this.scrollTop = y;
		}
		return this;
	},

	getSize: function(){
		if (isBody(this)) return this.getWindow().getSize();

		//<ltIE9>
		// This if clause is because IE8- cannot calculate getBoundingClientRect of elements with visibility hidden.
		if (!window.getComputedStyle) return {x: this.offsetWidth, y: this.offsetHeight};
		//</ltIE9>

		// This svg section under, calling `svgCalculateSize()`, can be removed when FF fixed the svg size bug.
		// Bug info: https://bugzilla.mozilla.org/show_bug.cgi?id=530985
		if (this.get('tag') == 'svg') return svgCalculateSize(this);

		try {
			var bounds = this.getBoundingClientRect();
			return {x: bounds.width, y: bounds.height};
		} catch (e){
			return {x: 0, y: 0};
		}
	},

	getScrollSize: function(){
		if (isBody(this)) return this.getWindow().getScrollSize();
		return {x: this.scrollWidth, y: this.scrollHeight};
	},

	getScroll: function(){
		if (isBody(this)) return this.getWindow().getScroll();
		return {x: this.scrollLeft, y: this.scrollTop};
	},

	getScrolls: function(){
		var element = this.parentNode, position = {x: 0, y: 0};
		while (element && !isBody(element)){
			position.x += element.scrollLeft;
			position.y += element.scrollTop;
			element = element.parentNode;
		}
		return position;
	},

	getOffsetParent: brokenOffsetParent ? function(){
		var element = this;
		if (isBody(element) || styleString(element, 'position') == 'fixed') return null;

		var isOffsetCheck = (styleString(element, 'position') == 'static') ? isOffsetStatic : isOffset;
		while ((element = element.parentNode)){
			if (isOffsetCheck(element)) return element;
		}
		return null;
	} : function(){
		var element = this;
		if (isBody(element) || styleString(element, 'position') == 'fixed') return null;

		try {
			return element.offsetParent;
		} catch (e){}
		return null;
	},

	getOffsets: function(){
		var hasGetBoundingClientRect = this.getBoundingClientRect;

		if (hasGetBoundingClientRect){
			var bound = this.getBoundingClientRect(),
				html = document.id(this.getDocument().documentElement),
				htmlScroll = html.getScroll(),
				elemScrolls = this.getScrolls(),
				isFixed = (styleString(this, 'position') == 'fixed');

			return {
				x: bound.left.toFloat() + elemScrolls.x + ((isFixed) ? 0 : htmlScroll.x) - html.clientLeft,
				y: bound.top.toFloat() + elemScrolls.y + ((isFixed) ? 0 : htmlScroll.y) - html.clientTop
			};
		}

		var element = this, position = {x: 0, y: 0};
		if (isBody(this)) return position;

		while (element && !isBody(element)){
			position.x += element.offsetLeft;
			position.y += element.offsetTop;

			element = element.offsetParent;
		}

		return position;
	},

	getPosition: function(relative){
		var offset = this.getOffsets(),
			scroll = this.getScrolls();
		var position = {
			x: offset.x - scroll.x,
			y: offset.y - scroll.y
		};

		if (relative && (relative = document.id(relative))){
			var relativePosition = relative.getPosition();
			return {x: position.x - relativePosition.x - leftBorder(relative), y: position.y - relativePosition.y - topBorder(relative)};
		}
		return position;
	},

	getCoordinates: function(element){
		if (isBody(this)) return this.getWindow().getCoordinates();
		var position = this.getPosition(element),
			size = this.getSize();
		var obj = {
			left: position.x,
			top: position.y,
			width: size.x,
			height: size.y
		};
		obj.right = obj.left + obj.width;
		obj.bottom = obj.top + obj.height;
		return obj;
	},

	computePosition: function(obj){
		return {
			left: obj.x - styleNumber(this, 'margin-left'),
			top: obj.y - styleNumber(this, 'margin-top')
		};
	},

	setPosition: function(obj){
		return this.setStyles(this.computePosition(obj));
	}

});


[Document, Window].invoke('implement', {

	getSize: function(){
		var doc = getCompatElement(this);
		return {x: doc.clientWidth, y: doc.clientHeight};
	},

	getScroll: function(){
		var win = this.getWindow(), doc = getCompatElement(this);
		return {x: win.pageXOffset || doc.scrollLeft, y: win.pageYOffset || doc.scrollTop};
	},

	getScrollSize: function(){
		var doc = getCompatElement(this),
			min = this.getSize(),
			body = this.getDocument().body;

		return {x: Math.max(doc.scrollWidth, body.scrollWidth, min.x), y: Math.max(doc.scrollHeight, body.scrollHeight, min.y)};
	},

	getPosition: function(){
		return {x: 0, y: 0};
	},

	getCoordinates: function(){
		var size = this.getSize();
		return {top: 0, left: 0, bottom: size.y, right: size.x, height: size.y, width: size.x};
	}

});

// private methods

var styleString = Element.getComputedStyle;

function styleNumber(element, style){
	return styleString(element, style).toInt() || 0;
}



function topBorder(element){
	return styleNumber(element, 'border-top-width');
}

function leftBorder(element){
	return styleNumber(element, 'border-left-width');
}

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

function getCompatElement(element){
	var doc = element.getDocument();
	return (!doc.compatMode || doc.compatMode == 'CSS1Compat') ? doc.html : doc.body;
}

})();

//aliases
Element.alias({position: 'setPosition'}); //compatability

[Window, Document, Element].invoke('implement', {

	getHeight: function(){
		return this.getSize().y;
	},

	getWidth: function(){
		return this.getSize().x;
	},

	getScrollTop: function(){
		return this.getScroll().y;
	},

	getScrollLeft: function(){
		return this.getScroll().x;
	},

	getScrollHeight: function(){
		return this.getScrollSize().y;
	},

	getScrollWidth: function(){
		return this.getScrollSize().x;
	},

	getTop: function(){
		return this.getPosition().y;
	},

	getLeft: function(){
		return this.getPosition().x;
	}

});

/*
---

name: Fx

description: Contains the basic animation logic to be extended by all other Fx Classes.

license: MIT-style license.

requires: [Chain, Events, Options, Class.Thenable]

provides: Fx

...
*/

(function(){

var Fx = this.Fx = new Class({

	Implements: [Chain, Events, Options, Class.Thenable],

	options: {
		/*
		onStart: nil,
		onCancel: nil,
		onComplete: nil,
		*/
		fps: 60,
		unit: false,
		duration: 500,
		frames: null,
		frameSkip: true,
		link: 'ignore'
	},

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

	getTransition: function(){
		return function(p){
			return -(Math.cos(Math.PI * p) - 1) / 2;
		};
	},

	step: function(now){
		if (this.options.frameSkip){
			var diff = (this.time != null) ? (now - this.time) : 0, frames = diff / this.frameInterval;
			this.time = now;
			this.frame += frames;
		} else {
			this.frame++;
		}

		if (this.frame < this.frames){
			var delta = this.transition(this.frame / this.frames);
			this.set(this.compute(this.from, this.to, delta));
		} else {
			this.frame = this.frames;
			this.set(this.compute(this.from, this.to, 1));
			this.stop();
		}
	},

	set: function(now){
		return now;
	},

	compute: function(from, to, delta){
		return Fx.compute(from, to, delta);
	},

	check: function(){
		if (!this.isRunning()) return true;
		switch (this.options.link){
			case 'cancel': this.cancel(); return true;
			case 'chain': this.chain(this.caller.pass(arguments, this)); return false;
		}
		return false;
	},

	start: function(from, to){
		if (!this.check(from, to)) return this;
		this.from = from;
		this.to = to;
		this.frame = (this.options.frameSkip) ? 0 : -1;
		this.time = null;
		this.transition = this.getTransition();
		var frames = this.options.frames, fps = this.options.fps, duration = this.options.duration;
		this.duration = Fx.Durations[duration] || duration.toInt();
		this.frameInterval = 1000 / fps;
		this.frames = frames || Math.round(this.duration / this.frameInterval);
		if (this.getThenableState() !== 'pending'){
			this.resetThenable(this.subject);
		}
		this.fireEvent('start', this.subject);
		pushInstance.call(this, fps);
		return this;
	},

	stop: function(){
		if (this.isRunning()){
			this.time = null;
			pullInstance.call(this, this.options.fps);
			if (this.frames == this.frame){
				this.fireEvent('complete', this.subject);
				if (!this.callChain()) this.fireEvent('chainComplete', this.subject);
			} else {
				this.fireEvent('stop', this.subject);
			}
			this.resolve(this.subject === this ? null : this.subject);
		}
		return this;
	},

	cancel: function(){
		if (this.isRunning()){
			this.time = null;
			pullInstance.call(this, this.options.fps);
			this.frame = this.frames;
			this.fireEvent('cancel', this.subject).clearChain();
			this.reject(this.subject);
		}
		return this;
	},

	pause: function(){
		if (this.isRunning()){
			this.time = null;
			pullInstance.call(this, this.options.fps);
		}
		return this;
	},

	resume: function(){
		if (this.isPaused()) pushInstance.call(this, this.options.fps);
		return this;
	},

	isRunning: function(){
		var list = instances[this.options.fps];
		return list && list.contains(this);
	},

	isPaused: function(){
		return (this.frame < this.frames) && !this.isRunning();
	}

});

Fx.compute = function(from, to, delta){
	return (to - from) * delta + from;
};

Fx.Durations = {'short': 250, 'normal': 500, 'long': 1000};

// global timers

var instances = {}, timers = {};

var loop = function(){
	var now = Date.now();
	for (var i = this.length; i--;){
		var instance = this[i];
		if (instance) instance.step(now);
	}
};

var pushInstance = function(fps){
	var list = instances[fps] || (instances[fps] = []);
	list.push(this);
	if (!timers[fps]) timers[fps] = loop.periodical(Math.round(1000 / fps), list);
};

var pullInstance = function(fps){
	var list = instances[fps];
	if (list){
		list.erase(this);
		if (!list.length && timers[fps]){
			delete instances[fps];
			timers[fps] = clearInterval(timers[fps]);
		}
	}
};

})();

/*
---

name: Fx.CSS

description: Contains the CSS animation logic. Used by Fx.Tween, Fx.Morph, Fx.Elements.

license: MIT-style license.

requires: [Fx, Element.Style]

provides: Fx.CSS

...
*/

Fx.CSS = new Class({

	Extends: Fx,

	//prepares the base from/to object

	prepare: function(element, property, values){
		values = Array.convert(values);
		var from = values[0], to = values[1];
		if (to == null){
			to = from;
			from = element.getStyle(property);
			var unit = this.options.unit;
			// adapted from: https://github.com/ryanmorr/fx/blob/master/fx.js#L299
			if (unit && from && typeof from == 'string' && from.slice(-unit.length) != unit && parseFloat(from) != 0){
				element.setStyle(property, to + unit);
				var value = element.getComputedStyle(property);
				// IE and Opera support pixelLeft or pixelWidth
				if (!(/px$/.test(value))){
					value = element.style[('pixel-' + property).camelCase()];
					if (value == null){
						// adapted from Dean Edwards' http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
						var left = element.style.left;
						element.style.left = to + unit;
						value = element.style.pixelLeft;
						element.style.left = left;
					}
				}
				from = (to || 1) / (parseFloat(value) || 1) * (parseFloat(from) || 0);
				element.setStyle(property, from + unit);
			}
		}
		return {from: this.parse(from), to: this.parse(to)};
	},

	//parses a value into an array

	parse: function(value){
		value = Function.convert(value)();
		value = (typeof value == 'string') ? value.split(' ') : Array.convert(value);
		return value.map(function(val){
			val = String(val);
			var found = false;
			Object.each(Fx.CSS.Parsers, function(parser){
				if (found) return;
				var parsed = parser.parse(val);
				if (parsed || parsed === 0) found = {value: parsed, parser: parser};
			});
			found = found || {value: val, parser: Fx.CSS.Parsers.String};
			return found;
		});
	},

	//computes by a from and to prepared objects, using their parsers.

	compute: function(from, to, delta){
		var computed = [];
		(Math.min(from.length, to.length)).times(function(i){
			computed.push({value: from[i].parser.compute(from[i].value, to[i].value, delta), parser: from[i].parser});
		});
		computed.$family = Function.convert('fx:css:value');
		return computed;
	},

	//serves the value as settable

	serve: function(value, unit){
		if (typeOf(value) != 'fx:css:value') value = this.parse(value);
		var returned = [];
		value.each(function(bit){
			returned = returned.concat(bit.parser.serve(bit.value, unit));
		});
		return returned;
	},

	//renders the change to an element

	render: function(element, property, value, unit){
		element.setStyle(property, this.serve(value, unit));
	},

	//searches inside the page css to find the values for a selector

	search: function(selector){
		if (Fx.CSS.Cache[selector]) return Fx.CSS.Cache[selector];
		var to = {}, selectorTest = new RegExp('^' + selector.escapeRegExp() + '$');

		var searchStyles = function(rules){
			Array.each(rules, function(rule){
				if (rule.media){
					searchStyles(rule.rules || rule.cssRules);
					return;
				}
				if (!rule.style) return;
				var selectorText = (rule.selectorText) ? rule.selectorText.replace(/^\w+/, function(m){
					return m.toLowerCase();
				}) : null;
				if (!selectorText || !selectorTest.test(selectorText)) return;
				Object.each(Element.Styles, function(value, style){
					if (!rule.style[style] || Element.ShortStyles[style]) return;
					value = String(rule.style[style]);
					to[style] = ((/^rgb/).test(value)) ? value.rgbToHex() : value;
				});
			});
		};

		Array.each(document.styleSheets, function(sheet){
			var href = sheet.href;
			if (href && href.indexOf('://') > -1 && href.indexOf(document.domain) == -1) return;
			var rules = sheet.rules || sheet.cssRules;
			searchStyles(rules);
		});
		return Fx.CSS.Cache[selector] = to;
	}

});

Fx.CSS.Cache = {};

Fx.CSS.Parsers = {

	Color: {
		parse: function(value){
			if (value.match(/^#[0-9a-f]{3,6}$/i)) return value.hexToRgb(true);
			return ((value = value.match(/(\d+),\s*(\d+),\s*(\d+)/))) ? [value[1], value[2], value[3]] : false;
		},
		compute: function(from, to, delta){
			return from.map(function(value, i){
				return Math.round(Fx.compute(from[i], to[i], delta));
			});
		},
		serve: function(value){
			return value.map(Number);
		}
	},

	Number: {
		parse: parseFloat,
		compute: Fx.compute,
		serve: function(value, unit){
			return (unit) ? value + unit : value;
		}
	},

	String: {
		parse: Function.convert(false),
		compute: function(zero, one){
			return one;
		},
		serve: function(zero){
			return zero;
		}
	}

};



/*
---

name: Fx.Morph

description: Formerly Fx.Styles, effect to transition any number of CSS properties for an element using an object of rules, or CSS based selector rules.

license: MIT-style license.

requires: Fx.CSS

provides: Fx.Morph

...
*/

Fx.Morph = new Class({

	Extends: Fx.CSS,

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

	set: function(now){
		if (typeof now == 'string') now = this.search(now);
		for (var p in now) this.render(this.element, p, now[p], this.options.unit);
		return this;
	},

	compute: function(from, to, delta){
		var now = {};
		for (var p in from) now[p] = this.parent(from[p], to[p], delta);
		return now;
	},

	start: function(properties){
		if (!this.check(properties)) return this;
		if (typeof properties == 'string') properties = this.search(properties);
		var from = {}, to = {};
		for (var p in properties){
			var parsed = this.prepare(this.element, p, properties[p]);
			from[p] = parsed.from;
			to[p] = parsed.to;
		}
		return this.parent(from, to);
	}

});

Element.Properties.morph = {

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

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

};

Element.implement({

	morph: function(props){
		this.get('morph').start(props);
		return this;
	}

});

/*
---

name: Fx.Transitions

description: Contains a set of advanced transitions to be used with any of the Fx Classes.

license: MIT-style license.

credits:
  - Easing Equations by Robert Penner, <http://www.robertpenner.com/easing/>, modified and optimized to be used with MooTools.

requires: Fx

provides: Fx.Transitions

...
*/

Fx.implement({

	getTransition: function(){
		var trans = this.options.transition || Fx.Transitions.Sine.easeInOut;
		if (typeof trans == 'string'){
			var data = trans.split(':');
			trans = Fx.Transitions;
			trans = trans[data[0]] || trans[data[0].capitalize()];
			if (data[1]) trans = trans['ease' + data[1].capitalize() + (data[2] ? data[2].capitalize() : '')];
		}
		return trans;
	}

});

Fx.Transition = function(transition, params){
	params = Array.convert(params);
	var easeIn = function(pos){
		return transition(pos, params);
	};
	return Object.append(easeIn, {
		easeIn: easeIn,
		easeOut: function(pos){
			return 1 - transition(1 - pos, params);
		},
		easeInOut: function(pos){
			return (pos <= 0.5 ? transition(2 * pos, params) : (2 - transition(2 * (1 - pos), params))) / 2;
		}
	});
};

Fx.Transitions = {

	linear: function(zero){
		return zero;
	}

};



Fx.Transitions.extend = function(transitions){
	for (var transition in transitions) Fx.Transitions[transition] = new Fx.Transition(transitions[transition]);
};

Fx.Transitions.extend({

	Pow: function(p, x){
		return Math.pow(p, x && x[0] || 6);
	},

	Expo: function(p){
		return Math.pow(2, 8 * (p - 1));
	},

	Circ: function(p){
		return 1 - Math.sin(Math.acos(p));
	},

	Sine: function(p){
		return 1 - Math.cos(p * Math.PI / 2);
	},

	Back: function(p, x){
		x = x && x[0] || 1.618;
		return Math.pow(p, 2) * ((x + 1) * p - x);
	},

	Bounce: function(p){
		var value;
		for (var a = 0, b = 1; 1; a += b, b /= 2){
			if (p >= (7 - 4 * a) / 11){
				value = b * b - Math.pow((11 - 6 * a - 11 * p) / 4, 2);
				break;
			}
		}
		return value;
	},

	Elastic: function(p, x){
		return Math.pow(2, 10 * --p) * Math.cos(20 * p * Math.PI * (x && x[0] || 1) / 3);
	}

});

['Quad', 'Cubic', 'Quart', 'Quint'].each(function(transition, i){
	Fx.Transitions[transition] = new Fx.Transition(function(p){
		return Math.pow(p, i + 2);
	});
});

/*
---

name: Fx.Tween

description: Formerly Fx.Style, effect to transition any CSS property for an element.

license: MIT-style license.

requires: Fx.CSS

provides: [Fx.Tween, Element.fade, Element.highlight]

...
*/

Fx.Tween = new Class({

	Extends: Fx.CSS,

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

	set: function(property, now){
		if (arguments.length == 1){
			now = property;
			property = this.property || this.options.property;
		}
		this.render(this.element, property, now, this.options.unit);
		return this;
	},

	start: function(property, from, to){
		if (!this.check(property, from, to)) return this;
		var args = Array.flatten(arguments);
		this.property = this.options.property || args.shift();
		var parsed = this.prepare(this.element, this.property, args);
		return this.parent(parsed.from, parsed.to);
	}

});

Element.Properties.tween = {

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

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

};

Element.implement({

	tween: function(property, from, to){
		this.get('tween').start(property, from, to);
		return this;
	},

	fade: function(){
		var fade = this.get('tween'), method, args = ['opacity'].append(arguments), toggle;
		if (args[1] == null) args[1] = 'toggle';
		switch (args[1]){
			case 'in': method = 'start'; args[1] = 1; break;
			case 'out': method = 'start'; args[1] = 0; break;
			case 'show': method = 'set'; args[1] = 1; break;
			case 'hide': method = 'set'; args[1] = 0; break;
			case 'toggle':
				var flag = this.retrieve('fade:flag', this.getStyle('opacity') == 1);
				method = 'start';
				args[1] = flag ? 0 : 1;
				this.store('fade:flag', !flag);
				toggle = true;
				break;
			default: method = 'start';
		}
		if (!toggle) this.eliminate('fade:flag');
		fade[method].apply(fade, args);
		var to = args[args.length - 1];

		if (method == 'set'){
			this.setStyle('visibility', to == 0 ? 'hidden' : 'visible');
		} else if (to != 0){
			if (fade.$chain.length){
				fade.chain(function(){
					this.element.setStyle('visibility', 'visible');
					this.callChain();
				});
			} else {
				this.setStyle('visibility', 'visible');
			}
		} else {
			fade.chain(function(){
				if (this.element.getStyle('opacity')) return;
				this.element.setStyle('visibility', 'hidden');
				this.callChain();
			});
		}

		return this;
	},

	highlight: function(start, end){
		if (!end){
			end = this.retrieve('highlight:original', this.getStyle('background-color'));
			end = (end == 'transparent') ? '#fff' : end;
		}
		var tween = this.get('tween');
		tween.start('background-color', start || '#ffff88', end).chain(function(){
			this.setStyle('background-color', this.retrieve('highlight:original'));
			tween.callChain();
		}.bind(this));
		return this;
	}

});

/*
---

name: Request

description: Powerful all purpose Request Class. Uses XMLHTTPRequest.

license: MIT-style license.

requires: [Object, Element, Chain, Events, Options, Class.Thenable, Browser]

provides: Request

...
*/

(function(){

var empty = function(){},
	progressSupport = ('onprogress' in new Browser.Request);

var Request = this.Request = new Class({

	Implements: [Chain, Events, Options, Class.Thenable],

	options: {/*
		onRequest: function(){},
		onLoadstart: function(event, xhr){},
		onProgress: function(event, xhr){},
		onComplete: function(){},
		onCancel: function(){},
		onSuccess: function(responseText, responseXML){},
		onFailure: function(xhr){},
		onException: function(headerName, value){},
		onTimeout: function(){},
		user: '',
		password: '',
		withCredentials: false,*/
		url: '',
		data: '',
		headers: {
			'X-Requested-With': 'XMLHttpRequest',
			'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
		},
		async: true,
		format: false,
		method: 'post',
		link: 'ignore',
		isSuccess: null,
		emulation: true,
		urlEncoded: true,
		encoding: 'utf-8',
		evalScripts: false,
		evalResponse: false,
		timeout: 0,
		noCache: false
	},

	initialize: function(options){
		this.xhr = new Browser.Request();
		this.setOptions(options);
		this.headers = this.options.headers;
	},

	onStateChange: function(){
		var xhr = this.xhr;
		if (xhr.readyState != 4 || !this.running) return;
		this.running = false;
		this.status = 0;
		Function.attempt(function(){
			var status = xhr.status;
			this.status = (status == 1223) ? 204 : status;
		}.bind(this));
		xhr.onreadystatechange = empty;
		if (progressSupport) xhr.onprogress = xhr.onloadstart = empty;
		if (this.timer){
			clearTimeout(this.timer);
			delete this.timer;
		}

		this.response = {text: this.xhr.responseText || '', xml: this.xhr.responseXML};
		if (this.options.isSuccess.call(this, this.status))
			this.success(this.response.text, this.response.xml);
		else
			this.failure();
	},

	isSuccess: function(){
		var status = this.status;
		return (status >= 200 && status < 300);
	},

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

	processScripts: function(text){
		if (this.options.evalResponse || (/(ecma|java)script/).test(this.getHeader('Content-type'))) return Browser.exec(text);
		return text.stripScripts(this.options.evalScripts);
	},

	success: function(text, xml){
		this.onSuccess(this.processScripts(text), xml);
		this.resolve({text: text, xml: xml});
	},

	onSuccess: function(){
		this.fireEvent('complete', arguments).fireEvent('success', arguments).callChain();
	},

	failure: function(){
		this.onFailure();
		this.reject({reason: 'failure', xhr: this.xhr});
	},

	onFailure: function(){
		this.fireEvent('complete').fireEvent('failure', this.xhr);
	},

	loadstart: function(event){
		this.fireEvent('loadstart', [event, this.xhr]);
	},

	progress: function(event){
		this.fireEvent('progress', [event, this.xhr]);
	},

	timeout: function(){
		this.fireEvent('timeout', this.xhr);
		this.reject({reason: 'timeout', xhr: this.xhr});
	},

	setHeader: function(name, value){
		this.headers[name] = value;
		return this;
	},

	getHeader: function(name){
		return Function.attempt(function(){
			return this.xhr.getResponseHeader(name);
		}.bind(this));
	},

	check: function(){
		if (!this.running) return true;
		switch (this.options.link){
			case 'cancel': this.cancel(); return true;
			case 'chain': this.chain(this.caller.pass(arguments, this)); return false;
		}
		return false;
	},

	send: function(options){
		if (!this.check(options)) return this;

		this.options.isSuccess = this.options.isSuccess || this.isSuccess;
		this.running = true;

		var type = typeOf(options);
		if (type == 'string' || type == 'element') options = {data: options};

		var old = this.options;
		options = Object.append({data: old.data, url: old.url, method: old.method}, options);
		var data = options.data, url = String(options.url), method = options.method.toLowerCase();

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

		if (this.options.format){
			var format = 'format=' + this.options.format;
			data = (data) ? format + '&' + data : format;
		}

		if (this.options.emulation && !['get', 'post'].contains(method)){
			var _method = '_method=' + method;
			data = (data) ? _method + '&' + data : _method;
			method = 'post';
		}

		if (this.options.urlEncoded && ['post', 'put'].contains(method)){
			var encoding = (this.options.encoding) ? '; charset=' + this.options.encoding : '';
			this.headers['Content-type'] = 'application/x-www-form-urlencoded' + encoding;
		}

		if (!url) url = document.location.pathname;

		var trimPosition = url.lastIndexOf('/');
		if (trimPosition > -1 && (trimPosition = url.indexOf('#')) > -1) url = url.substr(0, trimPosition);

		if (this.options.noCache)
			url += (url.indexOf('?') > -1 ? '&' : '?') + String.uniqueID();

		if (data && (method == 'get' || method == 'delete')){
			url += (url.indexOf('?') > -1 ? '&' : '?') + data;
			data = null;
		}

		var xhr = this.xhr;
		if (progressSupport){
			xhr.onloadstart = this.loadstart.bind(this);
			xhr.onprogress = this.progress.bind(this);
		}

		xhr.open(method.toUpperCase(), url, this.options.async, this.options.user, this.options.password);
		if ((this.options.withCredentials) && 'withCredentials' in xhr) xhr.withCredentials = true;

		xhr.onreadystatechange = this.onStateChange.bind(this);

		Object.each(this.headers, function(value, key){
			try {
				xhr.setRequestHeader(key, value);
			} catch (e){
				this.fireEvent('exception', [key, value]);
				this.reject({reason: 'exception', xhr: xhr, exception: e});
			}
		}, this);

		if (this.getThenableState() !== 'pending'){
			this.resetThenable({reason: 'send'});
		}
		this.fireEvent('request');
		xhr.send(data);
		if (!this.options.async) this.onStateChange();
		else if (this.options.timeout) this.timer = this.timeout.delay(this.options.timeout, this);
		return this;
	},

	cancel: function(){
		if (!this.running) return this;
		this.running = false;
		var xhr = this.xhr;
		xhr.abort();
		if (this.timer){
			clearTimeout(this.timer);
			delete this.timer;
		}
		xhr.onreadystatechange = empty;
		if (progressSupport) xhr.onprogress = xhr.onloadstart = empty;
		this.xhr = new Browser.Request();
		this.fireEvent('cancel');
		this.reject({reason: 'cancel', xhr: xhr});
		return this;
	}

});

var methods = {};
['get', 'post', 'put', 'delete', 'patch', 'head', 'GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD'].each(function(method){
	methods[method] = function(data){
		var object = {
			method: method
		};
		if (data != null) object.data = data;
		return this.send(object);
	};
});

Request.implement(methods);

Element.Properties.send = {

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

	get: function(){
		var send = this.retrieve('send');
		if (!send){
			send = new Request({
				data: this, link: 'cancel', method: this.get('method') || 'post', url: this.get('action')
			});
			this.store('send', send);
		}
		return send;
	}

};

Element.implement({

	send: function(url){
		var sender = this.get('send');
		sender.send({data: this, url: url || sender.options.url});
		return this;
	}

});

})();

/*
---

name: Request.HTML

description: Extends the basic Request Class with additional methods for interacting with HTML responses.

license: MIT-style license.

requires: [Element, Request]

provides: Request.HTML

...
*/

Request.HTML = new Class({

	Extends: Request,

	options: {
		update: false,
		append: false,
		evalScripts: true,
		filter: false,
		headers: {
			Accept: 'text/html, application/xml, text/xml, */*'
		}
	},

	success: function(text){
		var options = this.options, response = this.response;

		response.html = text.stripScripts(function(script){
			response.javascript = script;
		});

		var match = response.html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
		if (match) response.html = match[1];
		var temp = new Element('div').set('html', response.html);

		response.tree = temp.childNodes;
		response.elements = temp.getElements(options.filter || '*');

		if (options.filter) response.tree = response.elements;
		if (options.update){
			var update = document.id(options.update).empty();
			if (options.filter) update.adopt(response.elements);
			else update.set('html', response.html);
		} else if (options.append){
			var append = document.id(options.append);
			if (options.filter) response.elements.reverse().inject(append);
			else append.adopt(temp.getChildren());
		}
		if (options.evalScripts) Browser.exec(response.javascript);

		this.onSuccess(response.tree, response.elements, response.html, response.javascript);
		this.resolve({tree: response.tree, elements: response.elements, html: response.html, javascript: response.javascript});
	}

});

Element.Properties.load = {

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

	get: function(){
		var load = this.retrieve('load');
		if (!load){
			load = new Request.HTML({data: this, link: 'cancel', update: this, method: 'get'});
			this.store('load', load);
		}
		return load;
	}

};

Element.implement({

	load: function(){
		this.get('load').send(Array.link(arguments, {data: Type.isObject, url: Type.isString}));
		return this;
	}

});

/*
---

name: JSON

description: JSON encoder and decoder.

license: MIT-style license.

SeeAlso: <http://www.json.org/>

requires: [Array, String, Number, Function]

provides: JSON

...
*/

if (typeof JSON == 'undefined') this.JSON = {};



(function(){

var special = {'\b': '\\b', '\t': '\\t', '\n': '\\n', '\f': '\\f', '\r': '\\r', '"' : '\\"', '\\': '\\\\'};

var escape = function(chr){
	return special[chr] || '\\u' + ('0000' + chr.charCodeAt(0).toString(16)).slice(-4);
};

JSON.validate = function(string){
	string = string.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@').
					replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').
					replace(/(?:^|:|,)(?:\s*\[)+/g, '');

	return (/^[\],:{}\s]*$/).test(string);
};

JSON.encode = JSON.stringify ? function(obj){
	return JSON.stringify(obj);
} : function(obj){
	if (obj && obj.toJSON) obj = obj.toJSON();

	switch (typeOf(obj)){
		case 'string':
			return '"' + obj.replace(/[\x00-\x1f\\"]/g, escape) + '"';
		case 'array':
			return '[' + obj.map(JSON.encode).clean() + ']';
		case 'object': case 'hash':
			var string = [];
			Object.each(obj, function(value, key){
				var json = JSON.encode(value);
				if (json) string.push(JSON.encode(key) + ':' + json);
			});
			return '{' + string + '}';
		case 'number': case 'boolean': return '' + obj;
		case 'null': return 'null';
	}

	return null;
};

JSON.secure = true;


JSON.decode = function(string, secure){
	if (!string || typeOf(string) != 'string') return null;

	if (secure == null) secure = JSON.secure;
	if (secure){
		if (JSON.parse) return JSON.parse(string);
		if (!JSON.validate(string)) throw new Error('JSON could not decode the input; security is enabled and the value is not secure.');
	}

	return eval('(' + string + ')');
};

})();

/*
---

name: Request.JSON

description: Extends the basic Request Class with additional methods for sending and receiving JSON data.

license: MIT-style license.

requires: [Request, JSON]

provides: Request.JSON

...
*/

Request.JSON = new Class({

	Extends: Request,

	options: {
		/*onError: function(text, error){},*/
		secure: true
	},

	initialize: function(options){
		this.parent(options);
		Object.append(this.headers, {
			'Accept': 'application/json',
			'X-Request': 'JSON'
		});
	},

	success: function(text){
		var json;
		try {
			json = this.response.json = JSON.decode(text, this.options.secure);
		} catch (error){
			this.fireEvent('error', [text, error]);
			return;
		}
		if (json == null){
			this.failure();
		} else {
			this.onSuccess(json, text);
			this.resolve({json: json, text: text});
		}
	}

});

/*
---

name: Cookie

description: Class for creating, reading, and deleting browser Cookies.

license: MIT-style license.

credits:
  - Based on the functions by Peter-Paul Koch (http://quirksmode.org).

requires: [Options, Browser]

provides: Cookie

...
*/

var Cookie = new Class({

	Implements: Options,

	options: {
		path: '/',
		domain: false,
		duration: false,
		secure: false,
		document: document,
		encode: true,
		httpOnly: false
	},

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

	write: function(value){
		if (this.options.encode) value = encodeURIComponent(value);
		if (this.options.domain) value += '; domain=' + this.options.domain;
		if (this.options.path) value += '; path=' + this.options.path;
		if (this.options.duration){
			var date = new Date();
			date.setTime(date.getTime() + this.options.duration * 24 * 60 * 60 * 1000);
			value += '; expires=' + date.toGMTString();
		}
		if (this.options.secure) value += '; secure';
		if (this.options.httpOnly) value += '; HttpOnly';
		this.options.document.cookie = this.key + '=' + value;
		return this;
	},

	read: function(){
		var value = this.options.document.cookie.match('(?:^|;)\\s*' + this.key.escapeRegExp() + '=([^;]*)');
		return (value) ? decodeURIComponent(value[1]) : null;
	},

	dispose: function(){
		new Cookie(this.key, Object.merge({}, this.options, {duration: -1})).write('');
		return this;
	}

});

Cookie.write = function(key, value, options){
	return new Cookie(key, options).write(value);
};

Cookie.read = function(key){
	return new Cookie(key).read();
};

Cookie.dispose = function(key, options){
	return new Cookie(key, options).dispose();
};

/*
---

name: DOMReady

description: Contains the custom event domready.

license: MIT-style license.

requires: [Browser, Element, Element.Event]

provides: [DOMReady, DomReady]

...
*/

(function(window, document){

var ready,
	loaded,
	checks = [],
	shouldPoll,
	timer,
	testElement = document.createElement('div');

var domready = function(){
	clearTimeout(timer);
	if (!ready){
		Browser.loaded = ready = true;
		document.removeListener('DOMContentLoaded', domready).removeListener('readystatechange', check);
		document.fireEvent('domready');
		window.fireEvent('domready');
	}
	// cleanup scope vars
	document = window = testElement = null;
};

var check = function(){
	for (var i = checks.length; i--;) if (checks[i]()){
		domready();
		return true;
	}
	return false;
};

var poll = function(){
	clearTimeout(timer);
	if (!check()) timer = setTimeout(poll, 10);
};

document.addListener('DOMContentLoaded', domready);

/*<ltIE8>*/
// doScroll technique by Diego Perini http://javascript.nwbox.com/IEContentLoaded/
// testElement.doScroll() throws when the DOM is not ready, only in the top window
var doScrollWorks = function(){
	try {
		testElement.doScroll();
		return true;
	} catch (e){}
	return false;
};
// If doScroll works already, it can't be used to determine domready
//   e.g. in an iframe
if (testElement.doScroll && !doScrollWorks()){
	checks.push(doScrollWorks);
	shouldPoll = true;
}
/*</ltIE8>*/

if (document.readyState) checks.push(function(){
	var state = document.readyState;
	return (state == 'loaded' || state == 'complete');
});

if ('onreadystatechange' in document) document.addListener('readystatechange', check);
else shouldPoll = true;

if (shouldPoll) poll();

Element.Events.domready = {
	onAdd: function(fn){
		if (ready) fn.call(this);
	}
};

// Make sure that domready fires before load
Element.Events.load = {
	base: 'load',
	onAdd: function(fn){
		if (loaded && this == window) fn.call(this);
	},
	condition: function(){
		if (this == window){
			domready();
			delete Element.Events.load;
		}
		return true;
	}
};

// This is based on the custom load event
window.addEvent('load', function(){
	loaded = true;
});

})(window, document);


/* MooTools: the javascript framework. license: MIT-style license. copyright: Copyright (c) 2006-2018 [Valerio Proietti](https://mootools.net/).*/ 
/*!
Web Build: https://mootools.net/more/builder/000000c0000000b00000000000000080
*/
/*
---

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.6.0',
	build: '45b71db70f879781a7e0b0d3fb3bb1307c2521eb'
};

/*
---

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.convert(binds).concat(this.prototype.Binds || []);
};

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

/*
---

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: 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: Class.Singleton.js

name: Class.Singleton

description: Always provides a single instance of a class

license: MIT-style license.

authors:
  - Hristo Chakarov

requires:
  - Core/Class

provides: [Class.Singleton]

...
*/

Class.Singleton = new Class({

	initialize : function(descriptor){
		// here we keep reference of the single instance
		var singleton;
		// create a regular Class
		var constructor = new Class(descriptor);
		// We return another constructor, because we need to make sure that we
		// always return the same one and only instance.
		return function(){
			if (singleton){
				return singleton;
			}
			// Obviously we instantiate that class for the first time.
			// Create brand new object & extend it with the prototype of the
			// original `constructor`.
			singleton = Object.append({}, constructor.prototype);
			singleton.constructor = constructor;
			// We also need to call the constructor as a function, passing the
			// arguments object.
			var returnValue = constructor.apply(singleton, arguments);
			// In case the `constructor` returns something other than `this` -
			// return that value; otherwise return the `singleton`.
			singleton = typeof returnValue == 'object' ? returnValue : singleton;
			return singleton;
		};
	}

});

/*
---

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, 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);
});

})();

/*
---

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]
...

*/
(function(){

var Drag = this.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,
		unDraggableTags: ['button', 'input', 'a', 'textarea', 'select', 'option'],
		preventDefault: false,
		stopPropagation: false,
		compensateScroll: 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.offsetParent = (function(el){
			var offsetParent = el.getOffsetParent();
			var isBody = !offsetParent || (/^(?:body|html)$/i).test(offsetParent.tagName);
			return isBody ? window : document.id(offsetParent);
		})(this.element);
		this.selection = 'selectstart' in document ? 'selectstart' : 'mousedown';

		this.compensateScroll = {start: {}, diff: {}, last: {}};

		if ('ondragstart' in document && !('FileReader' in window) && !Drag.ondragstartFixed){
			document.ondragstart = Function.convert(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.convert(false),
			scrollListener: this.scrollListener.bind(this)
		};
		this.attach();
	},

	attach: function(){
		this.handles.addEvent('mousedown', this.bound.start);
		this.handles.addEvent('touchstart', this.bound.start);
		if (this.options.compensateScroll) this.offsetParent.addEvent('scroll', this.bound.scrollListener);
		return this;
	},

	detach: function(){
		this.handles.removeEvent('mousedown', this.bound.start);
		this.handles.removeEvent('touchstart', this.bound.start);
		if (this.options.compensateScroll) this.offsetParent.removeEvent('scroll', this.bound.scrollListener);
		return this;
	},

	scrollListener: function(){

		if (!this.mouse.start) return;
		var newScrollValue = this.offsetParent.getScroll();

		if (this.element.getStyle('position') == 'absolute'){
			var scrollDiff = this.sumValues(newScrollValue, this.compensateScroll.last, -1);
			this.mouse.now = this.sumValues(this.mouse.now, scrollDiff, 1);
		} else {
			this.compensateScroll.diff = this.sumValues(newScrollValue, this.compensateScroll.start, -1);
		}
		if (this.offsetParent != window) this.compensateScroll.diff = this.sumValues(this.compensateScroll.start, newScrollValue, -1);
		this.compensateScroll.last = newScrollValue;
		this.render(this.options);
	},

	sumValues: function(alpha, beta, op){
		var sum = {}, options = this.options;
		for (var z in options.modifiers){
			if (!options.modifiers[z]) continue;
			sum[z] = alpha[z] + beta[z] * op;
		}
		return sum;
	},

	start: function(event){
		if (this.options.unDraggableTags.contains(event.target.get('tag'))) return;

		var options = this.options;

		if (event.rightClick) return;

		if (options.preventDefault) event.preventDefault();
		if (options.stopPropagation) event.stopPropagation();
		this.compensateScroll.start = this.compensateScroll.last = this.offsetParent.getScroll();
		this.compensateScroll.diff = {x: 0, y: 0};
		this.mouse.start = event.page;
		this.fireEvent('beforeStart', this.element);

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

		var z, coordinates, offsetParent = this.offsetParent == window ? null : this.offsetParent;
		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(offsetParent);
				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,
			touchmove: this.bound.check,
			touchend: 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,
				touchmove: this.bound.drag,
				touchend: 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 = this.sumValues(event.page, this.compensateScroll.diff, -1);

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

	render: function(options){
		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];
		}
	},

	cancel: function(event){
		this.document.removeEvents({
			mousemove: this.bound.check,
			mouseup: this.bound.cancel,
			touchmove: this.bound.check,
			touchend: 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,
			touchmove: this.bound.drag,
			touchend: this.bound.stop
		};
		events[this.selection] = this.bound.eventStop;
		this.document.removeEvents(events);
		this.mouse.start = null;
		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.setContainer(this.options.container);

		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;
	},

	setContainer: function(container){
		this.container = document.id(container);
		if (this.container && typeOf(this.container) != 'element'){
			this.container = document.id(this.container.getDocument().body);
		}
	},

	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 = {},
			offsetScroll = offsetParent.getScroll();

		['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 + offsetScroll.x,
			top = 0 + offsetScroll.y,
			right = containerCoordinates.right - containerBorder.right - width + offsetScroll.x,
			bottom = containerCoordinates.bottom - containerBorder.bottom - height + offsetScroll.y;

		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;
				if (!offsetParentPadding.left && left < 0) left = 0;
				top += offsetParent == document.body ? 0 : containerMargin.top + offsetParentPadding.top;
				if (!offsetParentPadding.top && top < 0) top = 0;
			}
		} 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: 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 (c) 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){
		

		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: Slider.js

name: Slider

description: Class for creating horizontal and vertical slider controls.

license: MIT-style license

authors:
  - Valerio Proietti

requires:
  - Core/Element.Dimensions
  - Core/Number
  - Class.Binds
  - Drag
  - Element.Measure

provides: [Slider]

...
*/
(function(){

var Slider = this.Slider = new Class({

	Implements: [Events, Options],

	Binds: ['clickedElement', 'draggedKnob', 'scrolledElement'],

	options: {/*
		onTick: function(intPosition){},
		onMove: function(){},
		onChange: function(intStep){},
		onComplete: function(strStep){},*/
		onTick: function(position){
			this.setKnobPosition(position);
		},
		initialStep: 0,
		snap: false,
		offset: 0,
		range: false,
		wheel: false,
		steps: 100,
		mode: 'horizontal'
	},

	initialize: function(element, knob, options){
		this.setOptions(options);
		options = this.options;
		this.element = document.id(element);
		knob = this.knob = document.id(knob);
		this.previousChange = this.previousEnd = this.step = options.initialStep ? options.initialStep : options.range ? options.range[0] : 0;

		var limit = {},
			modifiers = {x: false, y: false};

		switch (options.mode){
			case 'vertical':
				this.axis = 'y';
				this.property = 'top';
				this.offset = 'offsetHeight';
				break;
			case 'horizontal':
				this.axis = 'x';
				this.property = 'left';
				this.offset = 'offsetWidth';
		}

		this.setSliderDimensions();
		this.setRange(options.range, null, true);

		if (knob.getStyle('position') == 'static') knob.setStyle('position', 'relative');
		knob.setStyle(this.property, -options.offset);
		modifiers[this.axis] = this.property;
		limit[this.axis] = [-options.offset, this.full - options.offset];

		var dragOptions = {
			snap: 0,
			limit: limit,
			modifiers: modifiers,
			onDrag: this.draggedKnob,
			onStart: this.draggedKnob,
			onBeforeStart: (function(){
				this.isDragging = true;
			}).bind(this),
			onCancel: function(){
				this.isDragging = false;
			}.bind(this),
			onComplete: function(){
				this.isDragging = false;
				this.draggedKnob();
				this.end();
			}.bind(this)
		};
		if (options.snap) this.setSnap(dragOptions);

		this.drag = new Drag(knob, dragOptions);
		if (options.initialStep != null) this.set(options.initialStep, true);
		this.attach();
	},

	attach: function(){
		this.element.addEvent('mousedown', this.clickedElement);
		if (this.options.wheel) this.element.addEvent('mousewheel', this.scrolledElement);
		this.drag.attach();
		return this;
	},

	detach: function(){
		this.element.removeEvent('mousedown', this.clickedElement)
			.removeEvent('mousewheel', this.scrolledElement);
		this.drag.detach();
		return this;
	},

	autosize: function(){
		this.setSliderDimensions()
			.setKnobPosition(this.toPosition(this.step));
		this.drag.options.limit[this.axis] = [-this.options.offset, this.full - this.options.offset];
		if (this.options.snap) this.setSnap();
		return this;
	},

	setSnap: function(options){
		if (!options) options = this.drag.options;
		options.grid = Math.ceil(this.stepWidth);
		options.limit[this.axis][1] = this.element[this.offset];
		return this;
	},

	setKnobPosition: function(position){
		if (this.options.snap) position = this.toPosition(this.step);
		this.knob.setStyle(this.property, position);
		return this;
	},

	setSliderDimensions: function(){
		this.full = this.element.measure(function(){
			this.half = this.knob[this.offset] / 2;
			return this.element[this.offset] - this.knob[this.offset] + (this.options.offset * 2);
		}.bind(this));
		return this;
	},

	set: function(step, silently){
		if (!((this.range > 0) ^ (step < this.min))) step = this.min;
		if (!((this.range > 0) ^ (step > this.max))) step = this.max;

		this.step = (step).round(this.modulus.decimalLength);
		if (silently) this.checkStep().setKnobPosition(this.toPosition(this.step));
		else this.checkStep().fireEvent('tick', this.toPosition(this.step)).fireEvent('move').end();
		return this;
	},

	setRange: function(range, pos, silently){
		this.min = Array.pick([range[0], 0]);
		this.max = Array.pick([range[1], this.options.steps]);
		this.range = this.max - this.min;
		this.steps = this.options.steps || this.full;
		var stepSize = this.stepSize = Math.abs(this.range) / this.steps;
		this.stepWidth = this.stepSize * this.full / Math.abs(this.range);
		this.setModulus();

		if (range) this.set(Array.pick([pos, this.step]).limit(this.min,this.max), silently);
		return this;
	},

	setModulus: function(){
		var decimals = ((this.stepSize + '').split('.')[1] || []).length,
			modulus = 1 + '';
		while (decimals--) modulus += '0';
		this.modulus = {multiplier: (modulus).toInt(10), decimalLength: modulus.length - 1};
	},

	clickedElement: function(event){
		if (this.isDragging || event.target == this.knob) return;

		var dir = this.range < 0 ? -1 : 1,
			position = event.page[this.axis] - this.element.getPosition()[this.axis] - this.half;

		position = position.limit(-this.options.offset, this.full - this.options.offset);

		this.step = (this.min + dir * this.toStep(position)).round(this.modulus.decimalLength);

		this.checkStep()
			.fireEvent('tick', position)
			.fireEvent('move')
			.end();
	},

	scrolledElement: function(event){
		var mode = (this.options.mode == 'horizontal') ? (event.wheel < 0) : (event.wheel > 0);
		this.set(this.step + (mode ? -1 : 1) * this.stepSize);
		event.stop();
	},

	draggedKnob: function(){
		var dir = this.range < 0 ? -1 : 1,
			position = this.drag.value.now[this.axis];

		position = position.limit(-this.options.offset, this.full -this.options.offset);

		this.step = (this.min + dir * this.toStep(position)).round(this.modulus.decimalLength);
		this.checkStep();
		this.fireEvent('move');
	},

	checkStep: function(){
		var step = this.step;
		if (this.previousChange != step){
			this.previousChange = step;
			this.fireEvent('change', step);
		}
		return this;
	},

	end: function(){
		var step = this.step;
		if (this.previousEnd !== step){
			this.previousEnd = step;
			this.fireEvent('complete', step + '');
		}
		return this;
	},

	toStep: function(position){
		var step = (position + this.options.offset) * this.stepSize / this.full * this.steps;
		return this.options.steps ? (step - (step * this.modulus.multiplier) % (this.stepSize * this.modulus.multiplier) / this.modulus.multiplier).round(this.modulus.decimalLength) : step;
	},

	toPosition: function(step){
		return (this.full * Math.abs(this.min - step)) / (this.steps * this.stepSize) - this.options.offset || 0;
	}

});

})();


/*
---

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]

...
*/
(function(){

var Sortables = this.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: {},
		unDraggableTags: ['button', 'input', 'a', 'textarea', 'select', 'option']
	},

	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));
	},

	getDroppableCoordinates: function(element){
		var offsetParent = element.getOffsetParent();
		var position = element.getPosition(offsetParent);
		var scroll = {
			w: window.getScroll(),
			offsetParent: offsetParent.getScroll()
		};
		position.x += scroll.offsetParent.x;
		position.y += scroll.offsetParent.y;

		if (offsetParent.getStyle('position') == 'fixed'){
			position.x -= scroll.w.x;
			position.y -= scroll.w.y;
		}

		return position;
	},

	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(this.getDroppableCoordinates(this.element));
	},

	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 ||
			(!this.options.handle && this.options.unDraggableTags.contains(event.target.get('tag')))
		) return;

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

		this.drag = new Drag.Move(this.clone, Object.merge({
			
			droppables: this.getDroppables()
		}, this.options.dragOptions)).addEvents({
			onSnap: function(){
				event.stop();
				this.clone.setStyle('visibility', 'visible');
				this.element.setStyle('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.setStyle('opacity', this.opacity);
		var self = this;
		if (this.effect){
			var dim = this.element.getStyles('width', 'height'),
				clone = this.clone,
				pos = clone.computePosition(this.getDroppableCoordinates(clone));

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

			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();
			self.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;
	}

});

})();

/*
---

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.Pseudo]

...
*/

(function(){

var pseudos = {relay: false},
	copyFromEvents = ['once', 'throttle', 'pause'],
	count = copyFromEvents.length;

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

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

})();

/*
---

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, []),
		value = split.value;

	if (value != '+') keys.append(value.replace('++', function(){
		keys.push('+'); // shift++ and shift+++a
		return '';
	}).split('+'));
	else keys = ['+'];

	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': '+',
	'109': '-', // subtract
	'189': '-'  // dash
});

})();

/*
---

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,
		'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
	},

	conversions = {
		ms: 1,
		s: 1000,
		m: 6e4,
		h: 36e5
	},

	findUnits = /(\d*.?\d+)([msh]+)/;

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 || (contents ? '' : '\\w+');
	var regstr = contents ? '<' + tag + '(?!\\w)[^>]*>([\\s\\S]*?)<\/' + tag + '(?!\\w)>' : '<\/?' + tag + '\/?>|<' + tag + '[\\s|\/][^>]*>';
	return new RegExp(regstr, 'gi');
};

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;
	},

	ms: function(){
		// "Borrowed" from https://gist.github.com/1503944
		var units = findUnits.exec(this);
		if (units == null) return Number(this);
		return Number(units[1]) * conversions[units[2]];
	}

});

})();

/*
---

script: Element.Forms.js

name: Element.Forms

description: Extends the Element native object to include methods useful in managing inputs.

license: MIT-style license

authors:
  - Aaron Newton

requires:
  - Core/Element
  - String.Extras
  - MooTools.More

provides: [Element.Forms]

...
*/

Element.implement({

	tidy: function(){
		this.set('value', this.get('value').tidy());
	},

	getTextInRange: function(start, end){
		return this.get('value').substring(start, end);
	},

	getSelectedText: function(){
		if (this.setSelectionRange) return this.getTextInRange(this.getSelectionStart(), this.getSelectionEnd());
		return document.selection.createRange().text;
	},

	getSelectedRange: function(){
		if (this.selectionStart != null){
			return {
				start: this.selectionStart,
				end: this.selectionEnd
			};
		}

		var pos = {
			start: 0,
			end: 0
		};
		var range = this.getDocument().selection.createRange();
		if (!range || range.parentElement() != this) return pos;
		var duplicate = range.duplicate();

		if (this.type == 'text'){
			pos.start = 0 - duplicate.moveStart('character', -100000);
			pos.end = pos.start + range.text.length;
		} else {
			var value = this.get('value');
			var offset = value.length;
			duplicate.moveToElementText(this);
			duplicate.setEndPoint('StartToEnd', range);
			if (duplicate.text.length) offset -= value.match(/[\n\r]*$/)[0].length;
			pos.end = offset - duplicate.text.length;
			duplicate.setEndPoint('StartToStart', range);
			pos.start = offset - duplicate.text.length;
		}
		return pos;
	},

	getSelectionStart: function(){
		return this.getSelectedRange().start;
	},

	getSelectionEnd: function(){
		return this.getSelectedRange().end;
	},

	setCaretPosition: function(pos){
		if (pos == 'end') pos = this.get('value').length;
		this.selectRange(pos, pos);
		return this;
	},

	getCaretPosition: function(){
		return this.getSelectedRange().start;
	},

	selectRange: function(start, end){
		if (this.setSelectionRange){
			this.focus();
			this.setSelectionRange(start, end);
		} else {
			var value = this.get('value');
			var diff = value.substr(start, end - start).replace(/\r/g, '').length;
			start = value.substr(0, start).replace(/\r/g, '').length;
			var range = this.createTextRange();
			range.collapse(true);
			range.moveEnd('character', start + diff);
			range.moveStart('character', start);
			range.select();
		}
		return this;
	},

	insertAtCursor: function(value, select){
		var pos = this.getSelectedRange();
		var text = this.get('value');
		this.set('value', text.substring(0, pos.start) + value + text.substring(pos.end, text.length));
		if (select !== false) this.selectRange(pos.start, pos.start + value.length);
		else this.setCaretPosition(pos.start + value.length);
		return this;
	},

	insertAroundCursor: function(options, select){
		options = Object.append({
			before: '',
			defaultMiddle: '',
			after: ''
		}, options);

		var value = this.getSelectedText() || options.defaultMiddle;
		var pos = this.getSelectedRange();
		var text = this.get('value');

		if (pos.start == pos.end){
			this.set('value', text.substring(0, pos.start) + options.before + value + options.after + text.substring(pos.end, text.length));
			this.selectRange(pos.start + options.before.length, pos.end + options.before.length + value.length);
		} else {
			var current = text.substring(pos.start, pos.end);
			this.set('value', text.substring(0, pos.start) + options.before + current + options.after + text.substring(pos.end, text.length));
			var selStart = pos.start + options.before.length;
			if (select !== false) this.selectRange(selStart, selStart + current.length);
			else this.setCaretPosition(selStart + text.length);
		}
		return this;
	}

});

/*
---

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();
			if (!this.retrieve('pin:_pinned')){
				var currentPosition = {
					top: pinnedPosition.y - scroll.y,
					left: pinnedPosition.x - scroll.x,
					margin: '0px',
					padding: '0px'
				};

				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();

			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'));
	}

});



})();

/*
---

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};
		var parentScroll = {x: 0, y: 0};
		var offsetParent = element.measure(function(){
			return document.id(this.getOffsetParent());
		});

		if (!offsetParent || offsetParent == element.getDocument().body) return;

		parentScroll = offsetParent.getScroll();
		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: 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: Elements.From.js

name: Elements.From

description: Returns a collection of elements from a string of html.

license: MIT-style license

authors:
  - Aaron Newton

requires:
  - Core/String
  - Core/Element
  - MooTools.More

provides: [Elements.from, Elements.From]

...
*/

Elements.from = function(text, excludeScripts){
	if (excludeScripts || excludeScripts == null) text = text.stripScripts();

	var container, match = text.match(/^\s*(?:<!--.*?-->\s*)*<(t[dhr]|tbody|tfoot|thead)/i);

	if (match){
		container = new Element('table');
		var tag = match[1].toLowerCase();
		if (['td', 'th', 'tr'].contains(tag)){
			container = new Element('tbody').inject(container);
			if (tag != 'tr') container = new Element('tr').inject(container);
		}
	}

	return (container || new Element('div')).set('html', text).getChildren();
};

/*
---

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]

...
*/

(function(){

/**
 * decodeURIComponent doesn't do the correct thing with query parameter keys or
 * values. Specifically, it leaves '+' as '+' when it should be converting them
 * to spaces as that's the specification. When browsers submit HTML forms via
 * GET, the values are encoded using 'application/x-www-form-urlencoded'
 * which converts spaces to '+'.
 *
 * See: http://unixpapa.com/js/querystring.html for a description of the
 * problem.
 */
var decodeComponent = function(str){
	return decodeURIComponent(str.replace(/\+/g, ' '));
};

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 = decodeComponent(value);
			keys.each(function(key, i){
				if (decodeKeys) key = decodeComponent(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: 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);

		

		if (!current) current = locale;

		return locale;
	},

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

		if (locale){
			current = locale;

			this.fireEvent('change', locale);

			
		}

		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.convert(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.convert(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;
	}

});



})();

/*
---

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.convert(1),
		second: Function.convert(1000),
		minute: Function.convert(60000),
		hour: Function.convert(3600000),
		day: Function.convert(86400000),
		week: Function.convert(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;
	},

	

	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());

})();

/*
---

name: Locale.en-US.Form.Validator

description: Form Validator messages for English.

license: MIT-style license

authors:
  - Aaron Newton

requires:
  - Locale

provides: [Locale.en-US.Form.Validator]

...
*/

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

	required: 'This field is required.',
	length: 'Please enter {length} characters (you entered {elLength} characters)',
	minLength: 'Please enter at least {minLength} characters (you entered {length} characters).',
	maxLength: 'Please enter no more than {maxLength} characters (you entered {length} characters).',
	integer: 'Please enter an integer in this field. Numbers with decimals (e.g. 1.25) are not permitted.',
	numeric: 'Please enter only numeric values in this field (i.e. "1" or "1.1" or "-1" or "-1.1").',
	digits: 'Please use numbers and punctuation only in this field (for example, a phone number with dashes or dots is permitted).',
	alpha: 'Please use only letters (a-z) within this field. No spaces or other characters are allowed.',
	alphanum: 'Please use only letters (a-z) or numbers (0-9) in this field. No spaces or other characters are allowed.',
	dateSuchAs: 'Please enter a valid date such as {date}',
	dateInFormatMDY: 'Please enter a valid date such as MM/DD/YYYY (i.e. "12/31/1999")',
	email: 'Please enter a valid email address. For example "fred@domain.com".',
	url: 'Please enter a valid URL such as http://www.example.com.',
	currencyDollar: 'Please enter a valid $ amount. For example $100.00 .',
	oneRequired: 'Please enter something for at least one of these inputs.',
	errorPrefix: 'Error: ',
	warningPrefix: 'Warning: ',

	// Form.Validator.Extras
	noSpace: 'There can be no spaces in this input.',
	reqChkByNode: 'No items are selected.',
	requiredChk: 'This field is required.',
	reqChkByName: 'Please select a {label}.',
	match: 'This field needs to match the {matchName} field',
	startDate: 'the start date',
	endDate: 'the end date',
	currentDate: 'the current date',
	afterDate: 'The date should be the same or after {label}.',
	beforeDate: 'The date should be the same or before {label}.',
	startMonth: 'Please select a start month',
	sameMonth: 'These two dates must be in the same month - you must change one or the other.',
	creditcard: 'The credit card number entered is invalid. Please check the number and try again. {length} digits entered.'

});

/*
---

script: Form.Validator.js

name: Form.Validator

description: A css-class based form validation system.

license: MIT-style license

authors:
  - Aaron Newton

requires:
  - Core/Options
  - Core/Events
  - Core/Element.Delegation
  - Core/Slick.Finder
  - Core/Element.Event
  - Core/Element.Style
  - Core/JSON
  - Locale
  - Class.Binds
  - Date
  - Element.Forms
  - Locale.en-US.Form.Validator
  - Element.Shortcuts

provides: [Form.Validator, InputValidator, FormValidator.BaseValidators]

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

var InputValidator = this.InputValidator = new Class({

	Implements: [Options],

	options: {
		errorMsg: 'Validation failed.',
		test: Function.convert(true)
	},

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

	test: function(field, props){
		field = document.id(field);
		return (field) ? this.options.test(field, props || this.getProps(field)) : false;
	},

	getError: function(field, props){
		field = document.id(field);
		var err = this.options.errorMsg;
		if (typeOf(err) == 'function') err = err(field, props || this.getProps(field));
		return err;
	},

	getProps: function(field){
		field = document.id(field);
		return (field) ? field.get('validatorProps') : {};
	}

});

Element.Properties.validators = {

	get: function(){
		return (this.get('data-validators') || this.className).clean().replace(/'(\\.|[^'])*'|"(\\.|[^"])*"/g, function(match){
			return match.replace(' ', '\\x20');
		}).split(' ');
	}

};

Element.Properties.validatorProps = {

	set: function(props){
		return this.eliminate('$moo:validatorProps').store('$moo:validatorProps', props);
	},

	get: function(props){
		if (props) this.set(props);
		if (this.retrieve('$moo:validatorProps')) return this.retrieve('$moo:validatorProps');
		if (this.getProperty('data-validator-properties') || this.getProperty('validatorProps')){
			try {
				this.store('$moo:validatorProps', JSON.decode(this.getProperty('validatorProps') || this.getProperty('data-validator-properties'), false));
			} catch (e){
				return {};
			}
		} else {
			var vals = this.get('validators').filter(function(cls){
				return cls.test(':');
			});
			if (!vals.length){
				this.store('$moo:validatorProps', {});
			} else {
				props = {};
				vals.each(function(cls){
					var split = cls.split(':');
					if (split[1]){
						try {
							props[split[0]] = JSON.decode(split[1], false);
						} catch (e){}
					}
				});
				this.store('$moo:validatorProps', props);
			}
		}
		return this.retrieve('$moo:validatorProps');
	}

};

Form.Validator = new Class({

	Implements: [Options, Events],

	options: {/*
		onFormValidate: function(isValid, form, event){},
		onElementValidate: function(isValid, field, className, warn){},
		onElementPass: function(field){},
		onElementFail: function(field, validatorsFailed){}, */
		fieldSelectors: 'input, select, textarea',
		ignoreHidden: true,
		ignoreDisabled: true,
		useTitles: false,
		evaluateOnSubmit: true,
		evaluateFieldsOnBlur: true,
		evaluateFieldsOnChange: true,
		serial: true,
		stopOnFailure: true,
		warningPrefix: function(){
			return Form.Validator.getMsg('warningPrefix') || 'Warning: ';
		},
		errorPrefix: function(){
			return Form.Validator.getMsg('errorPrefix') || 'Error: ';
		}
	},

	initialize: function(form, options){
		this.setOptions(options);
		this.element = document.id(form);
		this.warningPrefix = Function.convert(this.options.warningPrefix)();
		this.errorPrefix = Function.convert(this.options.errorPrefix)();
		this._bound = {
			onSubmit: this.onSubmit.bind(this),
			blurOrChange: function(event, field){
				this.validationMonitor(field, true);
			}.bind(this)
		};
		this.enable();
	},

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

	getFields: function(){
		return (this.fields = this.element.getElements(this.options.fieldSelectors));
	},

	enable: function(){
		this.element.store('validator', this);
		if (this.options.evaluateOnSubmit) this.element.addEvent('submit', this._bound.onSubmit);
		if (this.options.evaluateFieldsOnBlur){
			this.element.addEvent('blur:relay(input,select,textarea)', this._bound.blurOrChange);
		}
		if (this.options.evaluateFieldsOnChange){
			this.element.addEvent('change:relay(input,select,textarea)', this._bound.blurOrChange);
		}
	},

	disable: function(){
		this.element.eliminate('validator');
		this.element.removeEvents({
			submit: this._bound.onSubmit,
			'blur:relay(input,select,textarea)': this._bound.blurOrChange,
			'change:relay(input,select,textarea)': this._bound.blurOrChange
		});
	},

	validationMonitor: function(){
		clearTimeout(this.timer);
		this.timer = this.validateField.delay(50, this, arguments);
	},

	onSubmit: function(event){
		if (this.validate(event)) this.reset();
	},

	reset: function(){
		this.getFields().each(this.resetField, this);
		return this;
	},

	validate: function(event){
		var result = this.getFields().map(function(field){
			return this.validateField(field, true);
		}, this).every(function(v){
			return v;
		});
		this.fireEvent('formValidate', [result, this.element, event]);
		if (this.options.stopOnFailure && !result && event) event.preventDefault();
		return result;
	},

	validateField: function(field, force){
		if (this.paused) return true;
		field = document.id(field);
		var passed = !field.hasClass('validation-failed');
		var failed, warned;
		if (this.options.serial && !force){
			failed = this.element.getElement('.validation-failed');
			warned = this.element.getElement('.warning');
		}
		if (field && (!failed || force || field.hasClass('validation-failed') || (failed && !this.options.serial))){
			var validationTypes = field.get('validators');
			var validators = validationTypes.some(function(cn){
				return this.getValidator(cn);
			}, this);
			var validatorsFailed = [];
			validationTypes.each(function(className){
				if (className && !this.test(className, field)) validatorsFailed.include(className);
			}, this);
			passed = validatorsFailed.length === 0;
			if (validators && !this.hasValidator(field, 'warnOnly')){
				if (passed){
					field.addClass('validation-passed').removeClass('validation-failed');
					this.fireEvent('elementPass', [field]);
				} else {
					field.addClass('validation-failed').removeClass('validation-passed');
					this.fireEvent('elementFail', [field, validatorsFailed]);
				}
			}
			if (!warned){
				var warnings = validationTypes.some(function(cn){
					if (cn.test('^warn'))
						return this.getValidator(cn.replace(/^warn-/,''));
					else return null;
				}, this);
				field.removeClass('warning');
				var warnResult = validationTypes.map(function(cn){
					if (cn.test('^warn'))
						return this.test(cn.replace(/^warn-/,''), field, true);
					else return null;
				}, this);
			}
		}
		return passed;
	},

	test: function(className, field, warn){
		field = document.id(field);
		if ((this.options.ignoreHidden && !field.isVisible()) || (this.options.ignoreDisabled && field.get('disabled'))) return true;
		var validator = this.getValidator(className);
		if (warn != null) warn = false;
		if (this.hasValidator(field, 'warnOnly')) warn = true;
		var isValid = field.hasClass('ignoreValidation') || (validator ? validator.test(field) : true);
		if (validator) this.fireEvent('elementValidate', [isValid, field, className, warn]);
		if (warn) return true;
		return isValid;
	},

	hasValidator: function(field, value){
		return field.get('validators').contains(value);
	},

	resetField: function(field){
		field = document.id(field);
		if (field){
			field.get('validators').each(function(className){
				if (className.test('^warn-')) className = className.replace(/^warn-/, '');
				field.removeClass('validation-failed');
				field.removeClass('warning');
				field.removeClass('validation-passed');
			}, this);
		}
		return this;
	},

	stop: function(){
		this.paused = true;
		return this;
	},

	start: function(){
		this.paused = false;
		return this;
	},

	ignoreField: function(field, warn){
		field = document.id(field);
		if (field){
			this.enforceField(field);
			if (warn) field.addClass('warnOnly');
			else field.addClass('ignoreValidation');
		}
		return this;
	},

	enforceField: function(field){
		field = document.id(field);
		if (field) field.removeClass('warnOnly').removeClass('ignoreValidation');
		return this;
	}

});

Form.Validator.getMsg = function(key){
	return Locale.get('FormValidator.' + key);
};

Form.Validator.adders = {

	validators:{},

	add : function(className, options){
		this.validators[className] = new InputValidator(className, options);
		//if this is a class (this method is used by instances of Form.Validator and the Form.Validator namespace)
		//extend these validators into it
		//this allows validators to be global and/or per instance
		if (!this.initialize){
			this.implement({
				validators: this.validators
			});
		}
	},

	addAllThese : function(validators){
		Array.convert(validators).each(function(validator){
			this.add(validator[0], validator[1]);
		}, this);
	},

	getValidator: function(className){
		return this.validators[className.split(':')[0]];
	}

};

Object.append(Form.Validator, Form.Validator.adders);

Form.Validator.implement(Form.Validator.adders);

Form.Validator.add('IsEmpty', {

	errorMsg: false,
	test: function(element){
		if (element.type == 'select-one' || element.type == 'select')
			return !(element.selectedIndex >= 0 && element.options[element.selectedIndex].value != '');
		else
			return ((element.get('value') == null) || (element.get('value').length == 0));
	}

});

Form.Validator.addAllThese([

	['required', {
		errorMsg: function(){
			return Form.Validator.getMsg('required');
		},
		test: function(element){
			return !Form.Validator.getValidator('IsEmpty').test(element);
		}
	}],

	['length', {
		errorMsg: function(element, props){
			if (typeOf(props.length) != 'null')
				return Form.Validator.getMsg('length').substitute({length: props.length, elLength: element.get('value').length});
			else return '';
		},
		test: function(element, props){
			if (typeOf(props.length) != 'null') return (element.get('value').length == props.length || element.get('value').length == 0);
			else return true;
		}
	}],

	['minLength', {
		errorMsg: function(element, props){
			if (typeOf(props.minLength) != 'null')
				return Form.Validator.getMsg('minLength').substitute({minLength: props.minLength, length: element.get('value').length});
			else return '';
		},
		test: function(element, props){
			if (typeOf(props.minLength) != 'null') return (element.get('value').length >= (props.minLength || 0));
			else return true;
		}
	}],

	['maxLength', {
		errorMsg: function(element, props){
			//props is {maxLength:10}
			if (typeOf(props.maxLength) != 'null')
				return Form.Validator.getMsg('maxLength').substitute({maxLength: props.maxLength, length: element.get('value').length});
			else return '';
		},
		test: function(element, props){
			return element.get('value').length <= (props.maxLength || 10000);
		}
	}],

	['validate-integer', {
		errorMsg: Form.Validator.getMsg.pass('integer'),
		test: function(element){
			return Form.Validator.getValidator('IsEmpty').test(element) || (/^(-?[1-9]\d*|0)$/).test(element.get('value'));
		}
	}],

	['validate-numeric', {
		errorMsg: Form.Validator.getMsg.pass('numeric'),
		test: function(element){
			return Form.Validator.getValidator('IsEmpty').test(element) ||
				(/^-?(?:0$0(?=\d*\.)|[1-9]|0)\d*(\.\d+)?$/).test(element.get('value'));
		}
	}],

	['validate-digits', {
		errorMsg: Form.Validator.getMsg.pass('digits'),
		test: function(element){
			return Form.Validator.getValidator('IsEmpty').test(element) || (/^[\d() .:\-\+#]+$/.test(element.get('value')));
		}
	}],

	['validate-alpha', {
		errorMsg: Form.Validator.getMsg.pass('alpha'),
		test: function(element){
			return Form.Validator.getValidator('IsEmpty').test(element) || (/^[a-zA-Z]+$/).test(element.get('value'));
		}
	}],

	['validate-alphanum', {
		errorMsg: Form.Validator.getMsg.pass('alphanum'),
		test: function(element){
			return Form.Validator.getValidator('IsEmpty').test(element) || !(/\W/).test(element.get('value'));
		}
	}],

	['validate-date', {
		errorMsg: function(element, props){
			if (Date.parse){
				var format = props.dateFormat || '%x';
				return Form.Validator.getMsg('dateSuchAs').substitute({date: new Date().format(format)});
			} else {
				return Form.Validator.getMsg('dateInFormatMDY');
			}
		},
		test: function(element, props){
			if (Form.Validator.getValidator('IsEmpty').test(element)) return true;
			var dateLocale = Locale.get('Date'),
				dateNouns = new RegExp([dateLocale.days, dateLocale.days_abbr, dateLocale.months, dateLocale.months_abbr, dateLocale.AM, dateLocale.PM].flatten().join('|'), 'i'),
				value = element.get('value'),
				wordsInValue = value.match(/[a-z]+/gi);

			if (wordsInValue && !wordsInValue.every(dateNouns.exec, dateNouns)) return false;

			var date = Date.parse(value);
			if (!date) return false;

			var format = props.dateFormat || '%x',
				formatted = date.format(format);
			if (formatted != 'invalid date') element.set('value', formatted);
			return date.isValid();
		}
	}],

	['validate-email', {
		errorMsg: Form.Validator.getMsg.pass('email'),
		test: function(element){
			/*
			var chars = "[a-z0-9!#$%&'*+/=?^_`{|}~-]",
				local = '(?:' + chars + '\\.?){0,63}' + chars,

				label = '[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?',
				hostname = '(?:' + label + '\\.)*' + label;

				octet = '(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)',
				ipv4 = '\\[(?:' + octet + '\\.){3}' + octet + '\\]',

				domain = '(?:' + hostname + '|' + ipv4 + ')';

			var regex = new RegExp('^' + local + '@' + domain + '$', 'i');
			*/
			return Form.Validator.getValidator('IsEmpty').test(element) || (/^(?:[a-z0-9!#$%&'*+\/=?^_`{|}~-]\.?){0,63}[a-z0-9!#$%&'*+\/=?^_`{|}~-]@(?:(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)*[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\])$/i).test(element.get('value'));
		}
	}],

	['validate-url', {
		errorMsg: Form.Validator.getMsg.pass('url'),
		test: function(element){
			return Form.Validator.getValidator('IsEmpty').test(element) || (/^(https?|ftp|rmtp|mms):\/\/(([A-Z0-9][A-Z0-9_-]*)(\.[A-Z0-9][A-Z0-9_-]*)+)(:(\d+))?\/?/i).test(element.get('value'));
		}
	}],

	['validate-currency-dollar', {
		errorMsg: Form.Validator.getMsg.pass('currencyDollar'),
		test: function(element){
			return Form.Validator.getValidator('IsEmpty').test(element) || (/^\$?\-?([1-9]{1}[0-9]{0,2}(\,[0-9]{3})*(\.[0-9]{0,2})?|[1-9]{1}\d*(\.[0-9]{0,2})?|0(\.[0-9]{0,2})?|(\.[0-9]{1,2})?)$/).test(element.get('value'));
		}
	}],

	['validate-one-required', {
		errorMsg: Form.Validator.getMsg.pass('oneRequired'),
		test: function(element, props){
			var p = document.id(props['validate-one-required']) || element.getParent(props['validate-one-required']);
			return p.getElements('input').some(function(el){
				if (['checkbox', 'radio'].contains(el.get('type'))) return el.get('checked');
				return el.get('value');
			});
		}
	}]

]);

Element.Properties.validator = {

	set: function(options){
		this.get('validator').setOptions(options);
	},

	get: function(){
		var validator = this.retrieve('validator');
		if (!validator){
			validator = new Form.Validator(this);
			this.store('validator', validator);
		}
		return validator;
	}

};

Element.implement({

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

});






/*
---

script: Form.Validator.Extras.js

name: Form.Validator.Extras

description: Additional validators for the Form.Validator class.

license: MIT-style license

authors:
  - Aaron Newton

requires:
  - Form.Validator

provides: [Form.Validator.Extras]

...
*/

(function(){

function getItems(props, preference, children, cssSelector){
	if (preference && props[preference]) return props[preference];
	var el = document.id(props[children]);
	if (!el) return [];
	return el.getElements(cssSelector);
}

Form.Validator.addAllThese([

	['validate-enforce-oncheck', {
		test: function(element, props){
			var fv = element.getParent('form').retrieve('validator');
			if (!fv) return true;
			getItems(props, 'toEnforce', 'enforceChildrenOf', 'input, select, textarea').each(function(item){
				if (element.checked){
					fv.enforceField(item);
				} else {
					fv.ignoreField(item);
					fv.resetField(item);
				}
			});
			return true;
		}
	}],

	['validate-ignore-oncheck', {
		test: function(element, props){
			var fv = element.getParent('form').retrieve('validator');
			if (!fv) return true;
			getItems(props, 'toIgnore', 'ignoreChildrenOf', 'input, select, textarea').each(function(item){
				if (element.checked){
					fv.ignoreField(item);
					fv.resetField(item);
				} else {
					fv.enforceField(item);
				}
			});
			return true;
		}
	}],

	['validate-enforce-onselect-value', {
		test: function(element, props){
			if (!props.value) return true;
			var fv = element.getParent('form').retrieve('validator');
			if (!fv) return true;
			getItems(props, 'toEnforce', 'enforceChildrenOf', 'input, select, textarea').each(function(item){
				if (props.value == element.value){
					fv.enforceField(item);
				} else {
					fv.ignoreField(item);
					fv.resetField(item);
				}
			});
			return true;
		}
	}],

	['validate-nospace', {
		errorMsg: function(){
			return Form.Validator.getMsg('noSpace');
		},
		test: function(element, props){
			return !element.get('value').test(/\s/);
		}
	}],

	['validate-toggle-oncheck', {
		test: function(element, props){
			var fv = element.getParent('form').retrieve('validator');
			if (!fv) return true;
			var eleArr = getItems(props, 'toToggle', 'toToggleChildrenOf', 'input, select, textarea');
			if (!element.checked){
				eleArr.each(function(item){
					fv.ignoreField(item);
					fv.resetField(item);
				});
			} else {
				eleArr.each(function(item){
					fv.enforceField(item);
				});
			}
			return true;
		}
	}],

	['validate-reqchk-bynode', {
		errorMsg: function(){
			return Form.Validator.getMsg('reqChkByNode');
		},
		test: function(element, props){
			return getItems(props, false, 'nodeId', props.selector || 'input[type=checkbox], input[type=radio]').some(function(item){
				return item.checked;
			});
		}
	}],

	['validate-required-check', {
		errorMsg: function(element, props){
			return props.useTitle ? element.get('title') : Form.Validator.getMsg('requiredChk');
		},
		test: function(element, props){
			return !!element.checked;
		}
	}],

	['validate-reqchk-byname', {
		errorMsg: function(element, props){
			return Form.Validator.getMsg('reqChkByName').substitute({label: props.label || element.get('type')});
		},
		test: function(element, props){
			var grpName = props.groupName || element.get('name');
			var grpNameEls = $$('[name=' + grpName +']');
			var oneCheckedItem = grpNameEls.some(function(item, index){
				return item.checked;
			});
			var fv = element.getParent('form').retrieve('validator');
			if (oneCheckedItem && fv){
				grpNameEls.each(function(item, index){ fv.resetField(item); });
			}
			return oneCheckedItem;
		}
	}],

	['validate-match', {
		errorMsg: function(element, props){
			return Form.Validator.getMsg('match').substitute({matchName: decodeURIComponent((props.matchName+'').replace(/\+/g, '%20')) || document.id(props.matchInput).get('name')});
		},
		test: function(element, props){
			var eleVal = element.get('value');
			var matchVal = document.id(props.matchInput) && document.id(props.matchInput).get('value');
			return eleVal && matchVal ? eleVal == matchVal : true;
		}
	}],

	['validate-after-date', {
		errorMsg: function(element, props){
			return Form.Validator.getMsg('afterDate').substitute({
				label: props.afterLabel || (props.afterElement ? Form.Validator.getMsg('startDate') : Form.Validator.getMsg('currentDate'))
			});
		},
		test: function(element, props){
			var start = document.id(props.afterElement) ? Date.parse(document.id(props.afterElement).get('value')) : new Date();
			var end = Date.parse(element.get('value'));
			return end && start ? end >= start : true;
		}
	}],

	['validate-before-date', {
		errorMsg: function(element, props){
			return Form.Validator.getMsg('beforeDate').substitute({
				label: props.beforeLabel || (props.beforeElement ? Form.Validator.getMsg('endDate') : Form.Validator.getMsg('currentDate'))
			});
		},
		test: function(element, props){
			var start = Date.parse(element.get('value'));
			var end = document.id(props.beforeElement) ? Date.parse(document.id(props.beforeElement).get('value')) : new Date();
			return end && start ? end >= start : true;
		}
	}],

	['validate-custom-required', {
		errorMsg: function(){
			return Form.Validator.getMsg('required');
		},
		test: function(element, props){
			return element.get('value') != props.emptyValue;
		}
	}],

	['validate-same-month', {
		errorMsg: function(element, props){
			var startMo = document.id(props.sameMonthAs) && document.id(props.sameMonthAs).get('value');
			var eleVal = element.get('value');
			if (eleVal != '') return Form.Validator.getMsg(startMo ? 'sameMonth' : 'startMonth');
		},
		test: function(element, props){
			var d1 = Date.parse(element.get('value'));
			var d2 = Date.parse(document.id(props.sameMonthAs) && document.id(props.sameMonthAs).get('value'));
			return d1 && d2 ? d1.format('%B') == d2.format('%B') : true;
		}
	}],


	['validate-cc-num', {
		errorMsg: function(element){
			var ccNum = element.get('value').replace(/[^0-9]/g, '');
			return Form.Validator.getMsg('creditcard').substitute({length: ccNum.length});
		},
		test: function(element){
			// required is a different test
			if (Form.Validator.getValidator('IsEmpty').test(element)) return true;

			// Clean number value
			var ccNum = element.get('value');
			ccNum = ccNum.replace(/[^0-9]/g, '');

			var validType = false;

			if (ccNum.test(/^4[0-9]{12}([0-9]{3})?$/)) validType = 'Visa';
			else if (ccNum.test(/^5[1-5]([0-9]{14})$/)) validType = 'Master Card';
			else if (ccNum.test(/^3[47][0-9]{13}$/)) validType = 'American Express';
			else if (ccNum.test(/^6(?:011|5[0-9]{2})[0-9]{12}$/)) validType = 'Discover';
			else if (ccNum.test(/^3(?:0[0-5]|[68][0-9])[0-9]{11}$/)) validType = 'Diners Club';

			if (validType){
				var sum = 0;
				var cur = 0;

				for (var i=ccNum.length-1; i>=0; --i){
					cur = ccNum.charAt(i).toInt();
					if (cur == 0) continue;

					if ((ccNum.length-i) % 2 == 0) cur += cur;
					if (cur > 9){
						cur = cur.toString().charAt(0).toInt() + cur.toString().charAt(1).toInt();
					}

					sum += cur;
				}
				if ((sum % 10) == 0) return true;
			}

			var chunks = '';
			while (ccNum != ''){
				chunks += ' ' + ccNum.substr(0,4);
				ccNum = ccNum.substr(4);
			}

			element.getParent('form').retrieve('validator').ignoreField(element);
			element.set('value', chunks.clean());
			element.getParent('form').retrieve('validator').enforceField(element);
			return false;
		}
	}]

]);

})();

/*
---

script: Form.Validator.Inline.js

name: Form.Validator.Inline

description: Extends Form.Validator to add inline messages.

license: MIT-style license

authors:
  - Aaron Newton

requires:
  - Form.Validator

provides: [Form.Validator.Inline]

...
*/

Form.Validator.Inline = new Class({

	Extends: Form.Validator,

	options: {
		showError: function(errorElement){
			if (errorElement.reveal) errorElement.reveal();
			else errorElement.setStyle('display', 'block');
		},
		hideError: function(errorElement){
			if (errorElement.dissolve) errorElement.dissolve();
			else errorElement.setStyle('display', 'none');
		},
		scrollToErrorsOnSubmit: true,
		scrollToErrorsOnBlur: false,
		scrollToErrorsOnChange: false,
		scrollFxOptions: {
			transition: 'quad:out',
			offset: {
				y: -20
			}
		}
	},

	initialize: function(form, options){
		this.parent(form, options);
		this.addEvent('onElementValidate', function(isValid, field, className, warn){
			var validator = this.getValidator(className);
			if (!isValid && validator.getError(field)){
				if (warn) field.addClass('warning');
				var advice = this.makeAdvice(className, field, validator.getError(field), warn);
				this.insertAdvice(advice, field);
				this.showAdvice(className, field);
			} else {
				this.hideAdvice(className, field);
			}
		});
	},

	makeAdvice: function(className, field, error, warn){
		var errorMsg = (warn) ? this.warningPrefix : this.errorPrefix;
		errorMsg += (this.options.useTitles) ? field.title || error:error;
		var cssClass = (warn) ? 'warning-advice' : 'validation-advice';
		var advice = this.getAdvice(className, field);
		if (advice){
			advice = advice.set('html', errorMsg);
		} else {
			advice = new Element('div', {
				html: errorMsg,
				styles: { display: 'none' },
				id: 'advice-' + className.split(':')[0] + '-' + this.getFieldId(field)
			}).addClass(cssClass);
		}
		field.store('$moo:advice-' + className, advice);
		return advice;
	},

	getFieldId : function(field){
		return field.id ? field.id : field.id = 'input_' + field.name;
	},

	showAdvice: function(className, field){
		var advice = this.getAdvice(className, field);
		if (
			advice &&
			!field.retrieve('$moo:' + this.getPropName(className)) &&
			(
				advice.getStyle('display') == 'none' ||
				advice.getStyle('visibility') == 'hidden' ||
				advice.getStyle('opacity') == 0
			)
		){
			field.store('$moo:' + this.getPropName(className), true);
			this.options.showError(advice);
			this.fireEvent('showAdvice', [field, advice, className]);
		}
	},

	hideAdvice: function(className, field){
		var advice = this.getAdvice(className, field);
		if (advice && field.retrieve('$moo:' + this.getPropName(className))){
			field.store('$moo:' + this.getPropName(className), false);
			this.options.hideError(advice);
			this.fireEvent('hideAdvice', [field, advice, className]);
		}
	},

	getPropName: function(className){
		return 'advice' + className;
	},

	resetField: function(field){
		field = document.id(field);
		if (!field) return this;
		this.parent(field);
		field.get('validators').each(function(className){
			this.hideAdvice(className, field);
		}, this);
		return this;
	},

	getAllAdviceMessages: function(field, force){
		var advice = [];
		if (field.hasClass('ignoreValidation') && !force) return advice;
		var validators = field.get('validators').some(function(cn){
			var warner = cn.test('^warn-') || field.hasClass('warnOnly');
			if (warner) cn = cn.replace(/^warn-/, '');
			var validator = this.getValidator(cn);
			if (!validator) return;
			advice.push({
				message: validator.getError(field),
				warnOnly: warner,
				passed: validator.test(),
				validator: validator
			});
		}, this);
		return advice;
	},

	getAdvice: function(className, field){
		return field.retrieve('$moo:advice-' + className);
	},

	insertAdvice: function(advice, field){
		//Check for error position prop
		var props = field.get('validatorProps');
		//Build advice
		if (!props.msgPos || !document.id(props.msgPos)){
			if (field.type && field.type.toLowerCase() == 'radio') field.getParent().adopt(advice);
			else advice.inject(document.id(field), 'after');
		} else {
			document.id(props.msgPos).grab(advice);
		}
	},

	validateField: function(field, force, scroll){
		var result = this.parent(field, force);
		if (((this.options.scrollToErrorsOnSubmit && scroll == null) || scroll) && !result){
			var failed = document.id(this).getElement('.validation-failed');
			var par = document.id(this).getParent();
			while (par != document.body && par.getScrollSize().y == par.getSize().y){
				par = par.getParent();
			}
			var fx = par.retrieve('$moo:fvScroller');
			if (!fx && window.Fx && Fx.Scroll){
				fx = new Fx.Scroll(par, this.options.scrollFxOptions);
				par.store('$moo:fvScroller', fx);
			}
			if (failed){
				if (fx) fx.toElement(failed);
				else par.scrollTo(par.getScroll().x, failed.getPosition(par).y - 20);
			}
		}
		return result;
	},

	watchFields: function(fields){
		fields.each(function(el){
			if (this.options.evaluateFieldsOnBlur){
				el.addEvent('blur', this.validationMonitor.pass([el, false, this.options.scrollToErrorsOnBlur], this));
			}
			if (this.options.evaluateFieldsOnChange){
				el.addEvent('change', this.validationMonitor.pass([el, true, this.options.scrollToErrorsOnChange], this));
			}
		}, this);
	}

});

/*
---

script: Scroller.js

name: Scroller

description: Class which scrolls the contents of any Element (including the window) when the mouse reaches the Element's boundaries.

license: MIT-style license

authors:
  - Valerio Proietti

requires:
  - Core/Events
  - Core/Options
  - Core/Element.Event
  - Core/Element.Dimensions
  - MooTools.More

provides: [Scroller]

...
*/
(function(){

var Scroller = this.Scroller = new Class({

	Implements: [Events, Options],

	options: {
		area: 20,
		velocity: 1,
		onChange: function(x, y){
			this.element.scrollTo(x, y);
		},
		fps: 50
	},

	initialize: function(element, options){
		this.setOptions(options);
		this.element = document.id(element);
		this.docBody = document.id(this.element.getDocument().body);
		this.listener = (typeOf(this.element) != 'element') ? this.docBody : this.element;
		this.timer = null;
		this.bound = {
			attach: this.attach.bind(this),
			detach: this.detach.bind(this),
			getCoords: this.getCoords.bind(this)
		};
	},

	start: function(){
		this.listener.addEvents({
			mouseover: this.bound.attach,
			mouseleave: this.bound.detach
		});
		return this;
	},

	stop: function(){
		this.listener.removeEvents({
			mouseover: this.bound.attach,
			mouseleave: this.bound.detach
		});
		this.detach();
		this.timer = clearInterval(this.timer);
		return this;
	},

	attach: function(){
		this.listener.addEvent('mousemove', this.bound.getCoords);
	},

	detach: function(){
		this.listener.removeEvent('mousemove', this.bound.getCoords);
		this.timer = clearInterval(this.timer);
	},

	getCoords: function(event){
		this.page = (this.listener.get('tag') == 'body') ? event.client : event.page;
		if (!this.timer) this.timer = this.scroll.periodical(Math.round(1000 / this.options.fps), this);
	},

	scroll: function(){
		var size = this.element.getSize(),
			scroll = this.element.getScroll(),
			pos = ((this.element != this.docBody) && (this.element != window)) ? this.element.getOffsets() : {x: 0, y: 0},
			scrollSize = this.element.getScrollSize(),
			change = {x: 0, y: 0},
			top = this.options.area.top || this.options.area,
			bottom = this.options.area.bottom || this.options.area;
		for (var z in this.page){
			if (this.page[z] < (top + pos[z]) && scroll[z] != 0){
				change[z] = (this.page[z] - top - pos[z]) * this.options.velocity;
			} else if (this.page[z] + bottom > (size[z] + pos[z]) && scroll[z] + size[z] != scrollSize[z]){
				change[z] = (this.page[z] - size[z] + bottom - pos[z]) * this.options.velocity;
			}
			change[z] = change[z].round();
		}
		if (change.y || change.x) this.fireEvent('change', [scroll.x + change.x, scroll.y + change.y]);
	}

});

})();


/*
---

script: Tips.js

name: Tips

description: Class for creating nice tips that follow the mouse cursor when hovering an element.

license: MIT-style license

authors:
  - Valerio Proietti
  - Christoph Pojer
  - Luis Merino

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

provides: [Tips]

...
*/

(function(){

var read = function(option, element){
	return (option) ? (typeOf(option) == 'function' ? option(element) : element.get(option)) : '';
};

var Tips = this.Tips = new Class({

	Implements: [Events, Options],

	options: {/*
		id: null,
		onAttach: function(element){},
		onDetach: function(element){},
		onBound: function(coords){},*/
		onShow: function(){
			this.tip.setStyle('display', 'block');
		},
		onHide: function(){
			this.tip.setStyle('display', 'none');
		},
		title: 'title',
		text: function(element){
			return element.get('rel') || element.get('href');
		},
		showDelay: 100,
		hideDelay: 100,
		className: 'tip-wrap',
		offset: {x: 16, y: 16},
		windowPadding: {x:0, y:0},
		fixed: false,
		waiAria: true,
		hideEmpty: false
	},

	initialize: function(){
		var params = Array.link(arguments, {
			options: Type.isObject,
			elements: function(obj){
				return obj != null;
			}
		});
		this.setOptions(params.options);
		if (params.elements) this.attach(params.elements);
		this.container = new Element('div', {'class': 'tip'});

		if (this.options.id){
			this.container.set('id', this.options.id);
			if (this.options.waiAria) this.attachWaiAria();
		}
	},

	toElement: function(){
		if (this.tip) return this.tip;

		this.tip = new Element('div', {
			'class': this.options.className,
			styles: {
				position: 'absolute',
				top: 0,
				left: 0,
				display: 'none'
			}
		}).adopt(
			new Element('div', {'class': 'tip-top'}),
			this.container,
			new Element('div', {'class': 'tip-bottom'})
		);

		return this.tip;
	},

	attachWaiAria: function(){
		var id = this.options.id;
		this.container.set('role', 'tooltip');

		if (!this.waiAria){
			this.waiAria = {
				show: function(element){
					if (id) element.set('aria-describedby', id);
					this.container.set('aria-hidden', 'false');
				},
				hide: function(element){
					if (id) element.erase('aria-describedby');
					this.container.set('aria-hidden', 'true');
				}
			};
		}
		this.addEvents(this.waiAria);
	},

	detachWaiAria: function(){
		if (this.waiAria){
			this.container.erase('role');
			this.container.erase('aria-hidden');
			this.removeEvents(this.waiAria);
		}
	},

	attach: function(elements){
		$$(elements).each(function(element){
			var title = read(this.options.title, element),
				text = read(this.options.text, element);

			element.set('title', '').store('tip:native', title).retrieve('tip:title', title);
			element.retrieve('tip:text', text);
			this.fireEvent('attach', [element]);

			var events = ['enter', 'leave'];
			if (!this.options.fixed) events.push('move');

			events.each(function(value){
				var event = element.retrieve('tip:' + value);
				if (!event) event = function(event){
					this['element' + value.capitalize()].apply(this, [event, element]);
				}.bind(this);

				element.store('tip:' + value, event).addEvent('mouse' + value, event);
			}, this);
		}, this);

		return this;
	},

	detach: function(elements){
		$$(elements).each(function(element){
			['enter', 'leave', 'move'].each(function(value){
				element.removeEvent('mouse' + value, element.retrieve('tip:' + value)).eliminate('tip:' + value);
			});

			this.fireEvent('detach', [element]);

			if (this.options.title == 'title'){ // This is necessary to check if we can revert the title
				var original = element.retrieve('tip:native');
				if (original) element.set('title', original);
			}
		}, this);

		return this;
	},

	elementEnter: function(event, element){
		clearTimeout(this.timer);
		this.timer = (function(){
			this.container.empty();
			var showTip = !this.options.hideEmpty;
			['title', 'text'].each(function(value){
				var content = element.retrieve('tip:' + value);
				var div = this['_' + value + 'Element'] = new Element('div', {
					'class': 'tip-' + value
				}).inject(this.container);
				if (content){
					this.fill(div, content);
					showTip = true;
				}
			}, this);
			if (showTip){
				this.show(element);
			} else {
				this.hide(element);
			}
			this.position((this.options.fixed) ? {page: element.getPosition()} : event);
		}).delay(this.options.showDelay, this);
	},

	elementLeave: function(event, element){
		clearTimeout(this.timer);
		this.timer = this.hide.delay(this.options.hideDelay, this, element);
		this.fireForParent(event, element);
	},

	setTitle: function(title){
		if (this._titleElement){
			this._titleElement.empty();
			this.fill(this._titleElement, title);
		}
		return this;
	},

	setText: function(text){
		if (this._textElement){
			this._textElement.empty();
			this.fill(this._textElement, text);
		}
		return this;
	},

	fireForParent: function(event, element){
		element = element.getParent();
		if (!element || element == document.body) return;
		if (element.retrieve('tip:enter')) element.fireEvent('mouseenter', event);
		else this.fireForParent(event, element);
	},

	elementMove: function(event, element){
		this.position(event);
	},

	position: function(event){
		if (!this.tip) document.id(this);

		var size = window.getSize(), scroll = window.getScroll(),
			tip = {x: this.tip.offsetWidth, y: this.tip.offsetHeight},
			props = {x: 'left', y: 'top'},
			bounds = {y: false, x2: false, y2: false, x: false},
			obj = {};

		for (var z in props){
			obj[props[z]] = event.page[z] + this.options.offset[z];
			if (obj[props[z]] < 0) bounds[z] = true;
			if ((obj[props[z]] + tip[z] - scroll[z]) > size[z] - this.options.windowPadding[z]){
				obj[props[z]] = event.page[z] - this.options.offset[z] - tip[z];
				bounds[z+'2'] = true;
			}
		}

		this.fireEvent('bound', bounds);
		this.tip.setStyles(obj);
	},

	fill: function(element, contents){
		if (typeof contents == 'string') element.set('html', contents);
		else element.adopt(contents);
	},

	show: function(element){
		if (!this.tip) document.id(this);
		if (!this.tip.getParent()) this.tip.inject(document.body);
		this.fireEvent('show', [this.tip, element]);
	},

	hide: function(element){
		if (!this.tip) document.id(this);
		this.fireEvent('hide', [this.tip, element]);
	}

});

})();

/*
---
name: Locale.CH.Number
description: Number messages for Switzerland.
license: MIT-style license
authors:
  - Kim D. Jeker
requires:
  - Locale
provides: [Locale.CH.Number]
...
*/

Locale.define('CH', 'Number', {

	decimal: ',',
	group: '\'',

	currency: {
		decimal: '.',
		suffix: ' CHF'
	}

});

/*
---

name: Locale.EU.Number

description: Number messages for Europe.

license: MIT-style license

authors:
  - Arian Stolwijk

requires:
  - Locale

provides: [Locale.EU.Number]

...
*/

Locale.define('EU', 'Number', {

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

	currency: {
		prefix: '€ '
	}

});

/*
---

script: Locale.Set.From.js

name: Locale.Set.From

description: Provides an alternative way to create Locale.Set objects.

license: MIT-style license

authors:
  - Tim Wienk

requires:
  - Core/JSON
  - Locale

provides: Locale.Set.From

...
*/

(function(){

var parsers = {
	'json': JSON.decode
};

Locale.Set.defineParser = function(name, fn){
	parsers[name] = fn;
};

Locale.Set.from = function(set, type){
	if (instanceOf(set, Locale.Set)) return set;

	if (!type && typeOf(set) == 'string') type = 'json';
	if (parsers[type]) set = parsers[type](set);

	var locale = new Locale.Set;

	locale.sets = set.sets || {};

	if (set.inherits){
		locale.inherits.locales = Array.convert(set.inherits.locales);
		locale.inherits.sets = set.inherits.sets || {};
	}

	return locale;
};

})();

/*
---

name: Locale.ZA.Number

description: Number messages for ZA.

license: MIT-style license

authors:
  - Werner Mollentze

requires:
  - Locale

provides: [Locale.ZA.Number]

...
*/

Locale.define('ZA', 'Number', {

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

	currency: {
		prefix: 'R '
	}

});



/*
---

name: Locale.af-ZA.Date

description: Date messages for ZA Afrikaans.

license: MIT-style license

authors:
  - Werner Mollentze

requires:
  - Locale

provides: [Locale.af-ZA.Date]

...
*/

Locale.define('af-ZA', 'Date', {

	months: ['Januarie', 'Februarie', 'Maart', 'April', 'Mei', 'Junie', 'Julie', 'Augustus', 'September', 'Oktober', 'November', 'Desember'],
	months_abbr: ['Jan', 'Feb', 'Mrt', 'Apr', 'Mei', 'Jun', 'Jul', 'Aug', 'Sep', 'Okt', 'Nov', 'Des'],
	days: ['Sondag', 'Maandag', 'Dinsdag', 'Woensdag', 'Donderdag', 'Vrydag', 'Saterdag'],
	days_abbr: ['Son', 'Maa', 'Din', 'Woe', 'Don', 'Vry', 'Sat'],

	// Culture's date order: MM/DD/YYYY
	dateOrder: ['date', 'month', 'year'],
	shortDate: '%d-%m-%Y',
	shortTime: '%H:%M',
	AM: 'VM',
	PM: 'NM',
	firstDayOfWeek: 1,

	// Date.Extras
	ordinal: function(dayOfMonth){
		return ((dayOfMonth > 1 && dayOfMonth < 20 && dayOfMonth != 8) || (dayOfMonth > 100 && dayOfMonth.toString().substr(-2, 1) == '1')) ? 'de' : 'ste';
	},

	lessThanMinuteAgo: 'minder as \'n minuut gelede',
	minuteAgo: 'ongeveer \'n minuut gelede',
	minutesAgo: '{delta} minute gelede',
	hourAgo: 'omtret \'n uur gelede',
	hoursAgo: 'ongeveer {delta} ure gelede',
	dayAgo: '1 dag gelede',
	daysAgo: '{delta} dae gelede',
	weekAgo: '1 week gelede',
	weeksAgo: '{delta} weke gelede',
	monthAgo: '1 maand gelede',
	monthsAgo: '{delta} maande gelede',
	yearAgo: '1 jaar gelede',
	yearsAgo: '{delta} jare gelede',

	lessThanMinuteUntil: 'oor minder as \'n minuut',
	minuteUntil: 'oor ongeveer \'n minuut',
	minutesUntil: 'oor {delta} minute',
	hourUntil: 'oor ongeveer \'n uur',
	hoursUntil: 'oor {delta} uur',
	dayUntil: 'oor ongeveer \'n dag',
	daysUntil: 'oor {delta} dae',
	weekUntil: 'oor \'n week',
	weeksUntil: 'oor {delta} weke',
	monthUntil: 'oor \'n maand',
	monthsUntil: 'oor {delta} maande',
	yearUntil: 'oor \'n jaar',
	yearsUntil: 'oor {delta} jaar'

});

/*
---

name: Locale.af-ZA.Form.Validator

description: Form Validator messages for Afrikaans.

license: MIT-style license

authors:
  - Werner Mollentze

requires:
  - Locale

provides: [Locale.af-ZA.Form.Validator]

...
*/

Locale.define('af-ZA', 'FormValidator', {

	required: 'Hierdie veld word vereis.',
	length: 'Voer asseblief {length} karakters in (u het {elLength} karakters ingevoer)',
	minLength: 'Voer asseblief ten minste {minLength} karakters in (u het {length} karakters ingevoer).',
	maxLength: 'Moet asseblief nie meer as {maxLength} karakters invoer nie (u het {length} karakters ingevoer).',
	integer: 'Voer asseblief \'n heelgetal in hierdie veld in. Getalle met desimale (bv. 1.25) word nie toegelaat nie.',
	numeric: 'Voer asseblief slegs numeriese waardes in hierdie veld in (bv. "1" of "1.1" of "-1" of "-1.1").',
	digits: 'Gebruik asseblief slegs nommers en punktuasie in hierdie veld. (by voorbeeld, \'n telefoon nommer wat koppeltekens en punte bevat is toelaatbaar).',
	alpha: 'Gebruik asseblief slegs letters (a-z) binne-in hierdie veld. Geen spasies of ander karakters word toegelaat nie.',
	alphanum: 'Gebruik asseblief slegs letters (a-z) en nommers (0-9) binne-in hierdie veld. Geen spasies of ander karakters word toegelaat nie.',
	dateSuchAs: 'Voer asseblief \'n geldige datum soos {date} in',
	dateInFormatMDY: 'Voer asseblief \'n geldige datum soos MM/DD/YYYY in (bv. "12/31/1999")',
	email: 'Voer asseblief \'n geldige e-pos adres in. Byvoorbeeld "fred@domain.com".',
	url: 'Voer asseblief \'n geldige bronadres (URL) soos http://www.example.com in.',
	currencyDollar: 'Voer asseblief \'n geldige $ bedrag in. Byvoorbeeld $100.00 .',
	oneRequired: 'Voer asseblief iets in vir ten minste een van hierdie velde.',
	errorPrefix: 'Fout: ',
	warningPrefix: 'Waarskuwing: ',

	// Form.Validator.Extras
	noSpace: 'Daar mag geen spasies in hierdie toevoer wees nie.',
	reqChkByNode: 'Geen items is gekies nie.',
	requiredChk: 'Hierdie veld word vereis.',
	reqChkByName: 'Kies asseblief \'n {label}.',
	match: 'Hierdie veld moet by die {matchName} veld pas',
	startDate: 'die begin datum',
	endDate: 'die eind datum',
	currentDate: 'die huidige datum',
	afterDate: 'Die datum moet dieselfde of na {label} wees.',
	beforeDate: 'Die datum moet dieselfde of voor {label} wees.',
	startMonth: 'Kies asseblief \'n begin maand',
	sameMonth: 'Hierdie twee datums moet in dieselfde maand wees - u moet een of beide verander.',
	creditcard: 'Die ingevoerde kredietkaart nommer is ongeldig. Bevestig asseblief die nommer en probeer weer. {length} syfers is ingevoer.'

});

/*
---

name: Locale.af-ZA.Number

description: Number messages for ZA Afrikaans.

license: MIT-style license

authors:
  - Werner Mollentze

requires:
  - Locale
  - Locale.ZA.Number

provides: [Locale.af-ZA.Number]

...
*/

Locale.define('af-ZA').inherit('ZA', 'Number');

/*
---

name: Locale.ar.Date

description: Date messages for Arabic.

license: MIT-style license

authors:
  - Chafik Barbar

requires:
  - Locale

provides: [Locale.ar.Date]

...
*/

Locale.define('ar', 'Date', {

	// Culture's date order: DD/MM/YYYY
	dateOrder: ['date', 'month', 'year'],
	shortDate: '%d/%m/%Y',
	shortTime: '%H:%M'

});

/*
---

name: Locale.ar.Form.Validator

description: Form Validator messages for Arabic.

license: MIT-style license

authors:
  - Chafik Barbar

requires:
  - Locale

provides: [Locale.ar.Form.Validator]

...
*/

Locale.define('ar', 'FormValidator', {

	required: 'هذا الحقل مطلوب.',
	minLength: 'رجاءً إدخال {minLength} أحرف على الأقل (تم إدخال {length} أحرف).',
	maxLength: 'الرجاء عدم إدخال أكثر من {maxLength} أحرف (تم إدخال {length} أحرف).',
	integer: 'الرجاء إدخال عدد صحيح في هذا الحقل. أي رقم ذو كسر عشري أو مئوي (مثال 1.25 ) غير مسموح.',
	numeric: 'الرجاء إدخال قيم رقمية في هذا الحقل (مثال "1" أو "1.1" أو "-1" أو "-1.1").',
	digits: 'الرجاء أستخدام قيم رقمية وعلامات ترقيمية فقط في هذا الحقل (مثال, رقم هاتف مع نقطة أو شحطة)',
	alpha: 'الرجاء أستخدام أحرف فقط (ا-ي) في هذا الحقل. أي فراغات أو علامات غير مسموحة.',
	alphanum: 'الرجاء أستخدام أحرف فقط (ا-ي) أو أرقام (0-9) فقط في هذا الحقل. أي فراغات أو علامات غير مسموحة.',
	dateSuchAs: 'الرجاء إدخال تاريخ صحيح كالتالي {date}',
	dateInFormatMDY: 'الرجاء إدخال تاريخ صحيح (مثال, 31-12-1999)',
	email: 'الرجاء إدخال بريد إلكتروني صحيح.',
	url: 'الرجاء إدخال عنوان إلكتروني صحيح مثل http://www.example.com',
	currencyDollar: 'الرجاء إدخال قيمة $ صحيحة. مثال, 100.00$',
	oneRequired: 'الرجاء إدخال قيمة في أحد هذه الحقول على الأقل.',
	errorPrefix: 'خطأ: ',
	warningPrefix: 'تحذير: '

});

/*
---

name: Locale.ca-CA.Date

description: Date messages for Catalan.

license: MIT-style license

authors:
  - Ãlfons Sanchez

requires:
  - Locale

provides: [Locale.ca-CA.Date]

...
*/

Locale.define('ca-CA', 'Date', {

	months: ['Gener', 'Febrer', 'Març', 'Abril', 'Maig', 'Juny', 'Juli', 'Agost', 'Setembre', 'Octubre', 'Novembre', 'Desembre'],
	months_abbr: ['gen.', 'febr.', 'març', 'abr.', 'maig', 'juny', 'jul.', 'ag.', 'set.', 'oct.', 'nov.', 'des.'],
	days: ['Diumenge', 'Dilluns', 'Dimarts', 'Dimecres', 'Dijous', 'Divendres', 'Dissabte'],
	days_abbr: ['dg', 'dl', 'dt', 'dc', 'dj', 'dv', 'ds'],

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

	// Date.Extras
	ordinal: '',

	lessThanMinuteAgo: 'fa menys d`un minut',
	minuteAgo: 'fa un minut',
	minutesAgo: 'fa {delta} minuts',
	hourAgo: 'fa un hora',
	hoursAgo: 'fa unes {delta} hores',
	dayAgo: 'fa un dia',
	daysAgo: 'fa {delta} dies',

	lessThanMinuteUntil: 'menys d`un minut des d`ara',
	minuteUntil: 'un minut des d`ara',
	minutesUntil: '{delta} minuts des d`ara',
	hourUntil: 'un hora des d`ara',
	hoursUntil: 'unes {delta} hores des d`ara',
	dayUntil: '1 dia des d`ara',
	daysUntil: '{delta} dies des d`ara'

});

/*
---

name: Locale.ca-CA.Form.Validator

description: Form Validator messages for Catalan.

license: MIT-style license

authors:
  - Miquel Hudin
  - Ãlfons Sanchez

requires:
  - Locale

provides: [Locale.ca-CA.Form.Validator]

...
*/

Locale.define('ca-CA', 'FormValidator', {

	required: 'Aquest camp es obligatori.',
	minLength: 'Per favor introdueix al menys {minLength} caracters (has introduit {length} caracters).',
	maxLength: 'Per favor introdueix no mes de {maxLength} caracters (has introduit {length} caracters).',
	integer: 'Per favor introdueix un nombre enter en aquest camp. Nombres amb decimals (p.e. 1,25) no estan permesos.',
	numeric: 'Per favor introdueix sols valors numerics en aquest camp (p.e. "1" o "1,1" o "-1" o "-1,1").',
	digits: 'Per favor usa sols numeros i puntuacio en aquest camp (per exemple, un nombre de telefon amb guions i punts no esta permes).',
	alpha: 'Per favor utilitza lletres nomes (a-z) en aquest camp. No s´admiteixen espais ni altres caracters.',
	alphanum: 'Per favor, utilitza nomes lletres (a-z) o numeros (0-9) en aquest camp. No s´admiteixen espais ni altres caracters.',
	dateSuchAs: 'Per favor introdueix una data valida com {date}',
	dateInFormatMDY: 'Per favor introdueix una data valida com DD/MM/YYYY (p.e. "31/12/1999")',
	email: 'Per favor, introdueix una adreça de correu electronic valida. Per exemple, "fred@domain.com".',
	url: 'Per favor introdueix una URL valida com http://www.example.com.',
	currencyDollar: 'Per favor introdueix una quantitat valida de €. Per exemple €100,00 .',
	oneRequired: 'Per favor introdueix alguna cosa per al menys una d´aquestes entrades.',
	errorPrefix: 'Error: ',
	warningPrefix: 'Avis: ',

	// Form.Validator.Extras
	noSpace: 'No poden haver espais en aquesta entrada.',
	reqChkByNode: 'No hi han elements seleccionats.',
	requiredChk: 'Aquest camp es obligatori.',
	reqChkByName: 'Per favor selecciona una {label}.',
	match: 'Aquest camp necessita coincidir amb el camp {matchName}',
	startDate: 'la data de inici',
	endDate: 'la data de fi',
	currentDate: 'la data actual',
	afterDate: 'La data deu ser igual o posterior a {label}.',
	beforeDate: 'La data deu ser igual o anterior a {label}.',
	startMonth: 'Per favor selecciona un mes d´orige',
	sameMonth: 'Aquestes dos dates deuen estar dins del mateix mes - deus canviar una o altra.'

});

/*
---

name: Locale.cs-CZ.Date

description: Date messages for Czech.

license: MIT-style license

authors:
  - Jan Černý chemiX
  - Christopher Zukowski

requires:
  - Locale

provides: [Locale.cs-CZ.Date]

...
*/
(function(){

// Czech language pluralization rules, see http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html
// one -> n is 1;            1
// few -> n in 2..4;         2-4
// other -> everything else  0, 5-999, 1.31, 2.31, 5.31...
var pluralize = function(n, one, few, other){
	if (n == 1) return one;
	else if (n == 2 || n == 3 || n == 4) return few;
	else return other;
};

Locale.define('cs-CZ', 'Date', {

	months: ['Leden', 'Únor', 'Březen', 'Duben', 'Květen', 'Červen', 'Červenec', 'Srpen', 'Září', 'Říjen', 'Listopad', 'Prosinec'],
	months_abbr: ['ledna', 'února', 'března', 'dubna', 'května', 'června', 'července', 'srpna', 'září', 'října', 'listopadu', 'prosince'],
	days: ['Neděle', 'Pondělí', 'Úterý', 'Středa', 'Čtvrtek', 'Pátek', 'Sobota'],
	days_abbr: ['ne', 'po', 'út', 'st', 'čt', 'pá', 'so'],

	// Culture's date order: DD.MM.YYYY
	dateOrder: ['date', 'month', 'year'],
	shortDate: '%d.%m.%Y',
	shortTime: '%H:%M',
	AM: 'dop.',
	PM: 'odp.',
	firstDayOfWeek: 1,

	// Date.Extras
	ordinal: '.',

	lessThanMinuteAgo: 'před chvílí',
	minuteAgo: 'přibližně před minutou',
	minutesAgo: function(delta){ return 'před {delta} ' + pluralize(delta, 'minutou', 'minutami', 'minutami'); },
	hourAgo: 'přibližně před hodinou',
	hoursAgo: function(delta){ return 'před {delta} ' + pluralize(delta, 'hodinou', 'hodinami', 'hodinami'); },
	dayAgo: 'před dnem',
	daysAgo: function(delta){ return 'před {delta} ' + pluralize(delta, 'dnem', 'dny', 'dny'); },
	weekAgo: 'před týdnem',
	weeksAgo: function(delta){ return 'před {delta} ' + pluralize(delta, 'týdnem', 'týdny', 'týdny'); },
	monthAgo: 'před měsícem',
	monthsAgo: function(delta){ return 'před {delta} ' + pluralize(delta, 'měsícem', 'měsíci', 'měsíci'); },
	yearAgo: 'před rokem',
	yearsAgo: function(delta){ return 'před {delta} ' + pluralize(delta, 'rokem', 'lety', 'lety'); },

	lessThanMinuteUntil: 'za chvíli',
	minuteUntil: 'přibližně za minutu',
	minutesUntil: function(delta){ return 'za {delta} ' + pluralize(delta, 'minutu', 'minuty', 'minut'); },
	hourUntil: 'přibližně za hodinu',
	hoursUntil: function(delta){ return 'za {delta} ' + pluralize(delta, 'hodinu', 'hodiny', 'hodin'); },
	dayUntil: 'za den',
	daysUntil: function(delta){ return 'za {delta} ' + pluralize(delta, 'den', 'dny', 'dnů'); },
	weekUntil: 'za týden',
	weeksUntil: function(delta){ return 'za {delta} ' + pluralize(delta, 'týden', 'týdny', 'týdnů'); },
	monthUntil: 'za měsíc',
	monthsUntil: function(delta){ return 'za {delta} ' + pluralize(delta, 'měsíc', 'měsíce', 'měsíců'); },
	yearUntil: 'za rok',
	yearsUntil: function(delta){ return 'za {delta} ' + pluralize(delta, 'rok', 'roky', 'let'); }
});

})();

/*
---

name: Locale.cs-CZ.Form.Validator

description: Form Validator messages for Czech.

license: MIT-style license

authors:
  - Jan Černý chemiX

requires:
  - Locale

provides: [Locale.cs-CZ.Form.Validator]

...
*/

Locale.define('cs-CZ', 'FormValidator', {

	required: 'Tato položka je povinná.',
	minLength: 'Zadejte prosím alespoň {minLength} znaků (napsáno {length} znaků).',
	maxLength: 'Zadejte prosím méně než {maxLength} znaků (nápsáno {length} znaků).',
	integer: 'Zadejte prosím celé číslo. Desetinná čísla (např. 1.25) nejsou povolena.',
	numeric: 'Zadejte jen číselné hodnoty (tj. "1" nebo "1.1" nebo "-1" nebo "-1.1").',
	digits: 'Zadejte prosím pouze čísla a interpunkční znaménka(například telefonní číslo s pomlčkami nebo tečkami je povoleno).',
	alpha: 'Zadejte prosím pouze písmena (a-z). Mezery nebo jiné znaky nejsou povoleny.',
	alphanum: 'Zadejte prosím pouze písmena (a-z) nebo číslice (0-9). Mezery nebo jiné znaky nejsou povoleny.',
	dateSuchAs: 'Zadejte prosím platné datum jako {date}',
	dateInFormatMDY: 'Zadejte prosím platné datum jako MM / DD / RRRR (tj. "12/31/1999")',
	email: 'Zadejte prosím platnou e-mailovou adresu. Například "fred@domain.com".',
	url: 'Zadejte prosím platnou URL adresu jako http://www.example.com.',
	currencyDollar: 'Zadejte prosím platnou částku. Například $100.00.',
	oneRequired: 'Zadejte prosím alespoň jednu hodnotu pro tyto položky.',
	errorPrefix: 'Chyba: ',
	warningPrefix: 'Upozornění: ',

	// Form.Validator.Extras
	noSpace: 'V této položce nejsou povoleny mezery',
	reqChkByNode: 'Nejsou vybrány žádné položky.',
	requiredChk: 'Tato položka je vyžadována.',
	reqChkByName: 'Prosím vyberte {label}.',
	match: 'Tato položka se musí shodovat s položkou {matchName}',
	startDate: 'datum zahájení',
	endDate: 'datum ukončení',
	currentDate: 'aktuální datum',
	afterDate: 'Datum by mělo být stejné nebo větší než {label}.',
	beforeDate: 'Datum by mělo být stejné nebo menší než {label}.',
	startMonth: 'Vyberte počáteční měsíc.',
	sameMonth: 'Tyto dva datumy musí být ve stejném měsíci - změňte jeden z nich.',
	creditcard: 'Zadané číslo kreditní karty je neplatné. Prosím opravte ho. Bylo zadáno {length} čísel.'

});

/*
---

name: Locale.da-DK.Date

description: Date messages for Danish.

license: MIT-style license

authors:
  - Martin Overgaard
  - Henrik Hansen

requires:
  - Locale

provides: [Locale.da-DK.Date]

...
*/

Locale.define('da-DK', 'Date', {

	months: ['Januar', 'Februar', 'Marts', 'April', 'Maj', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'December'],
	months_abbr: ['jan.', 'feb.', 'mar.', 'apr.', 'maj.', 'jun.', 'jul.', 'aug.', 'sep.', 'okt.', 'nov.', 'dec.'],
	days: ['Søndag', 'Mandag', 'Tirsdag', 'Onsdag', 'Torsdag', 'Fredag', 'Lørdag'],
	days_abbr: ['søn', 'man', 'tir', 'ons', 'tor', 'fre', 'lør'],

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

	// Date.Extras
	ordinal: '.',

	lessThanMinuteAgo: 'mindre end et minut siden',
	minuteAgo: 'omkring et minut siden',
	minutesAgo: '{delta} minutter siden',
	hourAgo: 'omkring en time siden',
	hoursAgo: 'omkring {delta} timer siden',
	dayAgo: '1 dag siden',
	daysAgo: '{delta} dage siden',
	weekAgo: '1 uge siden',
	weeksAgo: '{delta} uger siden',
	monthAgo: '1 måned siden',
	monthsAgo: '{delta} måneder siden',
	yearAgo: '1 år siden',
	yearsAgo: '{delta} år siden',

	lessThanMinuteUntil: 'mindre end et minut fra nu',
	minuteUntil: 'omkring et minut fra nu',
	minutesUntil: '{delta} minutter fra nu',
	hourUntil: 'omkring en time fra nu',
	hoursUntil: 'omkring {delta} timer fra nu',
	dayUntil: '1 dag fra nu',
	daysUntil: '{delta} dage fra nu',
	weekUntil: '1 uge fra nu',
	weeksUntil: '{delta} uger fra nu',
	monthUntil: '1 måned fra nu',
	monthsUntil: '{delta} måneder fra nu',
	yearUntil: '1 år fra nu',
	yearsUntil: '{delta} år fra nu'

});

/*
---

name: Locale.da-DK.Form.Validator

description: Form Validator messages for Danish.

license: MIT-style license

authors:
  - Martin Overgaard

requires:
  - Locale

provides: [Locale.da-DK.Form.Validator]

...
*/

Locale.define('da-DK', 'FormValidator', {

	required: 'Feltet skal udfyldes.',
	minLength: 'Skriv mindst {minLength} tegn (du skrev {length} tegn).',
	maxLength: 'Skriv maksimalt {maxLength} tegn (du skrev {length} tegn).',
	integer: 'Skriv et tal i dette felt. Decimal tal (f.eks. 1.25) er ikke tilladt.',
	numeric: 'Skriv kun tal i dette felt (i.e. "1" eller "1.1" eller "-1" eller "-1.1").',
	digits: 'Skriv kun tal og tegnsætning i dette felt (eksempel, et telefon nummer med bindestreg eller punktum er tilladt).',
	alpha: 'Skriv kun bogstaver (a-z) i dette felt. Mellemrum og andre tegn er ikke tilladt.',
	alphanum: 'Skriv kun bogstaver (a-z) eller tal (0-9) i dette felt. Mellemrum og andre tegn er ikke tilladt.',
	dateSuchAs: 'Skriv en gyldig dato som {date}',
	dateInFormatMDY: 'Skriv dato i formatet DD-MM-YYYY (f.eks. "31-12-1999")',
	email: 'Skriv en gyldig e-mail adresse. F.eks "fred@domain.com".',
	url: 'Skriv en gyldig URL adresse. F.eks "http://www.example.com".',
	currencyDollar: 'Skriv et gldigt beløb. F.eks Kr.100.00 .',
	oneRequired: 'Et eller flere af felterne i denne formular skal udfyldes.',
	errorPrefix: 'Fejl: ',
	warningPrefix: 'Advarsel: ',

	// Form.Validator.Extras
	noSpace: 'Der må ikke benyttes mellemrum i dette felt.',
	reqChkByNode: 'Foretag et valg.',
	requiredChk: 'Dette felt skal udfyldes.',
	reqChkByName: 'Vælg en {label}.',
	match: 'Dette felt skal matche {matchName} feltet',
	startDate: 'start dato',
	endDate: 'slut dato',
	currentDate: 'dags dato',
	afterDate: 'Datoen skal være større end eller lig med {label}.',
	beforeDate: 'Datoen skal være mindre end eller lig med {label}.',
	startMonth: 'Vælg en start måned',
	sameMonth: 'De valgte datoer skal være i samme måned - skift en af dem.'

});

/*
---

name: Locale.de-DE.Date

description: Date messages for German.

license: MIT-style license

authors:
  - Christoph Pojer
  - Frank Rossi
  - Ulrich Petri
  - Fabian Beiner

requires:
  - Locale

provides: [Locale.de-DE.Date]

...
*/

Locale.define('de-DE', 'Date', {

	months: ['Januar', 'Februar', 'März', 'April', 'Mai', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'Dezember'],
	months_abbr: ['Jan', 'Feb', 'Mär', 'Apr', 'Mai', 'Jun', 'Jul', 'Aug', 'Sep', 'Okt', 'Nov', 'Dez'],
	days: ['Sonntag', 'Montag', 'Dienstag', 'Mittwoch', 'Donnerstag', 'Freitag', 'Samstag'],
	days_abbr: ['So', 'Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa'],

	// Culture's date order: DD.MM.YYYY
	dateOrder: ['date', 'month', 'year'],
	shortDate: '%d.%m.%Y',
	shortTime: '%H:%M',
	AM: 'vormittags',
	PM: 'nachmittags',
	firstDayOfWeek: 1,

	// Date.Extras
	ordinal: '.',

	lessThanMinuteAgo: 'vor weniger als einer Minute',
	minuteAgo: 'vor einer Minute',
	minutesAgo: 'vor {delta} Minuten',
	hourAgo: 'vor einer Stunde',
	hoursAgo: 'vor {delta} Stunden',
	dayAgo: 'vor einem Tag',
	daysAgo: 'vor {delta} Tagen',
	weekAgo: 'vor einer Woche',
	weeksAgo: 'vor {delta} Wochen',
	monthAgo: 'vor einem Monat',
	monthsAgo: 'vor {delta} Monaten',
	yearAgo: 'vor einem Jahr',
	yearsAgo: 'vor {delta} Jahren',

	lessThanMinuteUntil: 'in weniger als einer Minute',
	minuteUntil: 'in einer Minute',
	minutesUntil: 'in {delta} Minuten',
	hourUntil: 'in ca. einer Stunde',
	hoursUntil: 'in ca. {delta} Stunden',
	dayUntil: 'in einem Tag',
	daysUntil: 'in {delta} Tagen',
	weekUntil: 'in einer Woche',
	weeksUntil: 'in {delta} Wochen',
	monthUntil: 'in einem Monat',
	monthsUntil: 'in {delta} Monaten',
	yearUntil: 'in einem Jahr',
	yearsUntil: 'in {delta} Jahren'

});

/*
---

name: Locale.de-CH.Date

description: Date messages for German (Switzerland).

license: MIT-style license

authors:
  - Michael van der Weg

requires:
  - Locale
  - Locale.de-DE.Date

provides: [Locale.de-CH.Date]

...
*/

Locale.define('de-CH').inherit('de-DE', 'Date');

/*
---

name: Locale.de-CH.Form.Validator

description: Form Validator messages for German (Switzerland).

license: MIT-style license

authors:
  - Michael van der Weg

requires:
  - Locale

provides: [Locale.de-CH.Form.Validator]

...
*/

Locale.define('de-CH', 'FormValidator', {

	required: 'Dieses Feld ist obligatorisch.',
	minLength: 'Geben Sie bitte mindestens {minLength} Zeichen ein (Sie haben {length} Zeichen eingegeben).',
	maxLength: 'Bitte geben Sie nicht mehr als {maxLength} Zeichen ein (Sie haben {length} Zeichen eingegeben).',
	integer: 'Geben Sie bitte eine ganze Zahl ein. Dezimalzahlen (z.B. 1.25) sind nicht erlaubt.',
	numeric: 'Geben Sie bitte nur Zahlenwerte in dieses Eingabefeld ein (z.B. &quot;1&quot;, &quot;1.1&quot;, &quot;-1&quot; oder &quot;-1.1&quot;).',
	digits: 'Benutzen Sie bitte nur Zahlen und Satzzeichen in diesem Eingabefeld (erlaubt ist z.B. eine Telefonnummer mit Bindestrichen und Punkten).',
	alpha: 'Benutzen Sie bitte nur Buchstaben (a-z) in diesem Feld. Leerzeichen und andere Zeichen sind nicht erlaubt.',
	alphanum: 'Benutzen Sie bitte nur Buchstaben (a-z) und Zahlen (0-9) in diesem Eingabefeld. Leerzeichen und andere Zeichen sind nicht erlaubt.',
	dateSuchAs: 'Geben Sie bitte ein g&uuml;ltiges Datum ein. Wie zum Beispiel {date}',
	dateInFormatMDY: 'Geben Sie bitte ein g&uuml;ltiges Datum ein. Wie zum Beispiel TT.MM.JJJJ (z.B. &quot;31.12.1999&quot;)',
	email: 'Geben Sie bitte eine g&uuml;ltige E-Mail Adresse ein. Wie zum Beispiel &quot;maria@bernasconi.ch&quot;.',
	url: 'Geben Sie bitte eine g&uuml;ltige URL ein. Wie zum Beispiel http://www.example.com.',
	currencyDollar: 'Geben Sie bitte einen g&uuml;ltigen Betrag in Schweizer Franken ein. Wie zum Beispiel 100.00 CHF .',
	oneRequired: 'Machen Sie f&uuml;r mindestens eines der Eingabefelder einen Eintrag.',
	errorPrefix: 'Fehler: ',
	warningPrefix: 'Warnung: ',

	// Form.Validator.Extras
	noSpace: 'In diesem Eingabefeld darf kein Leerzeichen sein.',
	reqChkByNode: 'Es wurden keine Elemente gew&auml;hlt.',
	requiredChk: 'Dieses Feld ist obligatorisch.',
	reqChkByName: 'Bitte w&auml;hlen Sie ein {label}.',
	match: 'Dieses Eingabefeld muss mit dem Feld {matchName} &uuml;bereinstimmen.',
	startDate: 'Das Anfangsdatum',
	endDate: 'Das Enddatum',
	currentDate: 'Das aktuelle Datum',
	afterDate: 'Das Datum sollte zur gleichen Zeit oder sp&auml;ter sein {label}.',
	beforeDate: 'Das Datum sollte zur gleichen Zeit oder fr&uuml;her sein {label}.',
	startMonth: 'W&auml;hlen Sie bitte einen Anfangsmonat',
	sameMonth: 'Diese zwei Datumsangaben m&uuml;ssen im selben Monat sein - Sie m&uuml;ssen eine von beiden ver&auml;ndern.',
	creditcard: 'Die eingegebene Kreditkartennummer ist ung&uuml;ltig. Bitte &uuml;berpr&uuml;fen Sie diese und versuchen Sie es erneut. {length} Zahlen eingegeben.'

});

/*
---
name: Locale.de-CH.Number
description: Number messages for Switzerland.
license: MIT-style license
authors:
  - Kim D. Jeker
requires:
  - Locale
  - Locale.CH.Number
provides: [Locale.de-CH.Number]
...
*/

Locale.define('de-CH').inherit('CH', 'Number');

/*
---

name: Locale.de-DE.Form.Validator

description: Form Validator messages for German.

license: MIT-style license

authors:
  - Frank Rossi
  - Ulrich Petri
  - Fabian Beiner

requires:
  - Locale

provides: [Locale.de-DE.Form.Validator]

...
*/

Locale.define('de-DE', 'FormValidator', {

	required: 'Dieses Eingabefeld muss ausgefüllt werden.',
	minLength: 'Geben Sie bitte mindestens {minLength} Zeichen ein (Sie haben nur {length} Zeichen eingegeben).',
	maxLength: 'Geben Sie bitte nicht mehr als {maxLength} Zeichen ein (Sie haben {length} Zeichen eingegeben).',
	integer: 'Geben Sie in diesem Eingabefeld bitte eine ganze Zahl ein. Dezimalzahlen (z.B. "1.25") sind nicht erlaubt.',
	numeric: 'Geben Sie in diesem Eingabefeld bitte nur Zahlenwerte (z.B. "1", "1.1", "-1" oder "-1.1") ein.',
	digits: 'Geben Sie in diesem Eingabefeld bitte nur Zahlen und Satzzeichen ein (z.B. eine Telefonnummer mit Bindestrichen und Punkten ist erlaubt).',
	alpha: 'Geben Sie in diesem Eingabefeld bitte nur Buchstaben (a-z) ein. Leerzeichen und andere Zeichen sind nicht erlaubt.',
	alphanum: 'Geben Sie in diesem Eingabefeld bitte nur Buchstaben (a-z) und Zahlen (0-9) ein. Leerzeichen oder andere Zeichen sind nicht erlaubt.',
	dateSuchAs: 'Geben Sie bitte ein gültiges Datum ein (z.B. "{date}").',
	dateInFormatMDY: 'Geben Sie bitte ein gültiges Datum im Format TT.MM.JJJJ ein (z.B. "31.12.1999").',
	email: 'Geben Sie bitte eine gültige E-Mail-Adresse ein (z.B. "max@mustermann.de").',
	url: 'Geben Sie bitte eine gültige URL ein (z.B. "http://www.example.com").',
	currencyDollar: 'Geben Sie bitte einen gültigen Betrag in EURO ein (z.B. 100.00€).',
	oneRequired: 'Bitte füllen Sie mindestens ein Eingabefeld aus.',
	errorPrefix: 'Fehler: ',
	warningPrefix: 'Warnung: ',

	// Form.Validator.Extras
	noSpace: 'Es darf kein Leerzeichen in diesem Eingabefeld sein.',
	reqChkByNode: 'Es wurden keine Elemente gewählt.',
	requiredChk: 'Dieses Feld muss ausgefüllt werden.',
	reqChkByName: 'Bitte wählen Sie ein {label}.',
	match: 'Dieses Eingabefeld muss mit dem {matchName} Eingabefeld übereinstimmen.',
	startDate: 'Das Anfangsdatum',
	endDate: 'Das Enddatum',
	currentDate: 'Das aktuelle Datum',
	afterDate: 'Das Datum sollte zur gleichen Zeit oder später sein als {label}.',
	beforeDate: 'Das Datum sollte zur gleichen Zeit oder früher sein als {label}.',
	startMonth: 'Wählen Sie bitte einen Anfangsmonat',
	sameMonth: 'Diese zwei Datumsangaben müssen im selben Monat sein - Sie müssen eines von beiden verändern.',
	creditcard: 'Die eingegebene Kreditkartennummer ist ungültig. Bitte überprüfen Sie diese und versuchen Sie es erneut. {length} Zahlen eingegeben.'

});

/*
---

name: Locale.de-DE.Number

description: Number messages for German.

license: MIT-style license

authors:
  - Christoph Pojer

requires:
  - Locale
  - Locale.EU.Number

provides: [Locale.de-DE.Number]

...
*/

Locale.define('de-DE').inherit('EU', 'Number');

/*
---

name: Locale.el-GR.Date

description: Date messages for Greek language.

license: MIT-style license

authors:
  - Periklis Argiriadis

requires:
  - Locale

provides: [Locale.el-GR.Date]

...
*/

Locale.define('el-GR', 'Date', {

	months: ['Ιανουάριος', 'Φεβρουάριος', 'Μάρτιος', 'Απρίλιος', 'Μάιος', 'Ιούνιος', 'Ιούλιος', 'Αύγουστος', 'Σεπτέμβριος', 'Οκτώβριος', 'Νοέμβριος', 'Δεκέμβριος'],
	months_abbr: ['Ιαν', 'Φεβ', 'Μαρ', 'Απρ', 'Μάι', 'Ιουν', 'Ιουλ', 'Αυγ', 'Σεπ', 'Οκτ', 'Νοε', 'Δεκ'],
	days: ['Κυριακή', 'Δευτέρα', 'Τρίτη', 'Τετάρτη', 'Πέμπτη', 'Παρασκευή', 'Σάββατο'],
	days_abbr: ['Κυρ', 'Δευ', 'Τρι', 'Τετ', 'Πεμ', 'Παρ', 'Σαβ'],

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

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

	lessThanMinuteAgo: 'λιγότερο από ένα λεπτό πριν',
	minuteAgo: 'περίπου ένα λεπτό πριν',
	minutesAgo: '{delta} λεπτά πριν',
	hourAgo: 'περίπου μια ώρα πριν',
	hoursAgo: 'περίπου {delta} ώρες πριν',
	dayAgo: '1 ημέρα πριν',
	daysAgo: '{delta} ημέρες πριν',
	weekAgo: '1 εβδομάδα πριν',
	weeksAgo: '{delta} εβδομάδες πριν',
	monthAgo: '1 μήνα πριν',
	monthsAgo: '{delta} μήνες πριν',
	yearAgo: '1 χρόνο πριν',
	yearsAgo: '{delta} χρόνια πριν',

	lessThanMinuteUntil: 'λιγότερο από λεπτό από τώρα',
	minuteUntil: 'περίπου ένα λεπτό από τώρα',
	minutesUntil: '{delta} λεπτά από τώρα',
	hourUntil: 'περίπου μια ώρα από τώρα',
	hoursUntil: 'περίπου {delta} ώρες από τώρα',
	dayUntil: '1 ημέρα από τώρα',
	daysUntil: '{delta} ημέρες από τώρα',
	weekUntil: '1 εβδομάδα από τώρα',
	weeksUntil: '{delta} εβδομάδες από τώρα',
	monthUntil: '1 μήνας από τώρα',
	monthsUntil: '{delta} μήνες από τώρα',
	yearUntil: '1 χρόνος από τώρα',
	yearsUntil: '{delta} χρόνια από τώρα'

});

/*
---

name: Locale.el-GR.Form.Validator

description: Form Validator messages for Greek language.

license: MIT-style license

authors:
  - Dimitris Tsironis

requires:
  - Locale

provides: [Locale.el-GR.Form.Validator]

...
*/

Locale.define('el-GR', 'FormValidator', {

	required: 'Αυτό το πεδίο είναι απαραίτητο.',
	length: 'Παρακαλούμε, εισάγετε {length} χαρακτήρες (έχετε ήδη εισάγει {elLength} χαρακτήρες).',
	minLength: 'Παρακαλούμε, εισάγετε τουλάχιστον {minLength} χαρακτήρες (έχετε ήδη εισάγε {length} χαρακτήρες).',
	maxlength: 'Παρακαλούμε, εισάγετε εώς {maxlength} χαρακτήρες (έχετε ήδη εισάγε {length} χαρακτήρες).',
	integer: 'Παρακαλούμε, εισάγετε έναν ακέραιο αριθμό σε αυτό το πεδίο. Οι αριθμοί με δεκαδικά ψηφία (π.χ. 1.25) δεν επιτρέπονται.',
	numeric: 'Παρακαλούμε, εισάγετε μόνο αριθμητικές τιμές σε αυτό το πεδίο (π.χ." 1 " ή " 1.1 " ή " -1 " ή " -1.1 " ).',
	digits: 'Παρακαλούμε, χρησιμοποιήστε μόνο αριθμούς και σημεία στίξης σε αυτόν τον τομέα (π.χ. επιτρέπεται αριθμός τηλεφώνου με παύλες ή τελείες).',
	alpha: 'Παρακαλούμε, χρησιμοποιήστε μόνο γράμματα (a-z) σε αυτό το πεδίο. Δεν επιτρέπονται κενά ή άλλοι χαρακτήρες.',
	alphanum: 'Παρακαλούμε, χρησιμοποιήστε μόνο γράμματα (a-z) ή αριθμούς (0-9) σε αυτόν τον τομέα. Δεν επιτρέπονται κενά ή άλλοι χαρακτήρες.',
	dateSuchAs: 'Παρακαλούμε, εισάγετε μια έγκυρη ημερομηνία, όπως {date}',
	dateInFormatMDY: 'Παρακαλώ εισάγετε μια έγκυρη ημερομηνία, όπως ΜΜ/ΗΗ/ΕΕΕΕ (π.χ. "12/31/1999").',
	email: 'Παρακαλούμε, εισάγετε μια έγκυρη διεύθυνση ηλεκτρονικού ταχυδρομείου (π.χ. "fred@domain.com").',
	url: 'Παρακαλούμε, εισάγετε μια έγκυρη URL διεύθυνση, όπως http://www.example.com',
	currencyDollar: 'Παρακαλούμε, εισάγετε ένα έγκυρο ποσό σε δολλάρια (π.χ. $100.00).',
	oneRequired: 'Παρακαλούμε, εισάγετε κάτι για τουλάχιστον ένα από αυτά τα πεδία.',
	errorPrefix: 'Σφάλμα: ',
	warningPrefix: 'Προσοχή: ',

	// Form.Validator.Extras
	noSpace: 'Δεν επιτρέπονται τα κενά σε αυτό το πεδίο.',
	reqChkByNode: 'Δεν έχει επιλεγεί κάποιο αντικείμενο',
	requiredChk: 'Αυτό το πεδίο είναι απαραίτητο.',
	reqChkByName: 'Παρακαλούμε, επιλέξτε μια ετικέτα {label}.',
	match: 'Αυτό το πεδίο πρέπει να ταιριάζει με το πεδίο {matchName}.',
	startDate: 'η ημερομηνία έναρξης',
	endDate: 'η ημερομηνία λήξης',
	currentDate: 'η τρέχουσα ημερομηνία',
	afterDate: 'Η ημερομηνία πρέπει να είναι η ίδια ή μετά από την {label}.',
	beforeDate: 'Η ημερομηνία πρέπει να είναι η ίδια ή πριν από την {label}.',
	startMonth: 'Παρακαλώ επιλέξτε ένα μήνα αρχής.',
	sameMonth: 'Αυτές οι δύο ημερομηνίες πρέπει να έχουν τον ίδιο μήνα - θα πρέπει να αλλάξετε ή το ένα ή το άλλο',
	creditcard: 'Ο αριθμός της πιστωτικής κάρτας δεν είναι έγκυρος. Παρακαλούμε ελέγξτε τον αριθμό και δοκιμάστε ξανά. {length} μήκος ψηφίων.'

});

/*
---

name: Locale.en-GB.Date

description: Date messages for British English.

license: MIT-style license

authors:
  - Aaron Newton

requires:
  - Locale
  - Locale.en-US.Date

provides: [Locale.en-GB.Date]

...
*/

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

	// Culture's date order: DD/MM/YYYY
	dateOrder: ['date', 'month', 'year'],
	shortDate: '%d/%m/%Y',
	shortTime: '%H:%M'

}).inherit('en-US', 'Date');

/*
---

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: Locale.es-ES.Date

description: Date messages for Spanish.

license: MIT-style license

authors:
  - Ãlfons Sanchez

requires:
  - Locale

provides: [Locale.es-ES.Date]

...
*/

Locale.define('es-ES', 'Date', {

	months: ['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre'],
	months_abbr: ['ene', 'feb', 'mar', 'abr', 'may', 'jun', 'jul', 'ago', 'sep', 'oct', 'nov', 'dic'],
	days: ['Domingo', 'Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado'],
	days_abbr: ['dom', 'lun', 'mar', 'mié', 'juv', 'vie', 'sáb'],

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

	// Date.Extras
	ordinal: '',

	lessThanMinuteAgo: 'hace menos de un minuto',
	minuteAgo: 'hace un minuto',
	minutesAgo: 'hace {delta} minutos',
	hourAgo: 'hace una hora',
	hoursAgo: 'hace unas {delta} horas',
	dayAgo: 'hace un día',
	daysAgo: 'hace {delta} días',
	weekAgo: 'hace una semana',
	weeksAgo: 'hace unas {delta} semanas',
	monthAgo: 'hace un mes',
	monthsAgo: 'hace {delta} meses',
	yearAgo: 'hace un año',
	yearsAgo: 'hace {delta} años',

	lessThanMinuteUntil: 'menos de un minuto desde ahora',
	minuteUntil: 'un minuto desde ahora',
	minutesUntil: '{delta} minutos desde ahora',
	hourUntil: 'una hora desde ahora',
	hoursUntil: 'unas {delta} horas desde ahora',
	dayUntil: 'un día desde ahora',
	daysUntil: '{delta} días desde ahora',
	weekUntil: 'una semana desde ahora',
	weeksUntil: 'unas {delta} semanas desde ahora',
	monthUntil: 'un mes desde ahora',
	monthsUntil: '{delta} meses desde ahora',
	yearUntil: 'un año desde ahora',
	yearsUntil: '{delta} años desde ahora'

});

/*
---

name: Locale.es-AR.Date

description: Date messages for Spanish (Argentina).

license: MIT-style license

authors:
  - Ãlfons Sanchez
  - Diego Massanti

requires:
  - Locale
  - Locale.es-ES.Date

provides: [Locale.es-AR.Date]

...
*/

Locale.define('es-AR').inherit('es-ES', 'Date');

/*
---

name: Locale.es-AR.Form.Validator

description: Form Validator messages for Spanish (Argentina).

license: MIT-style license

authors:
  - Diego Massanti

requires:
  - Locale

provides: [Locale.es-AR.Form.Validator]

...
*/

Locale.define('es-AR', 'FormValidator', {

	required: 'Este campo es obligatorio.',
	minLength: 'Por favor ingrese al menos {minLength} caracteres (ha ingresado {length} caracteres).',
	maxLength: 'Por favor no ingrese más de {maxLength} caracteres (ha ingresado {length} caracteres).',
	integer: 'Por favor ingrese un número entero en este campo. Números con decimales (p.e. 1,25) no se permiten.',
	numeric: 'Por favor ingrese solo valores numéricos en este campo (p.e. "1" o "1,1" o "-1" o "-1,1").',
	digits: 'Por favor use sólo números y puntuación en este campo (por ejemplo, un número de teléfono con guiones y/o puntos no está permitido).',
	alpha: 'Por favor use sólo letras (a-z) en este campo. No se permiten espacios ni otros caracteres.',
	alphanum: 'Por favor, usa sólo letras (a-z) o números (0-9) en este campo. No se permiten espacios u otros caracteres.',
	dateSuchAs: 'Por favor ingrese una fecha válida como {date}',
	dateInFormatMDY: 'Por favor ingrese una fecha válida, utulizando el formato DD/MM/YYYY (p.e. "31/12/1999")',
	email: 'Por favor, ingrese una dirección de e-mail válida. Por ejemplo, "fred@dominio.com".',
	url: 'Por favor ingrese una URL válida como http://www.example.com.',
	currencyDollar: 'Por favor ingrese una cantidad válida de pesos. Por ejemplo $100,00 .',
	oneRequired: 'Por favor ingrese algo para por lo menos una de estas entradas.',
	errorPrefix: 'Error: ',
	warningPrefix: 'Advertencia: ',

	// Form.Validator.Extras
	noSpace: 'No se permiten espacios en este campo.',
	reqChkByNode: 'No hay elementos seleccionados.',
	requiredChk: 'Este campo es obligatorio.',
	reqChkByName: 'Por favor selecciona una {label}.',
	match: 'Este campo necesita coincidir con el campo {matchName}',
	startDate: 'la fecha de inicio',
	endDate: 'la fecha de fin',
	currentDate: 'la fecha actual',
	afterDate: 'La fecha debe ser igual o posterior a {label}.',
	beforeDate: 'La fecha debe ser igual o anterior a {label}.',
	startMonth: 'Por favor selecciona un mes de origen',
	sameMonth: 'Estas dos fechas deben estar en el mismo mes - debes cambiar una u otra.'

});

/*
---

name: Locale.es-AR.Number

description: Number messages for es Argentina.

license: MIT-style license

authors:
  - Oscar Kuchuk

requires:
  - Locale

provides: [Locale.es-AR.Number]

...
*/

Locale.define('es-AR', '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: Locale.es-ES.Form.Validator

description: Form Validator messages for Spanish.

license: MIT-style license

authors:
  - Ãlfons Sanchez

requires:
  - Locale

provides: [Locale.es-ES.Form.Validator]

...
*/

Locale.define('es-ES', 'FormValidator', {

	required: 'Este campo es obligatorio.',
	minLength: 'Por favor introduce al menos {minLength} caracteres (has introducido {length} caracteres).',
	maxLength: 'Por favor introduce no m&aacute;s de {maxLength} caracteres (has introducido {length} caracteres).',
	integer: 'Por favor introduce un n&uacute;mero entero en este campo. N&uacute;meros con decimales (p.e. 1,25) no se permiten.',
	numeric: 'Por favor introduce solo valores num&eacute;ricos en este campo (p.e. "1" o "1,1" o "-1" o "-1,1").',
	digits: 'Por favor usa solo n&uacute;meros y puntuaci&oacute;n en este campo (por ejemplo, un n&uacute;mero de tel&eacute;fono con guiones y puntos no esta permitido).',
	alpha: 'Por favor usa letras solo (a-z) en este campo. No se admiten espacios ni otros caracteres.',
	alphanum: 'Por favor, usa solo letras (a-z) o n&uacute;meros (0-9) en este campo. No se admiten espacios ni otros caracteres.',
	dateSuchAs: 'Por favor introduce una fecha v&aacute;lida como {date}',
	dateInFormatMDY: 'Por favor introduce una fecha v&aacute;lida como DD/MM/YYYY (p.e. "31/12/1999")',
	email: 'Por favor, introduce una direcci&oacute;n de email v&aacute;lida. Por ejemplo, "fred@domain.com".',
	url: 'Por favor introduce una URL v&aacute;lida como http://www.example.com.',
	currencyDollar: 'Por favor introduce una cantidad v&aacute;lida de €. Por ejemplo €100,00 .',
	oneRequired: 'Por favor introduce algo para por lo menos una de estas entradas.',
	errorPrefix: 'Error: ',
	warningPrefix: 'Aviso: ',

	// Form.Validator.Extras
	noSpace: 'No pueden haber espacios en esta entrada.',
	reqChkByNode: 'No hay elementos seleccionados.',
	requiredChk: 'Este campo es obligatorio.',
	reqChkByName: 'Por favor selecciona una {label}.',
	match: 'Este campo necesita coincidir con el campo {matchName}',
	startDate: 'la fecha de inicio',
	endDate: 'la fecha de fin',
	currentDate: 'la fecha actual',
	afterDate: 'La fecha debe ser igual o posterior a {label}.',
	beforeDate: 'La fecha debe ser igual o anterior a {label}.',
	startMonth: 'Por favor selecciona un mes de origen',
	sameMonth: 'Estas dos fechas deben estar en el mismo mes - debes cambiar una u otra.'

});

/*
---

name: Locale.es-VE.Date

description: Date messages for Spanish (Venezuela).

license: MIT-style license

authors:
  - Daniel Barreto

requires:
  - Locale
  - Locale.es-ES.Date

provides: [Locale.es-VE.Date]

...
*/

Locale.define('es-VE').inherit('es-ES', 'Date');

/*
---

name: Locale.es-VE.Form.Validator

description: Form Validator messages for Spanish (Venezuela).

license: MIT-style license

authors:
  - Daniel Barreto

requires:
  - Locale
  - Locale.es-ES.Form.Validator

provides: [Locale.es-VE.Form.Validator]

...
*/

Locale.define('es-VE', 'FormValidator', {

	digits: 'Por favor usa solo n&uacute;meros y puntuaci&oacute;n en este campo. Por ejemplo, un n&uacute;mero de tel&eacute;fono con guiones y puntos no esta permitido.',
	alpha: 'Por favor usa solo letras (a-z) en este campo. No se admiten espacios ni otros caracteres.',
	currencyDollar: 'Por favor introduce una cantidad v&aacute;lida de Bs. Por ejemplo Bs. 100,00 .',
	oneRequired: 'Por favor introduce un valor para por lo menos una de estas entradas.',

	// Form.Validator.Extras
	startDate: 'La fecha de inicio',
	endDate: 'La fecha de fin',
	currentDate: 'La fecha actual'

}).inherit('es-ES', 'FormValidator');

/*
---

name: Locale.es-VE.Number

description: Number messages for Spanish (Venezuela).

license: MIT-style license

authors:
  - Daniel Barreto

requires:
  - Locale

provides: [Locale.es-VE.Number]

...
*/

Locale.define('es-VE', 'Number', {

	decimal: ',',
	group: '.',
/*
	decimals: 0,
	precision: 0,
*/
	// Negative/Currency/percentage will mixin Number
	negative: {
		prefix: '-'
	},

	currency: {
		decimals: 2,
		prefix: 'Bs. '
	},

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

});

/*
---

name: Locale.et-EE.Date

description: Date messages for Estonian.

license: MIT-style license

authors:
  - Kevin Valdek

requires:
  - Locale

provides: [Locale.et-EE.Date]

...
*/

Locale.define('et-EE', 'Date', {

	months: ['jaanuar', 'veebruar', 'märts', 'aprill', 'mai', 'juuni', 'juuli', 'august', 'september', 'oktoober', 'november', 'detsember'],
	months_abbr: ['jaan', 'veebr', 'märts', 'apr', 'mai', 'juuni', 'juuli', 'aug', 'sept', 'okt', 'nov', 'dets'],
	days: ['pühapäev', 'esmaspäev', 'teisipäev', 'kolmapäev', 'neljapäev', 'reede', 'laupäev'],
	days_abbr: ['pühap', 'esmasp', 'teisip', 'kolmap', 'neljap', 'reede', 'laup'],

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

	// Date.Extras
	ordinal: '',

	lessThanMinuteAgo: 'vähem kui minut aega tagasi',
	minuteAgo: 'umbes minut aega tagasi',
	minutesAgo: '{delta} minutit tagasi',
	hourAgo: 'umbes tund aega tagasi',
	hoursAgo: 'umbes {delta} tundi tagasi',
	dayAgo: '1 päev tagasi',
	daysAgo: '{delta} päeva tagasi',
	weekAgo: '1 nädal tagasi',
	weeksAgo: '{delta} nädalat tagasi',
	monthAgo: '1 kuu tagasi',
	monthsAgo: '{delta} kuud tagasi',
	yearAgo: '1 aasta tagasi',
	yearsAgo: '{delta} aastat tagasi',

	lessThanMinuteUntil: 'vähem kui minuti aja pärast',
	minuteUntil: 'umbes minuti aja pärast',
	minutesUntil: '{delta} minuti pärast',
	hourUntil: 'umbes tunni aja pärast',
	hoursUntil: 'umbes {delta} tunni pärast',
	dayUntil: '1 päeva pärast',
	daysUntil: '{delta} päeva pärast',
	weekUntil: '1 nädala pärast',
	weeksUntil: '{delta} nädala pärast',
	monthUntil: '1 kuu pärast',
	monthsUntil: '{delta} kuu pärast',
	yearUntil: '1 aasta pärast',
	yearsUntil: '{delta} aasta pärast'

});

/*
---

name: Locale.et-EE.Form.Validator

description: Form Validator messages for Estonian.

license: MIT-style license

authors:
  - Kevin Valdek

requires:
  - Locale

provides: [Locale.et-EE.Form.Validator]

...
*/

Locale.define('et-EE', 'FormValidator', {

	required: 'Väli peab olema täidetud.',
	minLength: 'Palun sisestage vähemalt {minLength} tähte (te sisestasite {length} tähte).',
	maxLength: 'Palun ärge sisestage rohkem kui {maxLength} tähte (te sisestasite {length} tähte).',
	integer: 'Palun sisestage väljale täisarv. Kümnendarvud (näiteks 1.25) ei ole lubatud.',
	numeric: 'Palun sisestage ainult numbreid väljale (näiteks "1", "1.1", "-1" või "-1.1").',
	digits: 'Palun kasutage ainult numbreid ja kirjavahemärke (telefoninumbri sisestamisel on lubatud kasutada kriipse ja punkte).',
	alpha: 'Palun kasutage ainult tähti (a-z). Tühikud ja teised sümbolid on keelatud.',
	alphanum: 'Palun kasutage ainult tähti (a-z) või numbreid (0-9). Tühikud ja teised sümbolid on keelatud.',
	dateSuchAs: 'Palun sisestage kehtiv kuupäev kujul {date}',
	dateInFormatMDY: 'Palun sisestage kehtiv kuupäev kujul MM.DD.YYYY (näiteks: "12.31.1999").',
	email: 'Palun sisestage kehtiv e-maili aadress (näiteks: "fred@domain.com").',
	url: 'Palun sisestage kehtiv URL (näiteks: http://www.example.com).',
	currencyDollar: 'Palun sisestage kehtiv $ summa (näiteks: $100.00).',
	oneRequired: 'Palun sisestage midagi vähemalt ühele antud väljadest.',
	errorPrefix: 'Viga: ',
	warningPrefix: 'Hoiatus: ',

	// Form.Validator.Extras
	noSpace: 'Väli ei tohi sisaldada tühikuid.',
	reqChkByNode: 'Ükski väljadest pole valitud.',
	requiredChk: 'Välja täitmine on vajalik.',
	reqChkByName: 'Palun valige üks {label}.',
	match: 'Väli peab sobima {matchName} väljaga',
	startDate: 'algkuupäev',
	endDate: 'lõppkuupäev',
	currentDate: 'praegune kuupäev',
	afterDate: 'Kuupäev peab olema võrdne või pärast {label}.',
	beforeDate: 'Kuupäev peab olema võrdne või enne {label}.',
	startMonth: 'Palun valige algkuupäev.',
	sameMonth: 'Antud kaks kuupäeva peavad olema samas kuus - peate muutma ühte kuupäeva.'

});

/*
---

name: Locale.fa.Date

description: Date messages for Persian.

license: MIT-style license

authors:
  - Amir Hossein Hodjaty Pour

requires:
  - Locale

provides: [Locale.fa.Date]

...
*/

Locale.define('fa', 'Date', {

	months: ['ژانویه', 'فوریه', 'مارس', 'آپریل', 'مه', 'ژوئن', 'ژوئیه', 'آگوست', 'سپتامبر', 'اکتبر', 'نوامبر', 'دسامبر'],
	months_abbr: ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12'],
	days: ['یکشنبه', 'دوشنبه', 'سه شنبه', 'چهارشنبه', 'پنجشنبه', 'جمعه', 'شنبه'],
	days_abbr: ['ي', 'د', 'س', 'چ', 'پ', 'ج', 'ش'],

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

	// Date.Extras
	ordinal: 'ام',

	lessThanMinuteAgo: 'کمتر از یک دقیقه پیش',
	minuteAgo: 'حدود یک دقیقه پیش',
	minutesAgo: '{delta} دقیقه پیش',
	hourAgo: 'حدود یک ساعت پیش',
	hoursAgo: 'حدود {delta} ساعت پیش',
	dayAgo: '1 روز پیش',
	daysAgo: '{delta} روز پیش',
	weekAgo: '1 هفته پیش',
	weeksAgo: '{delta} هفته پیش',
	monthAgo: '1 ماه پیش',
	monthsAgo: '{delta} ماه پیش',
	yearAgo: '1 سال پیش',
	yearsAgo: '{delta} سال پیش',

	lessThanMinuteUntil: 'کمتر از یک دقیقه از حالا',
	minuteUntil: 'حدود یک دقیقه از حالا',
	minutesUntil: '{delta} دقیقه از حالا',
	hourUntil: 'حدود یک ساعت از حالا',
	hoursUntil: 'حدود {delta} ساعت از حالا',
	dayUntil: '1 روز از حالا',
	daysUntil: '{delta} روز از حالا',
	weekUntil: '1 هفته از حالا',
	weeksUntil: '{delta} هفته از حالا',
	monthUntil: '1 ماه از حالا',
	monthsUntil: '{delta} ماه از حالا',
	yearUntil: '1 سال از حالا',
	yearsUntil: '{delta} سال از حالا'

});

/*
---

name: Locale.fa.Form.Validator

description: Form Validator messages for Persian.

license: MIT-style license

authors:
  - Amir Hossein Hodjaty Pour

requires:
  - Locale

provides: [Locale.fa.Form.Validator]

...
*/

Locale.define('fa', 'FormValidator', {

	required: 'این فیلد الزامی است.',
	minLength: 'شما باید حداقل {minLength} حرف وارد کنید ({length} حرف وارد کرده اید).',
	maxLength: 'لطفا حداکثر {maxLength} حرف وارد کنید (شما {length} حرف وارد کرده اید).',
	integer: 'لطفا از عدد صحیح استفاده کنید. اعداد اعشاری (مانند 1.25) مجاز نیستند.',
	numeric: 'لطفا فقط داده عددی وارد کنید (مانند "1" یا "1.1" یا "1-" یا "1.1-").',
	digits: 'لطفا فقط از اعداد و علامتها در این فیلد استفاده کنید (برای مثال شماره تلفن با خط تیره و نقطه قابل قبول است).',
	alpha: 'لطفا فقط از حروف الفباء برای این بخش استفاده کنید. کاراکترهای دیگر و فاصله مجاز نیستند.',
	alphanum: 'لطفا فقط از حروف الفباء و اعداد در این بخش استفاده کنید. کاراکترهای دیگر و فاصله مجاز نیستند.',
	dateSuchAs: 'لطفا یک تاریخ معتبر مانند {date} وارد کنید.',
	dateInFormatMDY: 'لطفا یک تاریخ معتبر به شکل MM/DD/YYYY وارد کنید (مانند "12/31/1999").',
	email: 'لطفا یک آدرس ایمیل معتبر وارد کنید. برای مثال "fred@domain.com".',
	url: 'لطفا یک URL معتبر مانند http://www.example.com وارد کنید.',
	currencyDollar: 'لطفا یک محدوده معتبر برای این بخش وارد کنید مانند 100.00$ .',
	oneRequired: 'لطفا حداقل یکی از فیلدها را پر کنید.',
	errorPrefix: 'خطا: ',
	warningPrefix: 'هشدار: ',

	// Form.Validator.Extras
	noSpace: 'استفاده از فاصله در این بخش مجاز نیست.',
	reqChkByNode: 'موردی انتخاب نشده است.',
	requiredChk: 'این فیلد الزامی است.',
	reqChkByName: 'لطفا یک {label} را انتخاب کنید.',
	match: 'این فیلد باید با فیلد {matchName} مطابقت داشته باشد.',
	startDate: 'تاریخ شروع',
	endDate: 'تاریخ پایان',
	currentDate: 'تاریخ کنونی',
	afterDate: 'تاریخ میبایست برابر یا بعد از {label} باشد',
	beforeDate: 'تاریخ میبایست برابر یا قبل از {label} باشد',
	startMonth: 'لطفا ماه شروع را انتخاب کنید',
	sameMonth: 'این دو تاریخ باید در یک ماه باشند - شما باید یکی یا هر دو را تغییر دهید.',
	creditcard: 'شماره کارت اعتباری که وارد کرده اید معتبر نیست. لطفا شماره را بررسی کنید و مجددا تلاش کنید. {length} رقم وارد شده است.'

});

/*
---

name: Locale.fi-FI.Date

description: Date messages for Finnish.

license: MIT-style license

authors:
  - ksel

requires:
  - Locale

provides: [Locale.fi-FI.Date]

...
*/

Locale.define('fi-FI', 'Date', {

	// NOTE: months and days are not capitalized in finnish
	months: ['tammikuu', 'helmikuu', 'maaliskuu', 'huhtikuu', 'toukokuu', 'kesäkuu', 'heinäkuu', 'elokuu', 'syyskuu', 'lokakuu', 'marraskuu', 'joulukuu'],

	// these abbreviations are really not much used in finnish because they obviously won't abbreviate very much. ;)
	// NOTE: sometimes one can see forms such as "tammi", "helmi", etc. but that is not proper finnish.
	months_abbr: ['tammik.', 'helmik.', 'maalisk.', 'huhtik.', 'toukok.', 'kesäk.', 'heinäk.', 'elok.', 'syysk.', 'lokak.', 'marrask.', 'jouluk.'],

	days: ['sunnuntai', 'maanantai', 'tiistai', 'keskiviikko', 'torstai', 'perjantai', 'lauantai'],
	days_abbr: ['su', 'ma', 'ti', 'ke', 'to', 'pe', 'la'],

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

	// Date.Extras
	ordinal: '.',

	lessThanMinuteAgo: 'vajaa minuutti sitten',
	minuteAgo: 'noin minuutti sitten',
	minutesAgo: '{delta} minuuttia sitten',
	hourAgo: 'noin tunti sitten',
	hoursAgo: 'noin {delta} tuntia sitten',
	dayAgo: 'päivä sitten',
	daysAgo: '{delta} päivää sitten',
	weekAgo: 'viikko sitten',
	weeksAgo: '{delta} viikkoa sitten',
	monthAgo: 'kuukausi sitten',
	monthsAgo: '{delta} kuukautta sitten',
	yearAgo: 'vuosi sitten',
	yearsAgo: '{delta} vuotta sitten',

	lessThanMinuteUntil: 'vajaan minuutin kuluttua',
	minuteUntil: 'noin minuutin kuluttua',
	minutesUntil: '{delta} minuutin kuluttua',
	hourUntil: 'noin tunnin kuluttua',
	hoursUntil: 'noin {delta} tunnin kuluttua',
	dayUntil: 'päivän kuluttua',
	daysUntil: '{delta} päivän kuluttua',
	weekUntil: 'viikon kuluttua',
	weeksUntil: '{delta} viikon kuluttua',
	monthUntil: 'kuukauden kuluttua',
	monthsUntil: '{delta} kuukauden kuluttua',
	yearUntil: 'vuoden kuluttua',
	yearsUntil: '{delta} vuoden kuluttua'

});

/*
---

name: Locale.fi-FI.Form.Validator

description: Form Validator messages for Finnish.

license: MIT-style license

authors:
  - ksel

requires:
  - Locale

provides: [Locale.fi-FI.Form.Validator]

...
*/

Locale.define('fi-FI', 'FormValidator', {

	required: 'Tämä kenttä on pakollinen.',
	minLength: 'Ole hyvä ja anna vähintään {minLength} merkkiä (annoit {length} merkkiä).',
	maxLength: 'Älä anna enempää kuin {maxLength} merkkiä (annoit {length} merkkiä).',
	integer: 'Ole hyvä ja anna kokonaisluku. Luvut, joissa on desimaaleja (esim. 1.25) eivät ole sallittuja.',
	numeric: 'Anna tähän kenttään lukuarvo (kuten "1" tai "1.1" tai "-1" tai "-1.1").',
	digits: 'Käytä pelkästään numeroita ja välimerkkejä tässä kentässä (syötteet, kuten esim. puhelinnumero, jossa on väliviivoja, pilkkuja tai pisteitä, kelpaa).',
	alpha: 'Anna tähän kenttään vain kirjaimia (a-z). Välilyönnit tai muut merkit eivät ole sallittuja.',
	alphanum: 'Anna tähän kenttään vain kirjaimia (a-z) tai numeroita (0-9). Välilyönnit tai muut merkit eivät ole sallittuja.',
	dateSuchAs: 'Ole hyvä ja anna kelvollinen päivmäärä, kuten esimerkiksi {date}',
	dateInFormatMDY: 'Ole hyvä ja anna kelvollinen päivämäärä muodossa pp/kk/vvvv (kuten "12/31/1999")',
	email: 'Ole hyvä ja anna kelvollinen sähköpostiosoite (kuten esimerkiksi "matti@meikalainen.com").',
	url: 'Ole hyvä ja anna kelvollinen URL, kuten esimerkiksi http://www.example.com.',
	currencyDollar: 'Ole hyvä ja anna kelvollinen eurosumma (kuten esimerkiksi 100,00 EUR) .',
	oneRequired: 'Ole hyvä ja syötä jotakin ainakin johonkin näistä kentistä.',
	errorPrefix: 'Virhe: ',
	warningPrefix: 'Varoitus: ',

	// Form.Validator.Extras
	noSpace: 'Tässä syötteessä ei voi olla välilyöntejä',
	reqChkByNode: 'Ei valintoja.',
	requiredChk: 'Tämä kenttä on pakollinen.',
	reqChkByName: 'Ole hyvä ja valitse {label}.',
	match: 'Tämän kentän tulee vastata kenttää {matchName}',
	startDate: 'alkupäivämäärä',
	endDate: 'loppupäivämäärä',
	currentDate: 'nykyinen päivämäärä',
	afterDate: 'Päivämäärän tulisi olla sama tai myöhäisempi ajankohta kuin {label}.',
	beforeDate: 'Päivämäärän tulisi olla sama tai aikaisempi ajankohta kuin {label}.',
	startMonth: 'Ole hyvä ja valitse aloituskuukausi',
	sameMonth: 'Näiden kahden päivämäärän tulee olla saman kuun sisällä -- sinun pitää muuttaa jompaa kumpaa.',
	creditcard: 'Annettu luottokortin numero ei kelpaa. Ole hyvä ja tarkista numero sekä yritä uudelleen. {length} numeroa syötetty.'

});

/*
---

name: Locale.fi-FI.Number

description: Finnish number messages

license: MIT-style license

authors:
  - ksel

requires:
  - Locale
  - Locale.EU.Number

provides: [Locale.fi-FI.Number]

...
*/

Locale.define('fi-FI', 'Number', {

	group: ' ' // grouped by space

}).inherit('EU', 'Number');

/*
---

name: Locale.fr-FR.Date

description: Date messages for French.

license: MIT-style license

authors:
  - Nicolas Sorosac
  - Antoine Abt

requires:
  - Locale

provides: [Locale.fr-FR.Date]

...
*/

Locale.define('fr-FR', 'Date', {

	months: ['Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet', 'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre'],
	months_abbr: ['janv.', 'févr.', 'mars', 'avr.', 'mai', 'juin', 'juil.', 'août', 'sept.', 'oct.', 'nov.', 'déc.'],
	days: ['Dimanche', 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi'],
	days_abbr: ['dim.', 'lun.', 'mar.', 'mer.', 'jeu.', 'ven.', 'sam.'],

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

	// Date.Extras
	ordinal: function(dayOfMonth){
		return (dayOfMonth > 1) ? '' : 'er';
	},

	lessThanMinuteAgo: "il y a moins d'une minute",
	minuteAgo: 'il y a une minute',
	minutesAgo: 'il y a {delta} minutes',
	hourAgo: 'il y a une heure',
	hoursAgo: 'il y a {delta} heures',
	dayAgo: 'il y a un jour',
	daysAgo: 'il y a {delta} jours',
	weekAgo: 'il y a une semaine',
	weeksAgo: 'il y a {delta} semaines',
	monthAgo: 'il y a 1 mois',
	monthsAgo: 'il y a {delta} mois',
	yearthAgo: 'il y a 1 an',
	yearsAgo: 'il y a {delta} ans',

	lessThanMinuteUntil: "dans moins d'une minute",
	minuteUntil: 'dans une minute',
	minutesUntil: 'dans {delta} minutes',
	hourUntil: 'dans une heure',
	hoursUntil: 'dans {delta} heures',
	dayUntil: 'dans un jour',
	daysUntil: 'dans {delta} jours',
	weekUntil: 'dans 1 semaine',
	weeksUntil: 'dans {delta} semaines',
	monthUntil: 'dans 1 mois',
	monthsUntil: 'dans {delta} mois',
	yearUntil: 'dans 1 an',
	yearsUntil: 'dans {delta} ans'

});

/*
---

name: Locale.fr-FR.Form.Validator

description: Form Validator messages for French.

license: MIT-style license

authors:
  - Miquel Hudin
  - Nicolas Sorosac

requires:
  - Locale

provides: [Locale.fr-FR.Form.Validator]

...
*/

/*eslint mootools-whitespace:0*/

Locale.define('fr-FR', 'FormValidator', {

	required: 'Ce champ est obligatoire.',
	length: 'Veuillez saisir {length} caract&egrave;re(s) (vous avez saisi {elLength} caract&egrave;re(s)',
	minLength: 'Veuillez saisir un minimum de {minLength} caract&egrave;re(s) (vous avez saisi {length} caract&egrave;re(s)).',
	maxLength: 'Veuillez saisir un maximum de {maxLength} caract&egrave;re(s) (vous avez saisi {length} caract&egrave;re(s)).',
	integer: 'Veuillez saisir un nombre entier dans ce champ. Les nombres d&eacute;cimaux (ex : "1,25") ne sont pas autoris&eacute;s.',
	numeric: 'Veuillez saisir uniquement des chiffres dans ce champ (ex : "1" ou "1,1" ou "-1" ou "-1,1").',
	digits: "Veuillez saisir uniquement des chiffres et des signes de ponctuation dans ce champ (ex : un num&eacute;ro de t&eacute;l&eacute;phone avec des traits d'union est autoris&eacute;).",
	alpha: 'Veuillez saisir uniquement des lettres (a-z) dans ce champ. Les espaces ou autres caract&egrave;res ne sont pas autoris&eacute;s.',
	alphanum: 'Veuillez saisir uniquement des lettres (a-z) ou des chiffres (0-9) dans ce champ. Les espaces ou autres caract&egrave;res ne sont pas autoris&eacute;s.',
	dateSuchAs: 'Veuillez saisir une date correcte comme {date}',
	dateInFormatMDY: 'Veuillez saisir une date correcte, au format JJ/MM/AAAA (ex : "31/11/1999").',
	email: 'Veuillez saisir une adresse de courrier &eacute;lectronique. Par exemple "fred@domaine.com".',
	url: 'Veuillez saisir une URL, comme http://www.exemple.com.',
	currencyDollar: 'Veuillez saisir une quantit&eacute; correcte. Par exemple 100,00&euro;.',
	oneRequired: 'Veuillez s&eacute;lectionner au moins une de ces options.',
	errorPrefix: 'Erreur : ',
	warningPrefix: 'Attention : ',

	// Form.Validator.Extras
	noSpace: "Ce champ n'accepte pas les espaces.",
	reqChkByNode: "Aucun &eacute;l&eacute;ment n'est s&eacute;lectionn&eacute;.",
	requiredChk: 'Ce champ est obligatoire.',
	reqChkByName: 'Veuillez s&eacute;lectionner un(e) {label}.',
	match: 'Ce champ doit correspondre avec le champ {matchName}.',
	startDate: 'date de d&eacute;but',
	endDate: 'date de fin',
	currentDate: 'date actuelle',
	afterDate: 'La date doit &ecirc;tre identique ou post&eacute;rieure &agrave; {label}.',
	beforeDate: 'La date doit &ecirc;tre identique ou ant&eacute;rieure &agrave; {label}.',
	startMonth: 'Veuillez s&eacute;lectionner un mois de d&eacute;but.',
	sameMonth: 'Ces deux dates doivent &ecirc;tre dans le m&ecirc;me mois - vous devez en modifier une.',
	creditcard: 'Le num&eacute;ro de carte de cr&eacute;dit est invalide. Merci de v&eacute;rifier le num&eacute;ro et de r&eacute;essayer. Vous avez entr&eacute; {length} chiffre(s).'

});

/*
---

name: Locale.fr-FR.Number

description: Number messages for French.

license: MIT-style license

authors:
  - Arian Stolwijk
  - sv1l

requires:
  - Locale
  - Locale.EU.Number

provides: [Locale.fr-FR.Number]

...
*/

Locale.define('fr-FR', 'Number', {

	group: ' ' // In fr-FR localization, group character is a blank space

}).inherit('EU', 'Number');

/*
---

name: Locale.he-IL.Date

description: Date messages for Hebrew.

license: MIT-style license

authors:
  - Elad Ossadon

requires:
  - Locale

provides: [Locale.he-IL.Date]

...
*/

Locale.define('he-IL', 'Date', {

	months: ['ינואר', 'פברואר', 'מרץ', 'אפריל', 'מאי', 'יוני', 'יולי', 'אוגוסט', 'ספטמבר', 'אוקטובר', 'נובמבר', 'דצמבר'],
	months_abbr: ['ינואר', 'פברואר', 'מרץ', 'אפריל', 'מאי', 'יוני', 'יולי', 'אוגוסט', 'ספטמבר', 'אוקטובר', 'נובמבר', 'דצמבר'],
	days: ['ראשון', 'שני', 'שלישי', 'רביעי', 'חמישי', 'שישי', 'שבת'],
	days_abbr: ['ראשון', 'שני', 'שלישי', 'רביעי', 'חמישי', 'שישי', 'שבת'],

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

	// Date.Extras
	ordinal: '',

	lessThanMinuteAgo: 'לפני פחות מדקה',
	minuteAgo: 'לפני כדקה',
	minutesAgo: 'לפני {delta} דקות',
	hourAgo: 'לפני כשעה',
	hoursAgo: 'לפני {delta} שעות',
	dayAgo: 'לפני יום',
	daysAgo: 'לפני {delta} ימים',
	weekAgo: 'לפני שבוע',
	weeksAgo: 'לפני {delta} שבועות',
	monthAgo: 'לפני חודש',
	monthsAgo: 'לפני {delta} חודשים',
	yearAgo: 'לפני שנה',
	yearsAgo: 'לפני {delta} שנים',

	lessThanMinuteUntil: 'בעוד פחות מדקה',
	minuteUntil: 'בעוד כדקה',
	minutesUntil: 'בעוד {delta} דקות',
	hourUntil: 'בעוד כשעה',
	hoursUntil: 'בעוד {delta} שעות',
	dayUntil: 'בעוד יום',
	daysUntil: 'בעוד {delta} ימים',
	weekUntil: 'בעוד שבוע',
	weeksUntil: 'בעוד {delta} שבועות',
	monthUntil: 'בעוד חודש',
	monthsUntil: 'בעוד {delta} חודשים',
	yearUntil: 'בעוד שנה',
	yearsUntil: 'בעוד {delta} שנים'

});

/*
---

name: Locale.he-IL.Form.Validator

description: Form Validator messages for Hebrew.

license: MIT-style license

authors:
  - Elad Ossadon

requires:
  - Locale

provides: [Locale.he-IL.Form.Validator]

...
*/

Locale.define('he-IL', 'FormValidator', {

	required: 'נא למלא שדה זה.',
	minLength: 'נא להזין לפחות {minLength} תווים (הזנת {length} תווים).',
	maxLength: 'נא להזין עד {maxLength} תווים (הזנת {length} תווים).',
	integer: 'נא להזין מספר שלם לשדה זה. מספרים עשרוניים (כמו 1.25) אינם חוקיים.',
	numeric: 'נא להזין ערך מספרי בלבד בשדה זה (כמו "1", "1.1", "-1" או "-1.1").',
	digits: 'נא להזין רק ספרות וסימני הפרדה בשדה זה (למשל, מספר טלפון עם מקפים או נקודות הוא חוקי).',
	alpha: 'נא להזין רק אותיות באנגלית (a-z) בשדה זה. רווחים או תווים אחרים אינם חוקיים.',
	alphanum: 'נא להזין רק אותריות באנגלית (a-z) או ספרות (0-9) בשדה זה. אווחרים או תווים אחרים אינם חוקיים.',
	dateSuchAs: 'נא להזין תאריך חוקי, כמו {date}',
	dateInFormatMDY: 'נא להזין תאריך חוקי בפורמט MM/DD/YYYY (כמו "12/31/1999")',
	email: 'נא להזין כתובת אימייל חוקית. לדוגמה: "fred@domain.com".',
	url: 'נא להזין כתובת אתר חוקית, כמו http://www.example.com.',
	currencyDollar: 'נא להזין סכום דולרי חוקי. לדוגמה $100.00.',
	oneRequired: 'נא לבחור לפחות בשדה אחד.',
	errorPrefix: 'שגיאה: ',
	warningPrefix: 'אזהרה: ',

	// Form.Validator.Extras
	noSpace: 'אין להזין רווחים בשדה זה.',
	reqChkByNode: 'נא לבחור אחת מהאפשרויות.',
	requiredChk: 'שדה זה נדרש.',
	reqChkByName: 'נא לבחור {label}.',
	match: 'שדה זה צריך להתאים לשדה {matchName}',
	startDate: 'תאריך ההתחלה',
	endDate: 'תאריך הסיום',
	currentDate: 'התאריך הנוכחי',
	afterDate: 'התאריך צריך להיות זהה או אחרי {label}.',
	beforeDate: 'התאריך צריך להיות זהה או לפני {label}.',
	startMonth: 'נא לבחור חודש התחלה',
	sameMonth: 'שני תאריכים אלה צריכים להיות באותו חודש - נא לשנות אחד התאריכים.',
	creditcard: 'מספר כרטיס האשראי שהוזן אינו חוקי. נא לבדוק שנית. הוזנו {length} ספרות.'

});

/*
---

name: Locale.he-IL.Number

description: Number messages for Hebrew.

license: MIT-style license

authors:
  - Elad Ossadon

requires:
  - Locale

provides: [Locale.he-IL.Number]

...
*/

Locale.define('he-IL', 'Number', {

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

	currency: {
		suffix: ' ₪'
	}

});

/*
---

name: Locale.hu-HU.Date

description: Date messages for Hungarian.

license: MIT-style license

authors:
  - Zsolt Szegheő

requires:
  - Locale

provides: [Locale.hu-HU.Date]

...
*/

Locale.define('hu-HU', 'Date', {

	months: ['Január', 'Február', 'Március', 'Április', 'Május', 'Június', 'Július', 'Augusztus', 'Szeptember', 'Október', 'November', 'December'],
	months_abbr: ['jan.', 'febr.', 'márc.', 'ápr.', 'máj.', 'jún.', 'júl.', 'aug.', 'szept.', 'okt.', 'nov.', 'dec.'],
	days: ['Vasárnap', 'Hétfő', 'Kedd', 'Szerda', 'Csütörtök', 'Péntek', 'Szombat'],
	days_abbr: ['V', 'H', 'K', 'Sze', 'Cs', 'P', 'Szo'],

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

	// Date.Extras
	ordinal: '.',

	lessThanMinuteAgo: 'alig egy perce',
	minuteAgo: 'egy perce',
	minutesAgo: '{delta} perce',
	hourAgo: 'egy órája',
	hoursAgo: '{delta} órája',
	dayAgo: '1 napja',
	daysAgo: '{delta} napja',
	weekAgo: '1 hete',
	weeksAgo: '{delta} hete',
	monthAgo: '1 hónapja',
	monthsAgo: '{delta} hónapja',
	yearAgo: '1 éve',
	yearsAgo: '{delta} éve',

	lessThanMinuteUntil: 'alig egy perc múlva',
	minuteUntil: 'egy perc múlva',
	minutesUntil: '{delta} perc múlva',
	hourUntil: 'egy óra múlva',
	hoursUntil: '{delta} óra múlva',
	dayUntil: '1 nap múlva',
	daysUntil: '{delta} nap múlva',
	weekUntil: '1 hét múlva',
	weeksUntil: '{delta} hét múlva',
	monthUntil: '1 hónap múlva',
	monthsUntil: '{delta} hónap múlva',
	yearUntil: '1 év múlva',
	yearsUntil: '{delta} év múlva'

});

/*
---

name: Locale.hu-HU.Form.Validator

description: Form Validator messages for Hungarian.

license: MIT-style license

authors:
  - Zsolt Szegheő

requires:
  - Locale

provides: [Locale.hu-HU.Form.Validator]

...
*/

/*eslint mootools-whitespace:0*/

Locale.define('hu-HU', 'FormValidator', {

	required: 'A mező kitöltése kötelező.',
	minLength: 'Legalább {minLength} karakter megadása szükséges (megadva {length} karakter).',
	maxLength: 'Legfeljebb {maxLength} karakter megadása lehetséges (megadva {length} karakter).',
	integer: 'Egész szám megadása szükséges. A tizedesjegyek (pl. 1.25) nem engedélyezettek.',
	numeric: 'Szám megadása szükséges (pl. "1" vagy "1.1" vagy "-1" vagy "-1.1").',
	digits: 'Csak számok és írásjelek megadása lehetséges (pl. telefonszám kötőjelek és/vagy perjelekkel).',
	alpha: 'Csak betűk (a-z) megadása lehetséges. Szóköz és egyéb karakterek nem engedélyezettek.',
	alphanum: 'Csak betűk (a-z) vagy számok (0-9) megadása lehetséges. Szóköz és egyéb karakterek nem engedélyezettek.',
	dateSuchAs: 'Valós dátum megadása szükséges (pl. {date}).',
	dateInFormatMDY: 'Valós dátum megadása szükséges ÉÉÉÉ.HH.NN. formában. (pl. "1999.12.31.")',
	email: 'Valós e-mail cím megadása szükséges (pl. "fred@domain.hu").',
	url: 'Valós URL megadása szükséges (pl. http://www.example.com).',
	currencyDollar: 'Valós pénzösszeg megadása szükséges (pl. 100.00 Ft.).',
	oneRequired: 'Az alábbi mezők legalább egyikének kitöltése kötelező.',
	errorPrefix: 'Hiba: ',
	warningPrefix: 'Figyelem: ',

	// Form.Validator.Extras
	noSpace: 'A mező nem tartalmazhat szóközöket.',
	reqChkByNode: 'Nincs egyetlen kijelölt elem sem.',
	requiredChk: 'A mező kitöltése kötelező.',
	reqChkByName: 'Egy {label} kiválasztása szükséges.',
	match: 'A mezőnek egyeznie kell a(z) {matchName} mezővel.',
	startDate: 'a kezdet dátuma',
	endDate: 'a vég dátuma',
	currentDate: 'jelenlegi dátum',
	afterDate: 'A dátum nem lehet kisebb, mint {label}.',
	beforeDate: 'A dátum nem lehet nagyobb, mint {label}.',
	startMonth: 'Kezdeti hónap megadása szükséges.',
	sameMonth: 'A két dátumnak ugyanazon hónapban kell lennie.',
	creditcard: 'A megadott bankkártyaszám nem valódi (megadva {length} számjegy).'

});

/*
---

name: Locale.it-IT.Date

description: Date messages for Italian.

license: MIT-style license.

authors:
  - Andrea Novero
  - Valerio Proietti

requires:
  - Locale

provides: [Locale.it-IT.Date]

...
*/

Locale.define('it-IT', 'Date', {

	months: ['Gennaio', 'Febbraio', 'Marzo', 'Aprile', 'Maggio', 'Giugno', 'Luglio', 'Agosto', 'Settembre', 'Ottobre', 'Novembre', 'Dicembre'],
	months_abbr: ['gen', 'feb', 'mar', 'apr', 'mag', 'giu', 'lug', 'ago', 'set', 'ott', 'nov', 'dic'],
	days: ['Domenica', 'Lunedì', 'Martedì', 'Mercoledì', 'Giovedì', 'Venerdì', 'Sabato'],
	days_abbr: ['dom', 'lun', 'mar', 'mer', 'gio', 'ven', 'sab'],

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

	// Date.Extras
	ordinal: 'º',

	lessThanMinuteAgo: 'meno di un minuto fa',
	minuteAgo: 'circa un minuto fa',
	minutesAgo: 'circa {delta} minuti fa',
	hourAgo: "circa un'ora fa",
	hoursAgo: 'circa {delta} ore fa',
	dayAgo: 'circa 1 giorno fa',
	daysAgo: 'circa {delta} giorni fa',
	weekAgo: 'una settimana fa',
	weeksAgo: '{delta} settimane fa',
	monthAgo: 'un mese fa',
	monthsAgo: '{delta} mesi fa',
	yearAgo: 'un anno fa',
	yearsAgo: '{delta} anni fa',

	lessThanMinuteUntil: 'tra meno di un minuto',
	minuteUntil: 'tra circa un minuto',
	minutesUntil: 'tra circa {delta} minuti',
	hourUntil: "tra circa un'ora",
	hoursUntil: 'tra circa {delta} ore',
	dayUntil: 'tra circa un giorno',
	daysUntil: 'tra circa {delta} giorni',
	weekUntil: 'tra una settimana',
	weeksUntil: 'tra {delta} settimane',
	monthUntil: 'tra un mese',
	monthsUntil: 'tra {delta} mesi',
	yearUntil: 'tra un anno',
	yearsUntil: 'tra {delta} anni'

});

/*
---

name: Locale.it-IT.Form.Validator

description: Form Validator messages for Italian.

license: MIT-style license

authors:
  - Leonardo Laureti
  - Andrea Novero

requires:
  - Locale

provides: [Locale.it-IT.Form.Validator]

...
*/

/*eslint mootools-whitespace:0*/

Locale.define('it-IT', 'FormValidator', {

	required: 'Il campo &egrave; obbligatorio.',
	minLength: 'Inserire almeno {minLength} caratteri (ne sono stati inseriti {length}).',
	maxLength: 'Inserire al massimo {maxLength} caratteri (ne sono stati inseriti {length}).',
	integer: 'Inserire un numero intero. Non sono consentiti decimali (es.: 1.25).',
	numeric: 'Inserire solo valori numerici (es.: "1" oppure "1.1" oppure "-1" oppure "-1.1").',
	digits: 'Inserire solo numeri e caratteri di punteggiatura. Per esempio &egrave; consentito un numero telefonico con trattini o punti.',
	alpha: 'Inserire solo lettere (a-z). Non sono consentiti spazi o altri caratteri.',
	alphanum: 'Inserire solo lettere (a-z) o numeri (0-9). Non sono consentiti spazi o altri caratteri.',
	dateSuchAs: 'Inserire una data valida del tipo {date}',
	dateInFormatMDY: 'Inserire una data valida nel formato MM/GG/AAAA (es.: "12/31/1999")',
	email: 'Inserire un indirizzo email valido. Per esempio "nome@dominio.com".',
	url: 'Inserire un indirizzo valido. Per esempio "http://www.example.com".',
	currencyDollar: 'Inserire un importo valido. Per esempio "$100.00".',
	oneRequired: 'Completare almeno uno dei campi richiesti.',
	errorPrefix: 'Errore: ',
	warningPrefix: 'Attenzione: ',

	// Form.Validator.Extras
	noSpace: 'Non sono consentiti spazi.',
	reqChkByNode: 'Nessuna voce selezionata.',
	requiredChk: 'Il campo &egrave; obbligatorio.',
	reqChkByName: 'Selezionare un(a) {label}.',
	match: 'Il valore deve corrispondere al campo {matchName}',
	startDate: "data d'inizio",
	endDate: 'data di fine',
	currentDate: 'data attuale',
	afterDate: 'La data deve corrispondere o essere successiva al {label}.',
	beforeDate: 'La data deve corrispondere o essere precedente al {label}.',
	startMonth: "Selezionare un mese d'inizio",
	sameMonth: 'Le due date devono essere dello stesso mese - occorre modificarne una.'

});

/*
---

name: Locale.ja-JP.Date

description: Date messages for Japanese.

license: MIT-style license

authors:
  - Noritaka Horio

requires:
  - Locale

provides: [Locale.ja-JP.Date]

...
*/

Locale.define('ja-JP', 'Date', {

	months: ['1月', '2月', '3月', '4月', '5月', '6月', '7月', '8月', '9月', '10月', '11月', '12月'],
	months_abbr: ['1月', '2月', '3月', '4月', '5月', '6月', '7月', '8月', '9月', '10月', '11月', '12月'],
	days: ['日曜日', '月曜日', '火曜日', '水曜日', '木曜日', '金曜日', '土曜日'],
	days_abbr: ['日', '月', '火', '水', '木', '金', '土'],

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

	// Date.Extras
	ordinal: '',

	lessThanMinuteAgo: '1分以内前',
	minuteAgo: '約1分前',
	minutesAgo: '約{delta}分前',
	hourAgo: '約1時間前',
	hoursAgo: '約{delta}時間前',
	dayAgo: '1日前',
	daysAgo: '{delta}日前',
	weekAgo: '1週間前',
	weeksAgo: '{delta}週間前',
	monthAgo: '1ヶ月前',
	monthsAgo: '{delta}ヶ月前',
	yearAgo: '1年前',
	yearsAgo: '{delta}年前',

	lessThanMinuteUntil: '今から約1分以内',
	minuteUntil: '今から約1分',
	minutesUntil: '今から約{delta}分',
	hourUntil: '今から約1時間',
	hoursUntil: '今から約{delta}時間',
	dayUntil: '今から1日間',
	daysUntil: '今から{delta}日間',
	weekUntil: '今から1週間',
	weeksUntil: '今から{delta}週間',
	monthUntil: '今から1ヶ月',
	monthsUntil: '今から{delta}ヶ月',
	yearUntil: '今から1年',
	yearsUntil: '今から{delta}年'

});

/*
---

name: Locale.ja-JP.Form.Validator

description: Form Validator messages for Japanese.

license: MIT-style license

authors:
  - Noritaka Horio

requires:
  - Locale

provides: [Locale.ja-JP.Form.Validator]

...
*/

Locale.define('ja-JP', 'FormValidator', {

	required: '入力は必須です。',
	minLength: '入力文字数は{minLength}以上にしてください。({length}文字)',
	maxLength: '入力文字数は{maxLength}以下にしてください。({length}文字)',
	integer: '整数を入力してください。',
	numeric: '入力できるのは数値だけです。(例: "1", "1.1", "-1", "-1.1"....)',
	digits: '入力できるのは数値と句読記号です。 (例: -や+を含む電話番号など).',
	alpha: '入力できるのは半角英字だけです。それ以外の文字は入力できません。',
	alphanum: '入力できるのは半角英数字だけです。それ以外の文字は入力できません。',
	dateSuchAs: '有効な日付を入力してください。{date}',
	dateInFormatMDY: '日付の書式に誤りがあります。YYYY/MM/DD (i.e. "1999/12/31")',
	email: 'メールアドレスに誤りがあります。',
	url: 'URLアドレスに誤りがあります。',
	currencyDollar: '金額に誤りがあります。',
	oneRequired: 'ひとつ以上入力してください。',
	errorPrefix: 'エラー: ',
	warningPrefix: '警告: ',

	// FormValidator.Extras
	noSpace: 'スペースは入力できません。',
	reqChkByNode: '選択されていません。',
	requiredChk: 'この項目は必須です。',
	reqChkByName: '{label}を選択してください。',
	match: '{matchName}が入力されている場合必須です。',
	startDate: '開始日',
	endDate: '終了日',
	currentDate: '今日',
	afterDate: '{label}以降の日付にしてください。',
	beforeDate: '{label}以前の日付にしてください。',
	startMonth: '開始月を選択してください。',
	sameMonth: '日付が同一です。どちらかを変更してください。'

});

/*
---

name: Locale.ja-JP.Number

description: Number messages for Japanese.

license: MIT-style license

authors:
  - Noritaka Horio

requires:
  - Locale

provides: [Locale.ja-JP.Number]

...
*/

Locale.define('ja-JP', 'Number', {

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

	currency: {
		decimals: 0,
		prefix: '\\'
	}

});

/*
---

name: Locale.nl-NL.Date

description: Date messages for Dutch.

license: MIT-style license

authors:
  - Lennart Pilon
  - Tim Wienk

requires:
  - Locale

provides: [Locale.nl-NL.Date]

...
*/

Locale.define('nl-NL', 'Date', {

	months: ['januari', 'februari', 'maart', 'april', 'mei', 'juni', 'juli', 'augustus', 'september', 'oktober', 'november', 'december'],
	months_abbr: ['jan', 'feb', 'mrt', 'apr', 'mei', 'jun', 'jul', 'aug', 'sep', 'okt', 'nov', 'dec'],
	days: ['zondag', 'maandag', 'dinsdag', 'woensdag', 'donderdag', 'vrijdag', 'zaterdag'],
	days_abbr: ['zo', 'ma', 'di', 'wo', 'do', 'vr', 'za'],

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

	// Date.Extras
	ordinal: 'e',

	lessThanMinuteAgo: 'minder dan een minuut geleden',
	minuteAgo: 'ongeveer een minuut geleden',
	minutesAgo: '{delta} minuten geleden',
	hourAgo: 'ongeveer een uur geleden',
	hoursAgo: 'ongeveer {delta} uur geleden',
	dayAgo: 'een dag geleden',
	daysAgo: '{delta} dagen geleden',
	weekAgo: 'een week geleden',
	weeksAgo: '{delta} weken geleden',
	monthAgo: 'een maand geleden',
	monthsAgo: '{delta} maanden geleden',
	yearAgo: 'een jaar geleden',
	yearsAgo: '{delta} jaar geleden',

	lessThanMinuteUntil: 'over minder dan een minuut',
	minuteUntil: 'over ongeveer een minuut',
	minutesUntil: 'over {delta} minuten',
	hourUntil: 'over ongeveer een uur',
	hoursUntil: 'over {delta} uur',
	dayUntil: 'over ongeveer een dag',
	daysUntil: 'over {delta} dagen',
	weekUntil: 'over een week',
	weeksUntil: 'over {delta} weken',
	monthUntil: 'over een maand',
	monthsUntil: 'over {delta} maanden',
	yearUntil: 'over een jaar',
	yearsUntil: 'over {delta} jaar'

});

/*
---

name: Locale.nl-NL.Form.Validator

description: Form Validator messages for Dutch.

license: MIT-style license

authors:
  - Lennart Pilon
  - Arian Stolwijk
  - Tim Wienk

requires:
  - Locale

provides: [Locale.nl-NL.Form.Validator]

...
*/

Locale.define('nl-NL', 'FormValidator', {

	required: 'Dit veld is verplicht.',
	length: 'Vul precies {length} karakters in (je hebt {elLength} karakters ingevoerd).',
	minLength: 'Vul minimaal {minLength} karakters in (je hebt {length} karakters ingevoerd).',
	maxLength: 'Vul niet meer dan {maxLength} karakters in (je hebt {length} karakters ingevoerd).',
	integer: 'Vul een getal in. Getallen met decimalen (bijvoorbeeld 1.25) zijn niet toegestaan.',
	numeric: 'Vul alleen numerieke waarden in (bijvoorbeeld "1" of "1.1" of "-1" of "-1.1").',
	digits: 'Vul alleen nummers en leestekens in (bijvoorbeeld een telefoonnummer met streepjes is toegestaan).',
	alpha: 'Vul alleen letters in (a-z). Spaties en andere karakters zijn niet toegestaan.',
	alphanum: 'Vul alleen letters (a-z) of nummers (0-9) in. Spaties en andere karakters zijn niet toegestaan.',
	dateSuchAs: 'Vul een geldige datum in, zoals {date}',
	dateInFormatMDY: 'Vul een geldige datum, in het formaat MM/DD/YYYY (bijvoorbeeld "12/31/1999")',
	email: 'Vul een geldig e-mailadres in. Bijvoorbeeld "fred@domein.nl".',
	url: 'Vul een geldige URL in, zoals http://www.example.com.',
	currencyDollar: 'Vul een geldig $ bedrag in. Bijvoorbeeld $100.00 .',
	oneRequired: 'Vul iets in bij in ieder geval een van deze velden.',
	warningPrefix: 'Waarschuwing: ',
	errorPrefix: 'Fout: ',

	// Form.Validator.Extras
	noSpace: 'Spaties zijn niet toegestaan in dit veld.',
	reqChkByNode: 'Er zijn geen items geselecteerd.',
	requiredChk: 'Dit veld is verplicht.',
	reqChkByName: 'Selecteer een {label}.',
	match: 'Dit veld moet overeen komen met het {matchName} veld',
	startDate: 'de begin datum',
	endDate: 'de eind datum',
	currentDate: 'de huidige datum',
	afterDate: 'De datum moet hetzelfde of na {label} zijn.',
	beforeDate: 'De datum moet hetzelfde of voor {label} zijn.',
	startMonth: 'Selecteer een begin maand',
	sameMonth: 'Deze twee data moeten in dezelfde maand zijn - u moet een van beide aanpassen.',
	creditcard: 'Het ingevulde creditcardnummer is niet geldig. Controleer het nummer en probeer opnieuw. {length} getallen ingevuld.'

});

/*
---

name: Locale.nl-NL.Number

description: Number messages for Dutch.

license: MIT-style license

authors:
  - Arian Stolwijk

requires:
  - Locale
  - Locale.EU.Number

provides: [Locale.nl-NL.Number]

...
*/

Locale.define('nl-NL').inherit('EU', 'Number');




/*
---

name: Locale.no-NO.Date

description: Date messages for Norwegian.

license: MIT-style license

authors:
  - Espen 'Rexxars' Hovlandsdal
  - Ole Tøsse Kolvik
requires:
  - Locale

provides: [Locale.no-NO.Date]

...
*/

Locale.define('no-NO', 'Date', {
	months: ['Januar', 'Februar', 'Mars', 'April', 'Mai', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'Desember'],
	months_abbr: ['Jan', 'Feb', 'Mar', 'Apr', 'Mai', 'Jun', 'Jul', 'Aug', 'Sep', 'Okt', 'Nov', 'Des'],
	days: ['Søndag', 'Mandag', 'Tirsdag', 'Onsdag', 'Torsdag', 'Fredag', 'Lørdag'],
	days_abbr: ['Søn', 'Man', 'Tir', 'Ons', 'Tor', 'Fre', 'Lør'],

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

	lessThanMinuteAgo: 'mindre enn et minutt siden',
	minuteAgo: 'omtrent et minutt siden',
	minutesAgo: '{delta} minutter siden',
	hourAgo: 'omtrent en time siden',
	hoursAgo: 'omtrent {delta} timer siden',
	dayAgo: '{delta} dag siden',
	daysAgo: '{delta} dager siden',
	weekAgo: 'en uke siden',
	weeksAgo: '{delta} uker siden',
	monthAgo: 'en måned siden',
	monthsAgo: '{delta} måneder siden',
	yearAgo: 'ett år siden',
	yearsAgo: '{delta} år siden',

	lessThanMinuteUntil: 'mindre enn et minutt til',
	minuteUntil: 'omtrent et minutt til',
	minutesUntil: '{delta} minutter til',
	hourUntil: 'omtrent en time til',
	hoursUntil: 'omtrent {delta} timer til',
	dayUntil: 'en dag til',
	daysUntil: '{delta} dager til',
	weekUntil: 'en uke til',
	weeksUntil: '{delta} uker til',
	monthUntil: 'en måned til',
	monthsUntil: '{delta} måneder til',
	yearUntil: 'et år til',
	yearsUntil: '{delta} år til'
});

/*
---

name: Locale.no-NO.Form.Validator

description: Form Validator messages for Norwegian.

license: MIT-style license

authors:
  - Aaron Newton
  - Espen 'Rexxars' Hovlandsdal
  - Ole Tøsse Kolvik

requires:
  - Locale

provides: [Locale.no-NO.Form.Validator]

...
*/

Locale.define('no-NO', 'FormValidator', {

	required: 'Dette feltet er påkrevd.',
	length: 'Skriv inn {length} tegn (du skrev {elLength} tegn)',
	minLength: 'Skriv inn minst {minLength} tegn (du skrev {length} tegn).',
	maxLength: 'Ikke skriv mer enn {maxLength} tegn (du skrev {length} tegn).',
	integer: 'Skriv inn et tall i dette feltet. Tall med desimaler (f.eks. 1,25) er ikke tillat.',
	numeric: 'Skriv kun inn numeriske verdier i dette feltet (f.eks. "1", "1.1", "-1" eller "-1.1").',
	digits: 'Skriv kun nummer og skilletegn i dette feltet.',
	alpha: 'Skriv kun bokstaver (a-å) i dette feltet. Ingen mellomrom eller andre tegn er tillat.',
	alphanum: 'Skriv kun bokstaver (a-å) eller nummer (0-9) i dette feltet. Ingen mellomrom eller andre tegn er tillat.',
	dateSuchAs: 'Skriv inn en gyldig dato, som f.eks. {date}',
	dateInFormatMDY: 'Skriv inn en gyldig dato, f.eks. DD/MM/YYYY ("31/12/1999")',
	email: 'Skriv inn en gyldig epost-adresse. F.eks. "ola.nordmann@example.com".',
	url: 'Skriv inn en gyldig URL, f.eks. http://www.example.com.',
	currencyDollar: 'Skriv inn et gyldig beløp. F.eks. 100,00.',
	oneRequired: 'Minst ett av disse feltene må fylles ut.',
	errorPrefix: 'Feil: ',
	warningPrefix: 'Advarsel: ',

	// Form.Validator.Extras
	noSpace: 'Mellomrom er ikke tillatt i dette feltet.',
	reqChkByNode: 'Ingen objekter er valgt.',
	requiredChk: 'Dette feltet er påkrevd.',
	reqChkByName: 'Velg en {label}.',
	match: 'Dette feltet må være lik {matchName}',
	startDate: 'startdato',
	endDate: 'sluttdato',
	currentDate: 'dagens dato',
	afterDate: 'Datoen må være den samme som eller etter {label}.',
	beforeDate: 'Datoen må være den samme som eller før {label}.',
	startMonth: 'Velg en startmåned',
	sameMonth: 'Datoene må være i den samme måneden - velg den ene eller den andre.',
	creditcard: 'Kortnummeret du skrev inn er ikke gyldig. Prøv igjen. Du skrev {length} siffer.'

});

/*
---

name: Locale.no-NO.Number

description: Number messages for Norwegian.

license: MIT-style license

authors:
  - Arian Stolwijk
  - Martin Lundgren
  - Ole T�sse Kolvik

requires:
  - Locale
  - Locale.EU.Number

provides: [Locale.no-NO.Number]

...
*/

Locale.define('no-NO', 'Number', {

	currency: {
		prefix: 'NOK '
	}

}).inherit('EU', 'Number');

/*
---

name: Locale.pl-PL.Date

description: Date messages for Polish.

license: MIT-style license

authors:
  - Oskar Krawczyk

requires:
  - Locale

provides: [Locale.pl-PL.Date]

...
*/

Locale.define('pl-PL', 'Date', {

	months: ['Styczeń', 'Luty', 'Marzec', 'Kwiecień', 'Maj', 'Czerwiec', 'Lipiec', 'Sierpień', 'Wrzesień', 'Październik', 'Listopad', 'Grudzień'],
	months_abbr: ['sty', 'lut', 'mar', 'kwi', 'maj', 'cze', 'lip', 'sie', 'wrz', 'paź', 'lis', 'gru'],
	days: ['Niedziela', 'Poniedziałek', 'Wtorek', 'Środa', 'Czwartek', 'Piątek', 'Sobota'],
	days_abbr: ['niedz.', 'pon.', 'wt.', 'śr.', 'czw.', 'pt.', 'sob.'],

	// Culture's date order: YYYY-MM-DD
	dateOrder: ['year', 'month', 'date'],
	shortDate: '%Y-%m-%d',
	shortTime: '%H:%M',
	AM: 'nad ranem',
	PM: 'po południu',
	firstDayOfWeek: 1,

	// Date.Extras
	ordinal: function(dayOfMonth){
		return (dayOfMonth > 3 && dayOfMonth < 21) ? 'ty' : ['ty', 'szy', 'gi', 'ci', 'ty'][Math.min(dayOfMonth % 10, 4)];
	},

	lessThanMinuteAgo: 'mniej niż minute temu',
	minuteAgo: 'około minutę temu',
	minutesAgo: '{delta} minut temu',
	hourAgo: 'około godzinę temu',
	hoursAgo: 'około {delta} godzin temu',
	dayAgo: 'Wczoraj',
	daysAgo: '{delta} dni temu',

	lessThanMinuteUntil: 'za niecałą minutę',
	minuteUntil: 'za około minutę',
	minutesUntil: 'za {delta} minut',
	hourUntil: 'za około godzinę',
	hoursUntil: 'za około {delta} godzin',
	dayUntil: 'za 1 dzień',
	daysUntil: 'za {delta} dni'

});

/*
---

name: Locale.pl-PL.Form.Validator

description: Form Validator messages for Polish.

license: MIT-style license

authors:
  - Oskar Krawczyk

requires:
  - Locale

provides: [Locale.pl-PL.Form.Validator]

...
*/

Locale.define('pl-PL', 'FormValidator', {

	required: 'To pole jest wymagane.',
	minLength: 'Wymagane jest przynajmniej {minLength} znaków (wpisanych zostało tylko {length}).',
	maxLength: 'Dozwolone jest nie więcej niż {maxLength} znaków (wpisanych zostało {length})',
	integer: 'To pole wymaga liczb całych. Liczby dziesiętne (np. 1.25) są niedozwolone.',
	numeric: 'Prosimy używać tylko numerycznych wartości w tym polu (np. "1", "1.1", "-1" lub "-1.1").',
	digits: 'Prosimy używać liczb oraz zankow punktuacyjnych w typ polu (dla przykładu, przy numerze telefonu myślniki i kropki są dozwolone).',
	alpha: 'Prosimy używać tylko liter (a-z) w tym polu. Spacje oraz inne znaki są niedozwolone.',
	alphanum: 'Prosimy używać tylko liter (a-z) lub liczb (0-9) w tym polu. Spacje oraz inne znaki są niedozwolone.',
	dateSuchAs: 'Prosimy podać prawidłową datę w formacie: {date}',
	dateInFormatMDY: 'Prosimy podać poprawną date w formacie DD.MM.RRRR (i.e. "12.01.2009")',
	email: 'Prosimy podać prawidłowy adres e-mail, np. "jan@domena.pl".',
	url: 'Prosimy podać prawidłowy adres URL, np. http://www.example.com.',
	currencyDollar: 'Prosimy podać prawidłową sumę w PLN. Dla przykładu: 100.00 PLN.',
	oneRequired: 'Prosimy wypełnić chociaż jedno z pól.',
	errorPrefix: 'Błąd: ',
	warningPrefix: 'Uwaga: ',

	// Form.Validator.Extras
	noSpace: 'W tym polu nie mogą znajdować się spacje.',
	reqChkByNode: 'Brak zaznaczonych elementów.',
	requiredChk: 'To pole jest wymagane.',
	reqChkByName: 'Prosimy wybrać z {label}.',
	match: 'To pole musi być takie samo jak {matchName}',
	startDate: 'data początkowa',
	endDate: 'data końcowa',
	currentDate: 'aktualna data',
	afterDate: 'Podana data poinna być taka sama lub po {label}.',
	beforeDate: 'Podana data poinna być taka sama lub przed {label}.',
	startMonth: 'Prosimy wybrać początkowy miesiąc.',
	sameMonth: 'Te dwie daty muszą być w zakresie tego samego miesiąca - wymagana jest zmiana któregoś z pól.'

});

/*
---

name: Locale.pt-PT.Date

description: Date messages for Portuguese.

license: MIT-style license

authors:
  - Fabio Miranda Costa

requires:
  - Locale

provides: [Locale.pt-PT.Date]

...
*/

Locale.define('pt-PT', 'Date', {

	months: ['Janeiro', 'Fevereiro', 'Março', 'Abril', 'Maio', 'Junho', 'Julho', 'Agosto', 'Setembro', 'Outubro', 'Novembro', 'Dezembro'],
	months_abbr: ['Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Out', 'Nov', 'Dez'],
	days: ['Domingo', 'Segunda-feira', 'Terça-feira', 'Quarta-feira', 'Quinta-feira', 'Sexta-feira', 'Sábado'],
	days_abbr: ['Dom', 'Seg', 'Ter', 'Qua', 'Qui', 'Sex', 'Sáb'],

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

	// Date.Extras
	ordinal: 'º',

	lessThanMinuteAgo: 'há menos de um minuto',
	minuteAgo: 'há cerca de um minuto',
	minutesAgo: 'há {delta} minutos',
	hourAgo: 'há cerca de uma hora',
	hoursAgo: 'há cerca de {delta} horas',
	dayAgo: 'há um dia',
	daysAgo: 'há {delta} dias',
	weekAgo: 'há uma semana',
	weeksAgo: 'há {delta} semanas',
	monthAgo: 'há um mês',
	monthsAgo: 'há {delta} meses',
	yearAgo: 'há um ano',
	yearsAgo: 'há {delta} anos',

	lessThanMinuteUntil: 'em menos de um minuto',
	minuteUntil: 'em um minuto',
	minutesUntil: 'em {delta} minutos',
	hourUntil: 'em uma hora',
	hoursUntil: 'em {delta} horas',
	dayUntil: 'em um dia',
	daysUntil: 'em {delta} dias',
	weekUntil: 'em uma semana',
	weeksUntil: 'em {delta} semanas',
	monthUntil: 'em um mês',
	monthsUntil: 'em {delta} meses',
	yearUntil: 'em um ano',
	yearsUntil: 'em {delta} anos'

});

/*
---

name: Locale.pt-BR.Date

description: Date messages for Portuguese (Brazil).

license: MIT-style license

authors:
  - Fabio Miranda Costa

requires:
  - Locale
  - Locale.pt-PT.Date

provides: [Locale.pt-BR.Date]

...
*/

Locale.define('pt-BR', 'Date', {

	// Culture's date order: DD/MM/YYYY
	shortDate: '%d/%m/%Y'

}).inherit('pt-PT', 'Date');

/*
---

name: Locale.pt-BR.Form.Validator

description: Form Validator messages for Portuguese (Brazil).

license: MIT-style license

authors:
  - Fábio Miranda Costa

requires:
  - Locale

provides: [Locale.pt-BR.Form.Validator]

...
*/

Locale.define('pt-BR', 'FormValidator', {

	required: 'Este campo é obrigatório.',
	minLength: 'Digite pelo menos {minLength} caracteres (tamanho atual: {length}).',
	maxLength: 'Não digite mais de {maxLength} caracteres (tamanho atual: {length}).',
	integer: 'Por favor digite apenas um número inteiro neste campo. Não são permitidos números decimais (por exemplo, 1,25).',
	numeric: 'Por favor digite apenas valores numéricos neste campo (por exemplo, "1" ou "1.1" ou "-1" ou "-1,1").',
	digits: 'Por favor use apenas números e pontuação neste campo (por exemplo, um número de telefone com traços ou pontos é permitido).',
	alpha: 'Por favor use somente letras (a-z). Espaço e outros caracteres não são permitidos.',
	alphanum: 'Use somente letras (a-z) ou números (0-9) neste campo. Espaço e outros caracteres não são permitidos.',
	dateSuchAs: 'Digite uma data válida, como {date}',
	dateInFormatMDY: 'Digite uma data válida, como DD/MM/YYYY (por exemplo, "31/12/1999")',
	email: 'Digite um endereço de email válido. Por exemplo "nome@dominio.com".',
	url: 'Digite uma URL válida. Exemplo: http://www.example.com.',
	currencyDollar: 'Digite um valor em dinheiro válido. Exemplo: R$100,00 .',
	oneRequired: 'Digite algo para pelo menos um desses campos.',
	errorPrefix: 'Erro: ',
	warningPrefix: 'Aviso: ',

	// Form.Validator.Extras
	noSpace: 'Não é possível digitar espaços neste campo.',
	reqChkByNode: 'Não foi selecionado nenhum item.',
	requiredChk: 'Este campo é obrigatório.',
	reqChkByName: 'Por favor digite um {label}.',
	match: 'Este campo deve ser igual ao campo {matchName}.',
	startDate: 'a data inicial',
	endDate: 'a data final',
	currentDate: 'a data atual',
	afterDate: 'A data deve ser igual ou posterior a {label}.',
	beforeDate: 'A data deve ser igual ou anterior a {label}.',
	startMonth: 'Por favor selecione uma data inicial.',
	sameMonth: 'Estas duas datas devem ter o mesmo mês - você deve modificar uma das duas.',
	creditcard: 'O número do cartão de crédito informado é inválido. Por favor verifique o valor e tente novamente. {length} números informados.'

});

/*
---

name: Locale.pt-BR.Number

description: Number messages for PT Brazilian.

license: MIT-style license

authors:
  - Arian Stolwijk
  - Danillo César

requires:
  - Locale

provides: [Locale.pt-BR.Number]

...
*/

Locale.define('pt-BR', 'Number', {

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

	currency: {
		prefix: 'R$ '
	}

});



/*
---

name: Locale.pt-PT.Form.Validator

description: Form Validator messages for Portuguese.

license: MIT-style license

authors:
  - Miquel Hudin

requires:
  - Locale

provides: [Locale.pt-PT.Form.Validator]

...
*/

Locale.define('pt-PT', 'FormValidator', {

	required: 'Este campo é necessário.',
	minLength: 'Digite pelo menos{minLength} caracteres (comprimento {length} caracteres).',
	maxLength: 'Não insira mais de {maxLength} caracteres (comprimento {length} caracteres).',
	integer: 'Digite um número inteiro neste domínio. Com números decimais (por exemplo, 1,25), não são permitidas.',
	numeric: 'Digite apenas valores numéricos neste domínio (p.ex., "1" ou "1.1" ou "-1" ou "-1,1").',
	digits: 'Por favor, use números e pontuação apenas neste campo (p.ex., um número de telefone com traços ou pontos é permitida).',
	alpha: 'Por favor use somente letras (a-z), com nesta área. Não utilize espaços nem outros caracteres são permitidos.',
	alphanum: 'Use somente letras (a-z) ou números (0-9) neste campo. Não utilize espaços nem outros caracteres são permitidos.',
	dateSuchAs: 'Digite uma data válida, como {date}',
	dateInFormatMDY: 'Digite uma data válida, como DD/MM/YYYY (p.ex. "31/12/1999")',
	email: 'Digite um endereço de email válido. Por exemplo "fred@domain.com".',
	url: 'Digite uma URL válida, como http://www.example.com.',
	currencyDollar: 'Digite um valor válido $. Por exemplo $ 100,00. ',
	oneRequired: 'Digite algo para pelo menos um desses insumos.',
	errorPrefix: 'Erro: ',
	warningPrefix: 'Aviso: '

});

/*
---

name: Locale.ru-RU-unicode.Date

description: Date messages for Russian (utf-8).

license: MIT-style license

authors:
  - Evstigneev Pavel
  - Kuryanovich Egor

requires:
  - Locale

provides: [Locale.ru-RU.Date]

...
*/

(function(){

// Russian language pluralization rules, taken from CLDR project, http://unicode.org/cldr/
// one -> n mod 10 is 1 and n mod 100 is not 11;
// few -> n mod 10 in 2..4 and n mod 100 not in 12..14;
// many -> n mod 10 is 0 or n mod 10 in 5..9 or n mod 100 in 11..14;
// other -> everything else (example 3.14)
var pluralize = function(n, one, few, many, other){
	var modulo10 = n % 10,
		modulo100 = n % 100;

	if (modulo10 == 1 && modulo100 != 11){
		return one;
	} else if ((modulo10 == 2 || modulo10 == 3 || modulo10 == 4) && !(modulo100 == 12 || modulo100 == 13 || modulo100 == 14)){
		return few;
	} else if (modulo10 == 0 || (modulo10 == 5 || modulo10 == 6 || modulo10 == 7 || modulo10 == 8 || modulo10 == 9) || (modulo100 == 11 || modulo100 == 12 || modulo100 == 13 || modulo100 == 14)){
		return many;
	} else {
		return other;
	}
};

Locale.define('ru-RU', 'Date', {

	months: ['Январь', 'Февраль', 'Март', 'Апрель', 'Май', 'Июнь', 'Июль', 'Август', 'Сентябрь', 'Октябрь', 'Ноябрь', 'Декабрь'],
	months_abbr: ['янв', 'февр', 'март', 'апр', 'май','июнь','июль','авг','сент','окт','нояб','дек'],
	days: ['Воскресенье', 'Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота'],
	days_abbr: ['Вс', 'Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб'],

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

	// Date.Extras
	ordinal: '',

	lessThanMinuteAgo: 'меньше минуты назад',
	minuteAgo: 'минуту назад',
	minutesAgo: function(delta){ return '{delta} ' + pluralize(delta, 'минуту', 'минуты', 'минут') + ' назад'; },
	hourAgo: 'час назад',
	hoursAgo: function(delta){ return '{delta} ' + pluralize(delta, 'час', 'часа', 'часов') + ' назад'; },
	dayAgo: 'вчера',
	daysAgo: function(delta){ return '{delta} ' + pluralize(delta, 'день', 'дня', 'дней') + ' назад'; },
	weekAgo: 'неделю назад',
	weeksAgo: function(delta){ return '{delta} ' + pluralize(delta, 'неделя', 'недели', 'недель') + ' назад'; },
	monthAgo: 'месяц назад',
	monthsAgo: function(delta){ return '{delta} ' + pluralize(delta, 'месяц', 'месяца', 'месяцев') + ' назад'; },
	yearAgo: 'год назад',
	yearsAgo: function(delta){ return '{delta} ' + pluralize(delta, 'год', 'года', 'лет') + ' назад'; },

	lessThanMinuteUntil: 'меньше чем через минуту',
	minuteUntil: 'через минуту',
	minutesUntil: function(delta){ return 'через {delta} ' + pluralize(delta, 'минуту', 'минуты', 'минут') + ''; },
	hourUntil: 'через час',
	hoursUntil: function(delta){ return 'через {delta} ' + pluralize(delta, 'час', 'часа', 'часов') + ''; },
	dayUntil: 'завтра',
	daysUntil: function(delta){ return 'через {delta} ' + pluralize(delta, 'день', 'дня', 'дней') + ''; },
	weekUntil: 'через неделю',
	weeksUntil: function(delta){ return 'через {delta} ' + pluralize(delta, 'неделю', 'недели', 'недель') + ''; },
	monthUntil: 'через месяц',
	monthsUntil: function(delta){ return 'через {delta} ' + pluralize(delta, 'месяц', 'месяца', 'месяцев') + ''; },
	yearUntil: 'через',
	yearsUntil: function(delta){ return 'через {delta} ' + pluralize(delta, 'год', 'года', 'лет') + ''; }

});



})();

/*
---

name: Locale.ru-RU-unicode.Form.Validator

description: Form Validator messages for Russian (utf-8).

license: MIT-style license

authors:
  - Chernodarov Egor

requires:
  - Locale

provides: [Locale.ru-RU.Form.Validator]

...
*/

Locale.define('ru-RU', 'FormValidator', {

	required: 'Это поле обязательно к заполнению.',
	minLength: 'Пожалуйста, введите хотя бы {minLength} символов (Вы ввели {length}).',
	maxLength: 'Пожалуйста, введите не больше {maxLength} символов (Вы ввели {length}).',
	integer: 'Пожалуйста, введите в это поле число. Дробные числа (например 1.25) тут не разрешены.',
	numeric: 'Пожалуйста, введите в это поле число (например "1" или "1.1", или "-1", или "-1.1").',
	digits: 'В этом поле Вы можете использовать только цифры и знаки пунктуации (например, телефонный номер со знаками дефиса или с точками).',
	alpha: 'В этом поле можно использовать только латинские буквы (a-z). Пробелы и другие символы запрещены.',
	alphanum: 'В этом поле можно использовать только латинские буквы (a-z) и цифры (0-9). Пробелы и другие символы запрещены.',
	dateSuchAs: 'Пожалуйста, введите корректную дату {date}',
	dateInFormatMDY: 'Пожалуйста, введите дату в формате ММ/ДД/ГГГГ (например "12/31/1999")',
	email: 'Пожалуйста, введите корректный емейл-адрес. Для примера "fred@domain.com".',
	url: 'Пожалуйста, введите правильную ссылку вида http://www.example.com.',
	currencyDollar: 'Пожалуйста, введите сумму в долларах. Например: $100.00 .',
	oneRequired: 'Пожалуйста, выберите хоть что-нибудь в одном из этих полей.',
	errorPrefix: 'Ошибка: ',
	warningPrefix: 'Внимание: '

});



/*
---

name: Locale.sk-SK.Date

description: Date messages for Slovak.

license: MIT-style license

authors:
  - Ivan Masár

requires:
  - Locale

provides: [Locale.sk-SK.Date]

...
*/
(function(){

// Slovak language pluralization rules, see http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html
// one -> n is 1;            1
// few -> n in 2..4;         2-4
// other -> everything else  0, 5-999, 1.31, 2.31, 5.31...
var pluralize = function(n, one, few, other){
	if (n == 1) return one;
	else if (n == 2 || n == 3 || n == 4) return few;
	else return other;
};

Locale.define('sk-SK', 'Date', {

	months: ['Január', 'Február', 'Marec', 'Apríl', 'Máj', 'Jún', 'Júl', 'August', 'September', 'Október', 'November', 'December'],
	months_abbr: ['januára', 'februára', 'marca', 'apríla', 'mája', 'júna', 'júla', 'augusta', 'septembra', 'októbra', 'novembra', 'decembra'],
	days: ['Nedele', 'Pondelí', 'Úterý', 'Streda', 'Čtvrtek', 'Pátek', 'Sobota'],
	days_abbr: ['ne', 'po', 'ut', 'st', 'št', 'pi', 'so'],

	// Culture's date order: DD.MM.YYYY
	dateOrder: ['date', 'month', 'year'],
	shortDate: '%d.%m.%Y',
	shortTime: '%H:%M',
	AM: 'dop.',
	PM: 'pop.',
	firstDayOfWeek: 1,

	// Date.Extras
	ordinal: '.',

	lessThanMinuteAgo: 'pred chvíľou',
	minuteAgo: 'približne pred minútou',
	minutesAgo: function(delta){ return 'pred {delta} ' + pluralize(delta, 'minútou', 'minútami', 'minútami'); },
	hourAgo: 'približne pred hodinou',
	hoursAgo: function(delta){ return 'pred {delta} ' + pluralize(delta, 'hodinou', 'hodinami', 'hodinami'); },
	dayAgo: 'pred dňom',
	daysAgo: function(delta){ return 'pred {delta} ' + pluralize(delta, 'dňom', 'dňami', 'dňami'); },
	weekAgo: 'pred týždňom',
	weeksAgo: function(delta){ return 'pred {delta} ' + pluralize(delta, 'týždňom', 'týždňami', 'týždňami'); },
	monthAgo: 'pred mesiacom',
	monthsAgo: function(delta){ return 'pred {delta} ' + pluralize(delta, 'mesiacom', 'mesiacmi', 'mesiacmi'); },
	yearAgo: 'pred rokom',
	yearsAgo: function(delta){ return 'pred {delta} ' + pluralize(delta, 'rokom', 'rokmi', 'rokmi'); },

	lessThanMinuteUntil: 'o chvíľu',
	minuteUntil: 'približne o minútu',
	minutesUntil: function(delta){ return 'o {delta} ' + pluralize(delta, 'minútu', 'minúty', 'minúty'); },
	hourUntil: 'približne o hodinu',
	hoursUntil: function(delta){ return 'o {delta} ' + pluralize(delta, 'hodinu', 'hodiny', 'hodín'); },
	dayUntil: 'o deň',
	daysUntil: function(delta){ return 'o {delta} ' + pluralize(delta, 'deň', 'dni', 'dní'); },
	weekUntil: 'o týždeň',
	weeksUntil: function(delta){ return 'o {delta} ' + pluralize(delta, 'týždeň', 'týždne', 'týždňov'); },
	monthUntil: 'o mesiac',
	monthsUntil: function(delta){ return 'o {delta} ' + pluralize(delta, 'mesiac', 'mesiace', 'mesiacov'); },
	yearUntil: 'o rok',
	yearsUntil: function(delta){ return 'o {delta} ' + pluralize(delta, 'rok', 'roky', 'rokov'); }
});

})();

/*
---

name: Locale.sk-SK.Form.Validator

description: Form Validator messages for Czech.

license: MIT-style license

authors:
  - Ivan Masár

requires:
  - Locale

provides: [Locale.sk-SK.Form.Validator]

...
*/

Locale.define('sk-SK', 'FormValidator', {

	required: 'Táto položka je povinná.',
	minLength: 'Zadajte prosím aspoň {minLength} znakov (momentálne {length} znakov).',
	maxLength: 'Zadajte prosím menej ako {maxLength} znakov (momentálne {length} znakov).',
	integer: 'Zadajte prosím celé číslo. Desetinné čísla (napr. 1.25) nie sú povolené.',
	numeric: 'Zadajte len číselné hodnoty (t.j. „1“ alebo „1.1“ alebo „-1“ alebo „-1.1“).',
	digits: 'Zadajte prosím len čísla a interpunkčné znamienka (napríklad telefónne číslo s pomlčkami albo bodkami je povolené).',
	alpha: 'Zadajte prosím len písmená (a-z). Medzery alebo iné znaky nie sú povolené.',
	alphanum: 'Zadajte prosím len písmená (a-z) alebo číslice (0-9). Medzery alebo iné znaky nie sú povolené.',
	dateSuchAs: 'Zadajte prosím platný dátum v tvare {date}',
	dateInFormatMDY: 'Zadajte prosím platný datum v tvare MM / DD / RRRR (t.j. „12/31/1999“)',
	email: 'Zadajte prosím platnú emailovú adresu. Napríklad „fred@domain.com“.',
	url: 'Zadajte prosím platnoú adresu URL v tvare http://www.example.com.',
	currencyDollar: 'Zadajte prosím platnú čiastku. Napríklad $100.00.',
	oneRequired: 'Zadajte prosím aspoň jednu hodnotu z týchto položiek.',
	errorPrefix: 'Chyba: ',
	warningPrefix: 'Upozornenie: ',

	// Form.Validator.Extras
	noSpace: 'V tejto položle nie sú povolené medzery',
	reqChkByNode: 'Nie sú vybrané žiadne položky.',
	requiredChk: 'Táto položka je povinná.',
	reqChkByName: 'Prosím vyberte {label}.',
	match: 'Táto položka sa musí zhodovať s položkou {matchName}',
	startDate: 'dátum začiatku',
	endDate: 'dátum ukončenia',
	currendDate: 'aktuálny dátum',
	afterDate: 'Dátum by mal býť rovnaký alebo väčší ako {label}.',
	beforeDate: 'Dátum by mal byť rovnaký alebo menší ako {label}.',
	startMonth: 'Vyberte počiatočný mesiac.',
	sameMonth: 'Tieto dva dátumy musia býť v rovnakom mesiaci - zmeňte jeden z nich.',
	creditcard: 'Zadané číslo kreditnej karty je neplatné. Prosím, opravte ho. Bolo zadaných {length} číslic.'

});

/*
---

name: Locale.si-SI.Date

description: Date messages for Slovenian.

license: MIT-style license

authors:
  - Radovan Lozej

requires:
  - Locale

provides: [Locale.si-SI.Date]

...
*/

(function(){

var pluralize = function(n, one, two, three, other){
	return (n >= 1 && n <= 3) ? arguments[n] : other;
};

Locale.define('sl-SI', 'Date', {

	months: ['januar', 'februar', 'marec', 'april', 'maj', 'junij', 'julij', 'avgust', 'september', 'oktober', 'november', 'december'],
	months_abbr: ['jan', 'feb', 'mar', 'apr', 'maj', 'jun', 'jul', 'avg', 'sep', 'okt', 'nov', 'dec'],
	days: ['nedelja', 'ponedeljek', 'torek', 'sreda', 'četrtek', 'petek', 'sobota'],
	days_abbr: ['ned', 'pon', 'tor', 'sre', 'čet', 'pet', 'sob'],

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

	// Date.Extras
	ordinal: '.',

	lessThanMinuteAgo: 'manj kot minuto nazaj',
	minuteAgo: 'minuto nazaj',
	minutesAgo: function(delta){ return '{delta} ' + pluralize(delta, 'minuto', 'minuti', 'minute', 'minut') + ' nazaj'; },
	hourAgo: 'uro nazaj',
	hoursAgo: function(delta){ return '{delta} ' + pluralize(delta, 'uro', 'uri', 'ure', 'ur') + ' nazaj'; },
	dayAgo: 'dan nazaj',
	daysAgo: function(delta){ return '{delta} ' + pluralize(delta, 'dan', 'dneva', 'dni', 'dni') + ' nazaj'; },
	weekAgo: 'teden nazaj',
	weeksAgo: function(delta){ return '{delta} ' + pluralize(delta, 'teden', 'tedna', 'tedne', 'tednov') + ' nazaj'; },
	monthAgo: 'mesec nazaj',
	monthsAgo: function(delta){ return '{delta} ' + pluralize(delta, 'mesec', 'meseca', 'mesece', 'mesecov') + ' nazaj'; },
	yearthAgo: 'leto nazaj',
	yearsAgo: function(delta){ return '{delta} ' + pluralize(delta, 'leto', 'leti', 'leta', 'let') + ' nazaj'; },

	lessThanMinuteUntil: 'še manj kot minuto',
	minuteUntil: 'še minuta',
	minutesUntil: function(delta){ return 'še {delta} ' + pluralize(delta, 'minuta', 'minuti', 'minute', 'minut'); },
	hourUntil: 'še ura',
	hoursUntil: function(delta){ return 'še {delta} ' + pluralize(delta, 'ura', 'uri', 'ure', 'ur'); },
	dayUntil: 'še dan',
	daysUntil: function(delta){ return 'še {delta} ' + pluralize(delta, 'dan', 'dneva', 'dnevi', 'dni'); },
	weekUntil: 'še tedn',
	weeksUntil: function(delta){ return 'še {delta} ' + pluralize(delta, 'teden', 'tedna', 'tedni', 'tednov'); },
	monthUntil: 'še mesec',
	monthsUntil: function(delta){ return 'še {delta} ' + pluralize(delta, 'mesec', 'meseca', 'meseci', 'mesecov'); },
	yearUntil: 'še leto',
	yearsUntil: function(delta){ return 'še {delta} ' + pluralize(delta, 'leto', 'leti', 'leta', 'let'); }

});

})();

/*
---

name: Locale.si-SI.Form.Validator

description: Form Validator messages for Slovenian.

license: MIT-style license

authors:
  - Radovan Lozej

requires:
  - Locale

provides: [Locale.si-SI.Form.Validator]

...
*/

Locale.define('sl-SI', 'FormValidator', {

	required: 'To polje je obvezno',
	minLength: 'Prosim, vnesite vsaj {minLength} znakov (vnesli ste {length} znakov).',
	maxLength: 'Prosim, ne vnesite več kot {maxLength} znakov (vnesli ste {length} znakov).',
	integer: 'Prosim, vnesite celo število. Decimalna števila (kot 1,25) niso dovoljena.',
	numeric: 'Prosim, vnesite samo numerične vrednosti (kot "1" ali "1.1" ali "-1" ali "-1.1").',
	digits: 'Prosim, uporabite številke in ločila le na tem polju (na primer, dovoljena je telefonska številka z pomišlaji ali pikami).',
	alpha: 'Prosim, uporabite le črke v tem plju. Presledki in drugi znaki niso dovoljeni.',
	alphanum: 'Prosim, uporabite samo črke ali številke v tem polju. Presledki in drugi znaki niso dovoljeni.',
	dateSuchAs: 'Prosim, vnesite pravilen datum kot {date}',
	dateInFormatMDY: 'Prosim, vnesite pravilen datum kot MM.DD.YYYY (primer "12.31.1999")',
	email: 'Prosim, vnesite pravilen email naslov. Na primer "fred@domain.com".',
	url: 'Prosim, vnesite pravilen URL kot http://www.example.com.',
	currencyDollar: 'Prosim, vnesit epravilno vrednost €. Primer 100,00€ .',
	oneRequired: 'Prosimo, vnesite nekaj za vsaj eno izmed teh polj.',
	errorPrefix: 'Napaka: ',
	warningPrefix: 'Opozorilo: ',

	// Form.Validator.Extras
	noSpace: 'To vnosno polje ne dopušča presledkov.',
	reqChkByNode: 'Nič niste izbrali.',
	requiredChk: 'To polje je obvezno',
	reqChkByName: 'Prosim, izberite {label}.',
	match: 'To polje se mora ujemati z poljem {matchName}',
	startDate: 'datum začetka',
	endDate: 'datum konca',
	currentDate: 'trenuten datum',
	afterDate: 'Datum bi moral biti isti ali po {label}.',
	beforeDate: 'Datum bi moral biti isti ali pred {label}.',
	startMonth: 'Prosim, vnesite začetni datum',
	sameMonth: 'Ta dva datuma morata biti v istem mesecu - premeniti morate eno ali drugo.',
	creditcard: 'Številka kreditne kartice ni pravilna. Preverite številko ali poskusite še enkrat. Vnešenih {length} znakov.'

});

/*
---

name: Locale.sv-SE.Date

description: Date messages for Swedish.

license: MIT-style license

authors:
  - Martin Lundgren

requires:
  - Locale

provides: [Locale.sv-SE.Date]

...
*/

Locale.define('sv-SE', 'Date', {

	months: ['januari', 'februari', 'mars', 'april', 'maj', 'juni', 'juli', 'augusti', 'september', 'oktober', 'november', 'december'],
	months_abbr: ['jan', 'feb', 'mar', 'apr', 'maj', 'jun', 'jul', 'aug', 'sep', 'okt', 'nov', 'dec'],
	days: ['söndag', 'måndag', 'tisdag', 'onsdag', 'torsdag', 'fredag', 'lördag'],
	days_abbr: ['sön', 'mån', 'tis', 'ons', 'tor', 'fre', 'lör'],

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

	// Date.Extras
	ordinal: '',

	lessThanMinuteAgo: 'mindre än en minut sedan',
	minuteAgo: 'ungefär en minut sedan',
	minutesAgo: '{delta} minuter sedan',
	hourAgo: 'ungefär en timme sedan',
	hoursAgo: 'ungefär {delta} timmar sedan',
	dayAgo: '1 dag sedan',
	daysAgo: '{delta} dagar sedan',

	lessThanMinuteUntil: 'mindre än en minut sedan',
	minuteUntil: 'ungefär en minut sedan',
	minutesUntil: '{delta} minuter sedan',
	hourUntil: 'ungefär en timme sedan',
	hoursUntil: 'ungefär {delta} timmar sedan',
	dayUntil: '1 dag sedan',
	daysUntil: '{delta} dagar sedan'

});

/*
---

name: Locale.sv-SE.Form.Validator

description: Form Validator messages for Swedish.

license: MIT-style license

authors:
  - Martin Lundgren

requires:
  - Locale

provides: [Locale.sv-SE.Form.Validator]

...
*/

Locale.define('sv-SE', 'FormValidator', {

	required: 'Fältet är obligatoriskt.',
	minLength: 'Ange minst {minLength} tecken (du angav {length} tecken).',
	maxLength: 'Ange högst {maxLength} tecken (du angav {length} tecken). ',
	integer: 'Ange ett heltal i fältet. Tal med decimaler (t.ex. 1,25) är inte tillåtna.',
	numeric: 'Ange endast numeriska värden i detta fält (t.ex. "1" eller "1.1" eller "-1" eller "-1,1").',
	digits: 'Använd endast siffror och skiljetecken i detta fält (till exempel ett telefonnummer med bindestreck tillåtet).',
	alpha: 'Använd endast bokstäver (a-ö) i detta fält. Inga mellanslag eller andra tecken är tillåtna.',
	alphanum: 'Använd endast bokstäver (a-ö) och siffror (0-9) i detta fält. Inga mellanslag eller andra tecken är tillåtna.',
	dateSuchAs: 'Ange ett giltigt datum som t.ex. {date}',
	dateInFormatMDY: 'Ange ett giltigt datum som t.ex. YYYY-MM-DD (i.e. "1999-12-31")',
	email: 'Ange en giltig e-postadress. Till exempel "erik@domain.com".',
	url: 'Ange en giltig webbadress som http://www.example.com.',
	currencyDollar: 'Ange en giltig belopp. Exempelvis 100,00.',
	oneRequired: 'Vänligen ange minst ett av dessa alternativ.',
	errorPrefix: 'Fel: ',
	warningPrefix: 'Varning: ',

	// Form.Validator.Extras
	noSpace: 'Det får inte finnas några mellanslag i detta fält.',
	reqChkByNode: 'Inga objekt är valda.',
	requiredChk: 'Detta är ett obligatoriskt fält.',
	reqChkByName: 'Välj en {label}.',
	match: 'Detta fält måste matcha {matchName}',
	startDate: 'startdatumet',
	endDate: 'slutdatum',
	currentDate: 'dagens datum',
	afterDate: 'Datumet bör vara samma eller senare än {label}.',
	beforeDate: 'Datumet bör vara samma eller tidigare än {label}.',
	startMonth: 'Välj en start månad',
	sameMonth: 'Dessa två datum måste vara i samma månad - du måste ändra det ena eller det andra.'

});

/*
---

name: Locale.sv-SE.Number

description: Number messages for Swedish.

license: MIT-style license

authors:
  - Arian Stolwijk
  - Martin Lundgren

requires:
  - Locale
  - Locale.EU.Number

provides: [Locale.sv-SE.Number]

...
*/

Locale.define('sv-SE', 'Number', {

	currency: {
		prefix: 'SEK '
	}

}).inherit('EU', 'Number');

/*
---

name: Locale.tr-TR.Date

description: Date messages for Turkish.

license: MIT-style license

authors:
  - Faruk Can Bilir

requires:
  - Locale

provides: [Locale.tr-TR.Date]

...
*/

Locale.define('tr-TR', 'Date', {

	months: ['Ocak', 'Şubat', 'Mart', 'Nisan', 'Mayıs', 'Haziran', 'Temmuz', 'Ağustos', 'Eylül', 'Ekim', 'Kasım', 'Aralık'],
	months_abbr: ['Oca', 'Şub', 'Mar', 'Nis', 'May', 'Haz', 'Tem', 'Ağu', 'Eyl', 'Eki', 'Kas', 'Ara'],
	days: ['Pazar', 'Pazartesi', 'Salı', 'Çarşamba', 'Perşembe', 'Cuma', 'Cumartesi'],
	days_abbr: ['Pa', 'Pzt', 'Sa', 'Ça', 'Pe', 'Cu', 'Cmt'],

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

	// Date.Extras
	ordinal: '',

	lessThanMinuteAgo: 'bir dakikadan önce',
	minuteAgo: 'yaklaşık bir dakika önce',
	minutesAgo: '{delta} dakika önce',
	hourAgo: 'bir saat kadar önce',
	hoursAgo: '{delta} saat kadar önce',
	dayAgo: 'bir gün önce',
	daysAgo: '{delta} gün önce',
	weekAgo: 'bir hafta önce',
	weeksAgo: '{delta} hafta önce',
	monthAgo: 'bir ay önce',
	monthsAgo: '{delta} ay önce',
	yearAgo: 'bir yıl önce',
	yearsAgo: '{delta} yıl önce',

	lessThanMinuteUntil: 'bir dakikadan az sonra',
	minuteUntil: 'bir dakika kadar sonra',
	minutesUntil: '{delta} dakika sonra',
	hourUntil: 'bir saat kadar sonra',
	hoursUntil: '{delta} saat kadar sonra',
	dayUntil: 'bir gün sonra',
	daysUntil: '{delta} gün sonra',
	weekUntil: 'bir hafta sonra',
	weeksUntil: '{delta} hafta sonra',
	monthUntil: 'bir ay sonra',
	monthsUntil: '{delta} ay sonra',
	yearUntil: 'bir yıl sonra',
	yearsUntil: '{delta} yıl sonra'

});

/*
---

name: Locale.tr-TR.Form.Validator

description: Form Validator messages for Turkish.

license: MIT-style license

authors:
  - Faruk Can Bilir

requires:
  - Locale

provides: [Locale.tr-TR.Form.Validator]

...
*/

Locale.define('tr-TR', 'FormValidator', {

	required: 'Bu alan zorunlu.',
	minLength: 'Lütfen en az {minLength} karakter girin (siz {length} karakter girdiniz).',
	maxLength: 'Lütfen en fazla {maxLength} karakter girin (siz {length} karakter girdiniz).',
	integer: 'Lütfen bu alana sadece tamsayı girin. Ondalıklı sayılar (ör: 1.25) kullanılamaz.',
	numeric: 'Lütfen bu alana sadece sayısal değer girin (ör: "1", "1.1", "-1" ya da "-1.1").',
	digits: 'Lütfen bu alana sadece sayısal değer ve noktalama işareti girin (örneğin, nokta ve tire içeren bir telefon numarası kullanılabilir).',
	alpha: 'Lütfen bu alanda yalnızca harf kullanın. Boşluk ve diğer karakterler kullanılamaz.',
	alphanum: 'Lütfen bu alanda sadece harf ve rakam kullanın. Boşluk ve diğer karakterler kullanılamaz.',
	dateSuchAs: 'Lütfen geçerli bir tarih girin (Ör: {date})',
	dateInFormatMDY: 'Lütfen geçerli bir tarih girin (GG/AA/YYYY, ör: "31/12/1999")',
	email: 'Lütfen geçerli bir email adresi girin. Ör: "kemal@etikan.com".',
	url: 'Lütfen geçerli bir URL girin. Ör: http://www.example.com.',
	currencyDollar: 'Lütfen geçerli bir TL miktarı girin. Ör: 100,00 TL .',
	oneRequired: 'Lütfen en az bir tanesini doldurun.',
	errorPrefix: 'Hata: ',
	warningPrefix: 'Uyarı: ',

	// Form.Validator.Extras
	noSpace: 'Bu alanda boşluk kullanılamaz.',
	reqChkByNode: 'Hiçbir öğe seçilmemiş.',
	requiredChk: 'Bu alan zorunlu.',
	reqChkByName: 'Lütfen bir {label} girin.',
	match: 'Bu alan, {matchName} alanıyla uyuşmalı',
	startDate: 'başlangıç tarihi',
	endDate: 'bitiş tarihi',
	currentDate: 'bugünün tarihi',
	afterDate: 'Tarih, {label} tarihiyle aynı gün ya da ondan sonra olmalıdır.',
	beforeDate: 'Tarih, {label} tarihiyle aynı gün ya da ondan önce olmalıdır.',
	startMonth: 'Lütfen bir başlangıç ayı seçin',
	sameMonth: 'Bu iki tarih aynı ayda olmalı - bir tanesini değiştirmeniz gerekiyor.',
	creditcard: 'Girdiğiniz kredi kartı numarası geçersiz. Lütfen kontrol edip tekrar deneyin. {length} hane girildi.'

});

/*
---

name: Locale.tr-TR.Number

description: Number messages for Turkish.

license: MIT-style license

authors:
  - Faruk Can Bilir

requires:
  - Locale
  - Locale.EU.Number

provides: [Locale.tr-TR.Number]

...
*/

Locale.define('tr-TR', 'Number', {

	currency: {
		decimals: 0,
		suffix: ' TL'
	}

}).inherit('EU', 'Number');

/*
---

name: Locale.uk-UA.Date

description: Date messages for Ukrainian (utf-8).

license: MIT-style license

authors:
  - Slik

requires:
  - Locale

provides: [Locale.uk-UA.Date]

...
*/

(function(){

var pluralize = function(n, one, few, many, other){
	var d = (n / 10).toInt(),
		z = n % 10,
		s = (n / 100).toInt();

	if (d == 1 && n > 10) return many;
	if (z == 1) return one;
	if (z > 0 && z < 5) return few;
	return many;
};

Locale.define('uk-UA', 'Date', {

	months: ['Січень', 'Лютий', 'Березень', 'Квітень', 'Травень', 'Червень', 'Липень', 'Серпень', 'Вересень', 'Жовтень', 'Листопад', 'Грудень'],
	months_abbr: ['Січ', 'Лют', 'Бер', 'Квіт', 'Трав', 'Черв', 'Лип', 'Серп', 'Вер', 'Жовт', 'Лист', 'Груд' ],
	days: ['Неділя', 'Понеділок', 'Вівторок', 'Середа', 'Четвер', "П'ятниця", 'Субота'],
	days_abbr: ['Нд', 'Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб'],

	// Culture's date order: DD/MM/YYYY
	dateOrder: ['date', 'month', 'year'],
	shortDate: '%d/%m/%Y',
	shortTime: '%H:%M',
	AM: 'до полудня',
	PM: 'по полудню',
	firstDayOfWeek: 1,

	// Date.Extras
	ordinal: '',

	lessThanMinuteAgo: 'меньше хвилини тому',
	minuteAgo: 'хвилину тому',
	minutesAgo: function(delta){ return '{delta} ' + pluralize(delta, 'хвилину', 'хвилини', 'хвилин') + ' тому'; },
	hourAgo: 'годину тому',
	hoursAgo: function(delta){ return '{delta} ' + pluralize(delta, 'годину', 'години', 'годин') + ' тому'; },
	dayAgo: 'вчора',
	daysAgo: function(delta){ return '{delta} ' + pluralize(delta, 'день', 'дня', 'днів') + ' тому'; },
	weekAgo: 'тиждень тому',
	weeksAgo: function(delta){ return '{delta} ' + pluralize(delta, 'тиждень', 'тижні', 'тижнів') + ' тому'; },
	monthAgo: 'місяць тому',
	monthsAgo: function(delta){ return '{delta} ' + pluralize(delta, 'місяць', 'місяці', 'місяців') + ' тому'; },
	yearAgo: 'рік тому',
	yearsAgo: function(delta){ return '{delta} ' + pluralize(delta, 'рік', 'роки', 'років') + ' тому'; },

	lessThanMinuteUntil: 'за мить',
	minuteUntil: 'через хвилину',
	minutesUntil: function(delta){ return 'через {delta} ' + pluralize(delta, 'хвилину', 'хвилини', 'хвилин'); },
	hourUntil: 'через годину',
	hoursUntil: function(delta){ return 'через {delta} ' + pluralize(delta, 'годину', 'години', 'годин'); },
	dayUntil: 'завтра',
	daysUntil: function(delta){ return 'через {delta} ' + pluralize(delta, 'день', 'дня', 'днів'); },
	weekUntil: 'через тиждень',
	weeksUntil: function(delta){ return 'через {delta} ' + pluralize(delta, 'тиждень', 'тижні', 'тижнів'); },
	monthUntil: 'через місяць',
	monthesUntil: function(delta){ return 'через {delta} ' + pluralize(delta, 'місяць', 'місяці', 'місяців'); },
	yearUntil: 'через рік',
	yearsUntil: function(delta){ return 'через {delta} ' + pluralize(delta, 'рік', 'роки', 'років'); }

});

})();

/*
---

name: Locale.uk-UA.Form.Validator

description: Form Validator messages for Ukrainian (utf-8).

license: MIT-style license

authors:
  - Slik

requires:
  - Locale

provides: [Locale.uk-UA.Form.Validator]

...
*/

Locale.define('uk-UA', 'FormValidator', {

	required: 'Це поле повинне бути заповненим.',
	minLength: 'Введіть хоча б {minLength} символів (Ви ввели {length}).',
	maxLength: 'Кількість символів не може бути більше {maxLength} (Ви ввели {length}).',
	integer: 'Введіть в це поле число. Дробові числа (наприклад 1.25) не дозволені.',
	numeric: 'Введіть в це поле число (наприклад "1" або "1.1", або "-1", або "-1.1").',
	digits: 'В цьому полі ви можете використовувати лише цифри і знаки пунктіації (наприклад, телефонний номер з знаками дефізу або з крапками).',
	alpha: 'В цьому полі можна використовувати лише латинські літери (a-z). Пробіли і інші символи заборонені.',
	alphanum: 'В цьому полі можна використовувати лише латинські літери (a-z) і цифри (0-9). Пробіли і інші символи заборонені.',
	dateSuchAs: 'Введіть коректну дату {date}.',
	dateInFormatMDY: 'Введіть дату в форматі ММ/ДД/РРРР (наприклад "12/31/2009").',
	email: 'Введіть коректну адресу електронної пошти (наприклад "name@domain.com").',
	url: 'Введіть коректне інтернет-посилання (наприклад http://www.example.com).',
	currencyDollar: 'Введіть суму в доларах (наприклад "$100.00").',
	oneRequired: 'Заповніть одне з полів.',
	errorPrefix: 'Помилка: ',
	warningPrefix: 'Увага: ',

	noSpace: 'Пробіли заборонені.',
	reqChkByNode: 'Не відмічено жодного варіанту.',
	requiredChk: 'Це поле повинне бути віміченим.',
	reqChkByName: 'Будь ласка, відмітьте {label}.',
	match: 'Це поле повинно відповідати {matchName}',
	startDate: 'початкова дата',
	endDate: 'кінцева дата',
	currentDate: 'сьогоднішня дата',
	afterDate: 'Ця дата повинна бути такою ж, або пізнішою за {label}.',
	beforeDate: 'Ця дата повинна бути такою ж, або ранішою за {label}.',
	startMonth: 'Будь ласка, виберіть початковий місяць',
	sameMonth: 'Ці дати повинні відноситись одного і того ж місяця. Будь ласка, змініть одну з них.',
	creditcard: 'Номер кредитної карти введений неправильно. Будь ласка, перевірте його. Введено {length} символів.'

});

/*
---

name: Locale.zh-CH.Date

description: Date messages for Chinese (simplified and traditional).

license: MIT-style license

authors:
  - YMind Chan

requires:
  - Locale

provides: [Locale.zh-CH.Date]

...
*/

// Simplified Chinese
Locale.define('zh-CHS', 'Date', {

	months: ['一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月'],
	months_abbr: ['一', '二', '三', '四', '五', '六', '七', '八', '九', '十', '十一', '十二'],
	days: ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'],
	days_abbr: ['日', '一', '二', '三', '四', '五', '六'],

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

	// Date.Extras
	ordinal: '',

	lessThanMinuteAgo: '不到1分钟前',
	minuteAgo: '大约1分钟前',
	minutesAgo: '{delta}分钟之前',
	hourAgo: '大约1小时前',
	hoursAgo: '大约{delta}小时前',
	dayAgo: '1天前',
	daysAgo: '{delta}天前',
	weekAgo: '1星期前',
	weeksAgo: '{delta}星期前',
	monthAgo: '1个月前',
	monthsAgo: '{delta}个月前',
	yearAgo: '1年前',
	yearsAgo: '{delta}年前',

	lessThanMinuteUntil: '从现在开始不到1分钟',
	minuteUntil: '从现在开始約1分钟',
	minutesUntil: '从现在开始约{delta}分钟',
	hourUntil: '从现在开始1小时',
	hoursUntil: '从现在开始约{delta}小时',
	dayUntil: '从现在开始1天',
	daysUntil: '从现在开始{delta}天',
	weekUntil: '从现在开始1星期',
	weeksUntil: '从现在开始{delta}星期',
	monthUntil: '从现在开始一个月',
	monthsUntil: '从现在开始{delta}个月',
	yearUntil: '从现在开始1年',
	yearsUntil: '从现在开始{delta}年'

});

// Traditional Chinese
Locale.define('zh-CHT', 'Date', {

	months: ['一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月'],
	months_abbr: ['一', '二', '三', '四', '五', '六', '七', '八', '九', '十', '十一', '十二'],
	days: ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'],
	days_abbr: ['日', '一', '二', '三', '四', '五', '六'],

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

	// Date.Extras
	ordinal: '',

	lessThanMinuteAgo: '不到1分鐘前',
	minuteAgo: '大約1分鐘前',
	minutesAgo: '{delta}分鐘之前',
	hourAgo: '大約1小時前',
	hoursAgo: '大約{delta}小時前',
	dayAgo: '1天前',
	daysAgo: '{delta}天前',
	weekAgo: '1星期前',
	weeksAgo: '{delta}星期前',
	monthAgo: '1个月前',
	monthsAgo: '{delta}个月前',
	yearAgo: '1年前',
	yearsAgo: '{delta}年前',

	lessThanMinuteUntil: '從現在開始不到1分鐘',
	minuteUntil: '從現在開始約1分鐘',
	minutesUntil: '從現在開始約{delta}分鐘',
	hourUntil: '從現在開始1小時',
	hoursUntil: '從現在開始約{delta}小時',
	dayUntil: '從現在開始1天',
	daysUntil: '從現在開始{delta}天',
	weekUntil: '從現在開始1星期',
	weeksUntil: '從現在開始{delta}星期',
	monthUntil: '從現在開始一個月',
	monthsUntil: '從現在開始{delta}個月',
	yearUntil: '從現在開始1年',
	yearsUntil: '從現在開始{delta}年'

});

/*
---

name: Locale.zh-CH.Form.Validator

description: Form Validator messages for Chinese (simplified and traditional).

license: MIT-style license

authors:
  - YMind Chan

requires:
  - Locale
  - Form.Validator

provides: [Form.zh-CH.Form.Validator, Form.Validator.CurrencyYuanValidator]

...
*/

// Simplified Chinese
Locale.define('zh-CHS', 'FormValidator', {

	required: '此项必填。',
	minLength: '请至少输入 {minLength} 个字符 (已输入 {length} 个)。',
	maxLength: '最多只能输入 {maxLength} 个字符 (已输入 {length} 个)。',
	integer: '请输入一个整数，不能包含小数点。例如："1", "200"。',
	numeric: '请输入一个数字，例如："1", "1.1", "-1", "-1.1"。',
	digits: '请输入由数字和标点符号组成的内容。例如电话号码。',
	alpha: '请输入 A-Z 的 26 个字母，不能包含空格或任何其他字符。',
	alphanum: '请输入 A-Z 的 26 个字母或 0-9 的 10 个数字，不能包含空格或任何其他字符。',
	dateSuchAs: '请输入合法的日期格式，如：{date}。',
	dateInFormatMDY: '请输入合法的日期格式，例如：YYYY-MM-DD ("2010-12-31")。',
	email: '请输入合法的电子信箱地址，例如："fred@domain.com"。',
	url: '请输入合法的 Url 地址，例如：http://www.example.com。',
	currencyDollar: '请输入合法的货币符号，例如：￥100.0',
	oneRequired: '请至少选择一项。',
	errorPrefix: '错误：',
	warningPrefix: '警告：',

	// Form.Validator.Extras
	noSpace: '不能包含空格。',
	reqChkByNode: '未选择任何内容。',
	requiredChk: '此项必填。',
	reqChkByName: '请选择 {label}.',
	match: '必须与{matchName}相匹配',
	startDate: '起始日期',
	endDate: '结束日期',
	currentDate: '当前日期',
	afterDate: '日期必须等于或晚于 {label}.',
	beforeDate: '日期必须早于或等于 {label}.',
	startMonth: '请选择起始月份',
	sameMonth: '您必须修改两个日期中的一个，以确保它们在同一月份。',
	creditcard: '您输入的信用卡号码不正确。当前已输入{length}个字符。'

});

// Traditional Chinese
Locale.define('zh-CHT', 'FormValidator', {

	required: '此項必填。 ',
	minLength: '請至少輸入{minLength} 個字符(已輸入{length} 個)。 ',
	maxLength: '最多只能輸入{maxLength} 個字符(已輸入{length} 個)。 ',
	integer: '請輸入一個整數，不能包含小數點。例如："1", "200"。 ',
	numeric: '請輸入一個數字，例如："1", "1.1", "-1", "-1.1"。 ',
	digits: '請輸入由數字和標點符號組成的內容。例如電話號碼。 ',
	alpha: '請輸入AZ 的26 個字母，不能包含空格或任何其他字符。 ',
	alphanum: '請輸入AZ 的26 個字母或0-9 的10 個數字，不能包含空格或任何其他字符。 ',
	dateSuchAs: '請輸入合法的日期格式，如：{date}。 ',
	dateInFormatMDY: '請輸入合法的日期格式，例如：YYYY-MM-DD ("2010-12-31")。 ',
	email: '請輸入合法的電子信箱地址，例如："fred@domain.com"。 ',
	url: '請輸入合法的Url 地址，例如：http://www.example.com。 ',
	currencyDollar: '請輸入合法的貨幣符號，例如：￥100.0',
	oneRequired: '請至少選擇一項。 ',
	errorPrefix: '錯誤：',
	warningPrefix: '警告：',

	// Form.Validator.Extras
	noSpace: '不能包含空格。 ',
	reqChkByNode: '未選擇任何內容。 ',
	requiredChk: '此項必填。 ',
	reqChkByName: '請選擇 {label}.',
	match: '必須與{matchName}相匹配',
	startDate: '起始日期',
	endDate: '結束日期',
	currentDate: '當前日期',
	afterDate: '日期必須等於或晚於{label}.',
	beforeDate: '日期必須早於或等於{label}.',
	startMonth: '請選擇起始月份',
	sameMonth: '您必須修改兩個日期中的一個，以確保它們在同一月份。 ',
	creditcard: '您輸入的信用卡號碼不正確。當前已輸入{length}個字符。 '

});

Form.Validator.add('validate-currency-yuan', {

	errorMsg: function(){
		return Form.Validator.getMsg('currencyYuan');
	},

	test: function(element){
		// [￥]1[##][,###]+[.##]
		// [￥]1###+[.##]
		// [￥]0.##
		// [￥].##
		return Form.Validator.getValidator('IsEmpty').test(element) || (/^￥?\-?([1-9]{1}[0-9]{0,2}(\,[0-9]{3})*(\.[0-9]{0,2})?|[1-9]{1}\d*(\.[0-9]{0,2})?|0(\.[0-9]{0,2})?|(\.[0-9]{1,2})?)$/).test(element.get('value'));
	}

});

/*
---

name: Locale.zh-CH.Number

description: Number messages for for Chinese (simplified and traditional).

license: MIT-style license

authors:
  - YMind Chan

requires:
  - Locale
  - Locale.en-US.Number

provides: [Locale.zh-CH.Number]

...
*/

// Simplified Chinese
Locale.define('zh-CHS', 'Number', {

	currency: {
		prefix: '￥ '
	}

}).inherit('en-US', 'Number');

// Traditional Chinese
Locale.define('zh-CHT').inherit('zh-CHS', 'Number');

/*
---

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++,
			key = 'request_' + index;

		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[key] = function(){
			delete Request.JSONP.request_map[key];
			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){
		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: Request.Periodical.js

name: Request.Periodical

description: Requests the same URL to pull data from a server but increases the intervals if no data is returned to reduce the load

license: MIT-style license

authors:
  - Christoph Pojer

requires:
  - Core/Request
  - MooTools.More

provides: [Request.Periodical]

...
*/

Request.implement({

	options: {
		initialDelay: 5000,
		delay: 5000,
		limit: 60000
	},

	startTimer: function(data){
		var fn = function(){
			if (!this.running) this.send({data: data});
		};
		this.lastDelay = this.options.initialDelay;
		this.timer = fn.delay(this.lastDelay, this);
		this.completeCheck = function(response){
			clearTimeout(this.timer);
			this.lastDelay = (response) ? this.options.delay : (this.lastDelay + this.options.delay).min(this.options.limit);
			this.timer = fn.delay(this.lastDelay, this);
		};
		return this.addEvent('complete', this.completeCheck);
	},

	stopTimer: function(){
		clearTimeout(this.timer);
		return this.removeEvent('complete', this.completeCheck);
	}

});

/*
---

script: Request.Queue.js

name: Request.Queue

description: Controls several instances of Request and its variants to run only one request at a time.

license: MIT-style license

authors:
  - Aaron Newton

requires:
  - Core/Element
  - Core/Request
  - Class.Binds

provides: [Request.Queue]

...
*/

Request.Queue = new Class({

	Implements: [Options, Events],

	Binds: ['attach', 'request', 'complete', 'cancel', 'success', 'failure', 'exception'],

	options: {/*
		onRequest: function(argsPassedToOnRequest){},
		onSuccess: function(argsPassedToOnSuccess){},
		onComplete: function(argsPassedToOnComplete){},
		onCancel: function(argsPassedToOnCancel){},
		onException: function(argsPassedToOnException){},
		onFailure: function(argsPassedToOnFailure){},
		onEnd: function(){},
		*/
		stopOnFailure: true,
		autoAdvance: true,
		concurrent: 1,
		requests: {}
	},

	initialize: function(options){
		var requests;
		if (options){
			requests = options.requests;
			delete options.requests;
		}
		this.setOptions(options);
		this.requests = {};
		this.queue = [];
		this.reqBinders = {};

		if (requests) this.addRequests(requests);
	},

	addRequest: function(name, request){
		this.requests[name] = request;
		this.attach(name, request);
		return this;
	},

	addRequests: function(obj){
		Object.each(obj, function(req, name){
			this.addRequest(name, req);
		}, this);
		return this;
	},

	getName: function(req){
		return Object.keyOf(this.requests, req);
	},

	attach: function(name, req){
		if (req._groupSend) return this;
		['request', 'complete', 'cancel', 'success', 'failure', 'exception'].each(function(evt){
			if (!this.reqBinders[name]) this.reqBinders[name] = {};
			this.reqBinders[name][evt] = function(){
				this['on' + evt.capitalize()].apply(this, [name, req].append(arguments));
			}.bind(this);
			req.addEvent(evt, this.reqBinders[name][evt]);
		}, this);
		req._groupSend = req.send;
		req.send = function(options){
			this.send(name, options);
			return req;
		}.bind(this);
		return this;
	},

	removeRequest: function(req){
		var name = typeOf(req) == 'object' ? this.getName(req) : req;
		if (!name && typeOf(name) != 'string') return this;
		req = this.requests[name];
		if (!req) return this;
		['request', 'complete', 'cancel', 'success', 'failure', 'exception'].each(function(evt){
			req.removeEvent(evt, this.reqBinders[name][evt]);
		}, this);
		req.send = req._groupSend;
		delete req._groupSend;
		return this;
	},

	getRunning: function(){
		return Object.filter(this.requests, function(r){
			return r.running;
		});
	},

	isRunning: function(){
		return !!(Object.keys(this.getRunning()).length);
	},

	send: function(name, options){
		var q = function(){
			this.requests[name]._groupSend(options);
			this.queue.erase(q);
		}.bind(this);

		q.name = name;
		if (Object.keys(this.getRunning()).length >= this.options.concurrent || (this.error && this.options.stopOnFailure)) this.queue.push(q);
		else q();
		return this;
	},

	hasNext: function(name){
		return (!name) ? !!this.queue.length : !!this.queue.filter(function(q){ return q.name == name; }).length;
	},

	resume: function(){
		this.error = false;
		(this.options.concurrent - Object.keys(this.getRunning()).length).times(this.runNext, this);
		return this;
	},

	runNext: function(name){
		if (!this.queue.length) return this;
		if (!name){
			this.queue[0]();
		} else {
			var found;
			this.queue.each(function(q){
				if (!found && q.name == name){
					found = true;
					q();
				}
			});
		}
		return this;
	},

	runAll: function(){
		this.queue.each(function(q){
			q();
		});
		return this;
	},

	clear: function(name){
		if (!name){
			this.queue.empty();
		} else {
			this.queue = this.queue.map(function(q){
				if (q.name != name) return q;
				else return false;
			}).filter(function(q){
				return q;
			});
		}
		return this;
	},

	cancel: function(name){
		this.requests[name].cancel();
		return this;
	},

	onRequest: function(){
		this.fireEvent('request', arguments);
	},

	onComplete: function(){
		this.fireEvent('complete', arguments);
		if (!this.queue.length) this.fireEvent('end');
	},

	onCancel: function(){
		if (this.options.autoAdvance && !this.error) this.runNext();
		this.fireEvent('cancel', arguments);
	},

	onSuccess: function(){
		if (this.options.autoAdvance && !this.error) this.runNext();
		this.fireEvent('success', arguments);
	},

	onFailure: function(){
		this.error = true;
		if (!this.options.stopOnFailure && this.options.autoAdvance) this.runNext();
		this.fireEvent('failure', arguments);
	},

	onException: function(){
		this.error = true;
		if (!this.options.stopOnFailure && this.options.autoAdvance) this.runNext();
		this.fireEvent('exception', arguments);
	}

});

/*
---

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--){
				if (this[l] != null) result += parseFloat(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;
	},

	pluck: function(prop){
		return this.map(function(item){
			return item[prop];
		});
	}

});

})();

/*
---

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: 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);
	}

});

/*
---
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: 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+):)?(?:\/\/(?:(?:([^:@\/]*):?([^:@\/]*))?@)?(\[[A-Fa-f0-9:]+\]|[^:\/?#]*)(?::(\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(null, part), 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.convert(document.getElements('base[href]', true)).getLast(), {base: document.location});

String.implement({

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

});

})();

/*
---

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));
	}

});

/*
---

script: Assets.js

name: Assets

description: Provides methods to dynamically load JavaScript, CSS, and Image files into the document.

license: MIT-style license

authors:
  - Valerio Proietti

requires:
  - Core/Element.Event
  - MooTools.More

provides: [Assets, Asset.javascript, Asset.css, Asset.image, Asset.images]

...
*/
;(function(){

var Asset = this.Asset = {

	javascript: function(source, properties){
		if (!properties) properties = {};

		var script = new Element('script', {src: source, type: 'text/javascript'}),
			doc = properties.document || document,
			load = properties.onload || properties.onLoad;

		delete properties.onload;
		delete properties.onLoad;
		delete properties.document;

		if (load){
			if (!script.addEventListener){
				script.addEvent('readystatechange', function(){
					if (['loaded', 'complete'].contains(this.readyState)) load.call(this);
				});
			} else {
				script.addEvent('load', load);
			}
		}

		return script.set(properties).inject(doc.head);
	},

	css: function(source, properties){
		if (!properties) properties = {};

		var load = properties.onload || properties.onLoad,
			doc = properties.document || document,
			timeout = properties.timeout || 3000;

		['onload', 'onLoad', 'document'].each(function(prop){
			delete properties[prop];
		});

		var link = new Element('link', {
			type: 'text/css',
			rel: 'stylesheet',
			media: 'screen',
			href: source
		}).setProperties(properties).inject(doc.head);

		if (load){
			// based on article at http://www.yearofmoo.com/2011/03/cross-browser-stylesheet-preloading.html
			var loaded = false, retries = 0;
			var check = function(){
				var stylesheets = document.styleSheets;
				for (var i = 0; i < stylesheets.length; i++){
					var file = stylesheets[i];
					var owner = file.ownerNode ? file.ownerNode : file.owningElement;
					if (owner && owner == link){
						loaded = true;
						return load.call(link);
					}
				}
				retries++;
				if (!loaded && retries < timeout / 50) return setTimeout(check, 50);
			};
			setTimeout(check, 0);
		}
		return link;
	},

	image: function(source, properties){
		if (!properties) properties = {};

		var image = new Image(),
			element = document.id(image) || new Element('img');

		['load', 'abort', 'error'].each(function(name){
			var type = 'on' + name,
				cap = 'on' + name.capitalize(),
				event = properties[type] || properties[cap] || function(){};

			delete properties[cap];
			delete properties[type];

			image[type] = function(){
				if (!image) return;
				if (!element.parentNode){
					element.width = image.width;
					element.height = image.height;
				}
				image = image.onload = image.onabort = image.onerror = null;
				event.delay(1, element, element);
				element.fireEvent(name, element, 1);
			};
		});

		image.src = element.src = source;
		if (image && image.complete) image.onload.delay(1);
		return element.set(properties);
	},

	images: function(sources, options){
		sources = Array.convert(sources);

		var fn = function(){},
			counter = 0;

		options = Object.merge({
			onComplete: fn,
			onProgress: fn,
			onError: fn,
			properties: {}
		}, options);

		return new Elements(sources.map(function(source, index){
			return Asset.image(source, Object.append(options.properties, {
				onload: function(){
					counter++;
					options.onProgress.call(this, counter, index, source);
					if (counter == sources.length) options.onComplete();
				},
				onerror: function(){
					counter++;
					options.onError.call(this, counter, index, source);
					if (counter == sources.length) options.onComplete();
				}
			}));
		}));
	}

};

})();

/*
---

script: Color.js

name: Color

description: Class for creating and manipulating colors in JavaScript. Supports HSB -> RGB Conversions and vice versa.

license: MIT-style license

authors:
  - Valerio Proietti

requires:
  - Core/Array
  - Core/String
  - Core/Number
  - Core/Hash
  - Core/Function
  - MooTools.More

provides: [Color]

...
*/

(function(){

var Color = this.Color = new Type('Color', function(color, type){
	if (arguments.length >= 3){
		type = 'rgb'; color = Array.slice(arguments, 0, 3);
	} else if (typeof color == 'string'){
		if (color.match(/rgb/)) color = color.rgbToHex().hexToRgb(true);
		else if (color.match(/hsb/)) color = color.hsbToRgb();
		else color = color.hexToRgb(true);
	}
	type = type || 'rgb';
	switch (type){
		case 'hsb':
			var old = color;
			color = color.hsbToRgb();
			color.hsb = old;
			break;
		case 'hex': color = color.hexToRgb(true); break;
	}
	color.rgb = color.slice(0, 3);
	color.hsb = color.hsb || color.rgbToHsb();
	color.hex = color.rgbToHex();
	return Object.append(color, this);
});

Color.implement({

	mix: function(){
		var colors = Array.slice(arguments);
		var alpha = (typeOf(colors.getLast()) == 'number') ? colors.pop() : 50;
		var rgb = this.slice();
		colors.each(function(color){
			color = new Color(color);
			for (var i = 0; i < 3; i++) rgb[i] = Math.round((rgb[i] / 100 * (100 - alpha)) + (color[i] / 100 * alpha));
		});
		return new Color(rgb, 'rgb');
	},

	invert: function(){
		return new Color(this.map(function(value){
			return 255 - value;
		}));
	},

	setHue: function(value){
		return new Color([value, this.hsb[1], this.hsb[2]], 'hsb');
	},

	setSaturation: function(percent){
		return new Color([this.hsb[0], percent, this.hsb[2]], 'hsb');
	},

	setBrightness: function(percent){
		return new Color([this.hsb[0], this.hsb[1], percent], 'hsb');
	}

});

this.$RGB = function(r, g, b){
	return new Color([r, g, b], 'rgb');
};

this.$HSB = function(h, s, b){
	return new Color([h, s, b], 'hsb');
};

this.$HEX = function(hex){
	return new Color(hex, 'hex');
};

Array.implement({

	rgbToHsb: function(){
		var red = this[0],
			green = this[1],
			blue = this[2],
			hue = 0,
			max = Math.max(red, green, blue),
			min = Math.min(red, green, blue),
			delta = max - min,
			brightness = max / 255,
			saturation = (max != 0) ? delta / max : 0;

		if (saturation != 0){
			var rr = (max - red) / delta;
			var gr = (max - green) / delta;
			var br = (max - blue) / delta;
			if (red == max) hue = br - gr;
			else if (green == max) hue = 2 + rr - br;
			else hue = 4 + gr - rr;
			hue /= 6;
			if (hue < 0) hue++;
		}
		return [Math.round(hue * 360), Math.round(saturation * 100), Math.round(brightness * 100)];
	},

	hsbToRgb: function(){
		var br = Math.round(this[2] / 100 * 255);
		if (this[1] == 0){
			return [br, br, br];
		} else {
			var hue = this[0] % 360;
			var f = hue % 60;
			var p = Math.round((this[2] * (100 - this[1])) / 10000 * 255);
			var q = Math.round((this[2] * (6000 - this[1] * f)) / 600000 * 255);
			var t = Math.round((this[2] * (6000 - this[1] * (60 - f))) / 600000 * 255);
			switch (Math.floor(hue / 60)){
				case 0: return [br, t, p];
				case 1: return [q, br, p];
				case 2: return [p, br, t];
				case 3: return [p, q, br];
				case 4: return [t, p, br];
				case 5: return [br, p, q];
			}
		}
		return false;
	}

});

String.implement({

	rgbToHsb: function(){
		var rgb = this.match(/\d{1,3}/g);
		return (rgb) ? rgb.rgbToHsb() : null;
	},

	hsbToRgb: function(){
		var hsb = this.match(/\d{1,3}/g);
		return (hsb) ? hsb.hsbToRgb() : null;
	}

});

})();


/*
---

script: Hash.Cookie.js

name: Hash.Cookie

description: Class for creating, reading, and deleting Cookies in JSON format.

license: MIT-style license

authors:
  - Valerio Proietti
  - Aaron Newton

requires:
  - Core/Cookie
  - Core/JSON
  - MooTools.More
  - Hash

provides: [Hash.Cookie]

...
*/

Hash.Cookie = new Class({

	Extends: Cookie,

	options: {
		autoSave: true
	},

	initialize: function(name, options){
		this.parent(name, options);
		this.load();
	},

	save: function(){
		var value = JSON.encode(this.hash);
		if (!value || value.length > 4096) return false; //cookie would be truncated!
		if (value == '{}') this.dispose();
		else this.write(value);
		return true;
	},

	load: function(){
		this.hash = new Hash(JSON.decode(this.read(), true));
		return this;
	}

});

Hash.each(Hash.prototype, function(method, name){
	if (typeof method == 'function') Hash.Cookie.implement(name, function(){
		var value = method.apply(this.hash, arguments);
		if (this.options.autoSave) this.save();
		return value;
	});
});

    var Allium = function(configuration) {
	this.configuration = configuration;
};

Allium.prototype = {
	get: function(key) {
		return this.configuration[key] || null;
	},

	set: function(key, value) {
		this.configuration[key] = value;
	}
};

var Cookie = function() {};

Cookie.prototype = {
    set: function(name, value, expires, path, domain) {
        if (typeof path == 'undefined') {
            path = '/';
        }

        var cookie = name + "=" + value + ';path=' + path;

        if (typeof domain != 'undefined') {
            cookie += ';domain=' + domain;
        }

        if (typeof expires != 'undefined') {
            if (!(expires instanceof Date)) {
                var lifetime = parseInt(expires);
                expires = new Date;

                if (!isNaN(lifetime)) {
                    expires.setSeconds(lifetime.getSeconds() + lifetime);
                }
            }

            cookie += ';expires=' + expires.toUTCString();
        }

        document.cookie = cookie;
    },

    get: function(name) {
        var name    = name + "=",
            cookies = document.cookie.split(';');

        for(var i = 0; i < cookies.length; i++) {
            var cookie = cookies[i];

            while (cookie.charAt(0) == ' ') {
                cookie = cookie.substring(1);
            }

            if (cookie.indexOf(name) == 0) {
                return cookie.substring(name.length, cookie.length);
            }
        }

        return null;
    },

    remove: function(name, path, domain) {
        this.set(name, '', -1, path, domain);
    },

    exists: function(name) {
        return (this.get(name) !== null);
    },
};

/**
 * Analogous to PHP
 */
var I18n = function() {
    this.language     = 'DE';
    this.localeTypes  = ['number', 'currency', 'date_time'];
    this.locales      = {};
    this.patterns     = {};
    this.currency     = 'EUR';
    this.timeZone     = 'Europe/Berlin';
    this.translations = {};
};

I18n.prototype = {
    getCurrency: function() {
        var self = this;

        return self.currency;
    },

    getCurrencyFormatter: function(options) {
        var self = this;

        if (typeof options === 'undefined') {
            options = {};
        }

        var fmtLocale  = self.getLocale('currency'),
            fmtOptions = {
                style           : 'currency',
                useGrouping     : true,
                currency        : self.getCurrency(),
                currencyDisplay : 'symbol'
            };

        if (typeof options.locale !== 'undefined') {
            fmtLocale = options.locale;
        }

        if (typeof options.precision !== 'undefined') {
            fmtOptions.maximumFractionDigits = options.precision;
            fmtOptions.minimumFractionDigits = options.precision;
        }

        if (typeof options.grouping !== 'undefined') {
            fmtOptions.useGrouping = options.grouping;
        }

        if (typeof options.currency !== 'undefined') {
            fmtOptions.currency = options.currency;
        }

        return new Intl.NumberFormat(fmtLocale, fmtOptions);
    },

    getCurrencySymbol: function(locale, currency) {
        var self = this;

        if (typeof locale === 'undefined' || locale === null) {
            locale = self.getLocale('currency');
        }

        if (typeof currency === 'undefined' || currency === null) {
            currency = self.getCurrency();
        }

        var options = {
                locale   : locale,
                currency : currency
            };

        var fmt    = self.getCurrencyFormatter(options),
            fmtNum = fmt.format(1000000.0),
            symbol = fmtNum.replace(/^.*?([^\s\d\.\,]+).*?$/, '$1');

        /**
         * Not supported by all browsers
         *
        var parts = fmt.formatToParts(1000000.0);

        parts.forEach(function(part) {
            if (typeof part.type !== 'undefined' && part.type == 'currency' && typeof part.value !== 'undefined') {
                symbol = part.value;
            }
        });
        */

        return symbol;
    },

    getDateTimeFormatter: function(options) {
        var self = this;

        if (typeof options === 'undefined') {
            options = {};
        }

        var fmtLocale     = self.getLocale('date_time'),
            patternLocale = self.getLocale(),
            date          = 'medium',
            time          = 'none',
            fmtOptions    = {
                timeZone : self.getTimeZone()
            };

        if (typeof options.locale !== 'undefined') {
            fmtLocale     = options.locale;
            patternLocale = options.locale;
        }

        if (typeof options.date !== 'undefined') {
            date = options.date;
        }

        if (typeof options.time !== 'undefined') {
            time = options.time;
        }

        switch (date) {
            case 'full':
                fmtOptions.weekday = 'long';
                fmtOptions.year    = 'numeric';
                fmtOptions.month   = 'long';
                fmtOptions.day     = 'numeric';
                // fmtOptions.era     = undefined;
                break;
            case 'long':
                fmtOptions.weekday = undefined;
                fmtOptions.year    = 'numeric';
                fmtOptions.month   = 'long';
                fmtOptions.day     = 'numeric';
                // fmtOptions.era     = undefined;
                break;
            case 'medium':
                fmtOptions.weekday = undefined;
                fmtOptions.year    = 'numeric';
                fmtOptions.month   = '2-digit';
                fmtOptions.day     = '2-digit';
                // fmtOptions.era     = undefined;
                break;
            case 'short':
                fmtOptions.weekday = undefined;
                fmtOptions.year    = '2-digit';
                fmtOptions.month   = '2-digit';
                fmtOptions.day     = '2-digit';
                // fmtOptions.era     = undefined;
                break;
            case 'none':
                fmtOptions.weekday = undefined;
                fmtOptions.year    = undefined;
                fmtOptions.month   = undefined;
                fmtOptions.day     = undefined;
                fmtOptions.era     = undefined;
                break;
        }

        switch (time) {
            case 'full':
                fmtOptions.hour         = 'numeric';
                fmtOptions.minute       = '2-digit';
                fmtOptions.second       = '2-digit';
                fmtOptions.timeZoneName = 'long';
                break;
            case 'long':
                fmtOptions.hour         = 'numeric';
                fmtOptions.minute       = '2-digit';
                fmtOptions.second       = '2-digit';
                fmtOptions.timeZoneName = 'short';
                break;
            case 'medium':
                fmtOptions.hour         = 'numeric';
                fmtOptions.minute       = '2-digit';
                fmtOptions.second       = '2-digit';
                fmtOptions.timeZoneName = undefined;
                break;
            case 'short':
                fmtOptions.hour         = '2-digit';
                fmtOptions.minute       = '2-digit';
                fmtOptions.second       = undefined;
                fmtOptions.timeZoneName = undefined;
                break;
            case 'none':
                fmtOptions.hour         = undefined;
                fmtOptions.minute       = undefined;
                fmtOptions.second       = undefined;
                fmtOptions.timeZoneName = undefined;
                break;
        }

        var patterns = self.getPattern('date_time', patternLocale);

        if (patterns && typeof patterns['formatter'] !== 'undefined') {
            if (date != 'none' && typeof patterns['formatter'][date] !== 'undefined') {
                if (typeof patterns['formatter'][date]['date'] !== 'undefined') {
                    ['weekday', 'year', 'month', 'day', 'era'].forEach(function(key) {
                        if (typeof patterns['formatter'][date]['date'][key] !== 'undefined') {
                            fmtOptions[key] = (patterns['formatter'][date]['date'][key] === null) ? undefined : patterns['formatter'][date]['date'][key];
                        }
                    });
                }
            }

            if (time != 'none' && typeof patterns['formatter'][time] !== 'undefined') {
                if (typeof patterns['formatter'][time]['time'] !== 'undefined') {
                    ['hour', 'minute', 'second', 'timeZoneName'].forEach(function(key) {
                        if (typeof patterns['formatter'][time]['time'][key] !== 'undefined') {
                            fmtOptions[key] = (patterns['formatter'][time]['time'][key] === null) ? undefined : patterns['formatter'][time]['time'][key];
                        }
                    });
                }
            }

            if (typeof patterns['date_picker']['date'] !== 'undefined') {
                Locale.define(locale, 'Date', 'shortDate', patterns['date_picker']['date']);
            }

            if (typeof patterns['date_picker']['time'] !== 'undefined') {
                Locale.define(locale, 'Date', 'shortTime', patterns['date_picker']['time']);
            }
        }

        if (typeof options.timeZone !== 'undefined') {
            fmtOptions.timeZone = options.timeZone;
        }

        return new Intl.DateTimeFormat(fmtLocale, fmtOptions);
    },

    getDecimalSeparator: function(locale) {
        var self    = this,
            options = {
                locale    : locale,
                precision : 1,
                fixed     : true
            };

        var fmt    = self.getNumberFormatter(options),
            fmtNum = fmt.format(1000000.0),
            separator = fmtNum.replace(/^.+?(\D)\d$/, '$1');

        /**
         * Not supported by all browsers
         *
        var parts = fmt.formatToParts(1000000.0);

        parts.forEach(function(part) {
            if (typeof part.type !== 'undefined' && part.type == 'decimal' && typeof part.value !== 'undefined') {
                separator = part.value;
            }
        });
        */

        return separator;
    },

    getLanguage: function(locale) {
        var self = this;

        if (typeof locale === 'undefined' || locale === null) {
            return self.language;
        }

        return locale.toUpperCase().replace(/\-[A-Z]+$/, '');
    },

    getLocale: function(type, locale) {
        var self = this;

        if (typeof locale === 'undefined') {
            locale = self.getLocale('default', 'default');

            if (typeof type === 'undefined' || !self.localeTypes.indexOf(type) === -1) {
                return locale;
            }
        }

        if (typeof self.locales[locale] === 'undefined') {
            return self.getLocale('default', 'default');
        }

        if (typeof type === 'undefined' || !self.localeTypes.indexOf(type) === -1 || typeof self.locales[locale] === 'undefined' || typeof self.locales[locale][type] === 'undefined') {
            type = 'default';
        }

        return (typeof self.locales[locale] !== 'undefined' && typeof self.locales[locale][type] !== 'undefined') ? self.locales[locale][type] : locale;
    },

    getLocales: function() {
        var self = this;

        return self.locales;
    },

    getPattern: function(type, locale) {
        var self = this;

        if (typeof locale === 'undefined') {
            locale = self.getLocale();
        }

        if (typeof self.patterns[locale] === 'undefined') {
            locale = 'default';
        }

        if (typeof type === 'undefined' || !self.localeTypes.indexOf(type) === -1 || typeof self.patterns[locale] === 'undefined' || typeof self.patterns[locale][type] === 'undefined') {
            type = 'default';
        }

        return (typeof self.patterns[locale] !== 'undefined' && typeof self.patterns[locale][type] !== 'undefined') ? self.patterns[locale][type] : null;
    },

    getPatterns: function() {
        var self = this;

        return self.patterns;
    },

    getNumberFormatter: function(options) {
        var self = this;

        if (typeof options === 'undefined') {
            options = {};
        }

        var fmtLocale  = self.getLocale('number'),
            fmtOptions = {
                style                 : 'decimal',
                useGrouping           : true,
                minimumFractionDigits : 0,
                maximumFractionDigits : 20
            };

        if (typeof options.locale !== 'undefined') {
            fmtLocale = options.locale;
        }

        if (typeof options.precision !== 'undefined') {
            fmtOptions.maximumFractionDigits = options.precision;
        }

        if (typeof options.fixed !== 'undefined' && options.fixed) {
            fmtOptions.minimumFractionDigits = fmtOptions.maximumFractionDigits;
        }

        if (typeof options.grouping !== 'undefined') {
            fmtOptions.useGrouping = options.grouping;
        }

        return new Intl.NumberFormat(fmtLocale, fmtOptions);
    },

    getThousandsSeparator: function(locale) {
        var self    = this,
            options = {
                locale    : locale,
                precision : 1,
                fixed     : true
            };

        var fmt       = self.getNumberFormatter(options),
            fmtNum    = fmt.format(1000000.0),
            separator = fmtNum.replace(/^\d+(\D).+?\D\d$/, '$1');

        /**
         * Not supported by all browsers
         *
        var fmtNum = fmt.format(1000000.0);

        parts.forEach(function(part) {
            if (typeof part.type !== 'undefined' && part.type == 'group' && typeof part.value !== 'undefined') {
                separator = part.value;
            }
        });
        */

        return separator;
    },

    getTimeZone: function() {
        var self = this;

        return self.timeZone;
    },

    getTranslation: function(language) {
        var self = this;

        if (typeof language === 'undefined') {
            language = self.getLanguage();
        }

        return (typeof self.translations[language] !== 'undefined') ? self.translations[language] : {};
    },

    getTranslations: function() {
        var self = this;

        return self.translations;
    },

    formatCurrency: function(value, options) {
        var self = this,
            fmt  = self.getCurrencyFormatter(options);

        return fmt.format(value);
    },

    formatDateTime: function(value, options) {
        var self = this,
            fmt  = self.getDateTimeFormatter(options);

        return fmt.format(value);
    },

    formatNumber: function(value, options) {
        var self = this;

        if (typeof options === 'undefined') {
            options = {};
        }

        if (typeof options.multiplier === 'undefined' || !options.multiplier) {
            options.multiplier = 1;
        }

        var fmt = self.getNumberFormatter(options);

        return fmt.format(value * options.multiplier);
    },

    formatPercent: function(value, options) {
        var self = this;

        if (typeof options === 'undefined') {
            options = {};
        }

        if (typeof options.precision === 'undefined') {
            options.precision = 2;
        }

        if (typeof options.fixed === 'undefined') {
            options.fixed = true;
        }

        if (typeof options.multiplier === 'undefined' || !options.multiplier) {
            options.multiplier = 100;
        }

        return self.formatNumber(value, options) + ' %';
    },

    formatTranslationKey: function(key, options) {
        if (typeof options === 'undefined') {
            options = {};
        }

        if (typeof options.prefix === 'undefined') {
            options.prefix = '';
        }

        if (typeof options.suffix === 'undefined') {
            options.suffix = '';
        }

        key = options.prefix + key + options.suffix;
        key = key.toLowerCase().replace(/[^a-z0-9]+/g, '.');

        return key;
    },

    setCurrency: function(currency) {
        var self = this;

        self.currency = currency.toUpperCase();

        return self;
    },

    setLanguage: function(language) {
        var self = this;

        self.language = language.toUpperCase();

        return self;
    },

    setLocale: function(targetLocale, type, locale) {
        var self = this;

        if (typeof targetLocale === 'undefined' || targetLocale === null || targetLocale.trim() === '') {
            return self;
        }

        if (typeof locale === 'undefined') {
            locale = 'default';
        }

        if (typeof type === 'undefined' || !self.localeTypes.indexOf(type) === -1) {
            type = 'default';
        }

        locale       = locale.replace(/\_/g, '-');
        targetLocale = targetLocale.replace(/\_/g, '-');

        if (typeof self.locales[locale] === 'undefined') {
            self.locales[locale] = {};
        }

        self.locales[locale][type] = targetLocale;

        return self;
    },

    setPattern: function(pattern, type, locale) {
        var self = this;

        if (typeof pattern === 'undefined' || pattern === null || (typeof pattern === 'string' && pattern.trim() === '') || (typeof pattern !== 'string' && !pattern)) {
            return self;
        }

        if (typeof locale === 'undefined') {
            locale = 'default';
        }

        if (typeof type === 'undefined' || !self.localeTypes.indexOf(type) === -1) {
            type = 'default';
        }

        locale = locale.replace(/\_/g, '-');

        if (typeof self.patterns[locale] === 'undefined') {
            self.patterns[locale] = {};
        }

        self.patterns[locale][type] = pattern;

        return self;
    },

    setTimeZone: function(timeZone) {
        var self = this;

        self.timeZone = timeZone;

        return self;
    },

    setTranslation: function(translation, language) {
        var self = this;

        if (typeof language === 'undefined') {
            language = self.getLanguage();
        }

        self.translations[language] = translation;

        return self;
    },

    setTranslations: function(translations) {
        var self = this;

        self.translations = translations;

        return self;
    },

    translate: function(key, options, data) {
        var self  = this,
            input = key;

        if (typeof options === 'undefined') {
            options = {};
        }

        if (typeof data === 'undefined') {
            data = {};
        }

        if (typeof options.language === 'undefined') {
            options.language = self.getLanguage();
        } else {
            options.language = options.language.toUpperCase();
        }

        var translation = self.getTranslation(options.language);

        key = self.formatTranslationKey(key, options);

        if (typeof translation[key] === 'undefined') {
            return input;
        }

        var value = translation[key];

        if (typeof options.transform !== 'undefined') {
            switch (options.transform) {
                case 'uc':
                    value = value.toUpperCase();
                    break;
                case 'lc':
                    value = value.toLowerCase();
                    break;
                case 'ucfirst':
                    value = value.toUpperCaseFirst();
                    break;
                case 'lcfirst':
                    value = value.toLowerCaseFirst();
                    break;
                case 'ucwords':
                    value = value.toUpperCaseWords();
                    break;
            }
        }

        value = value.vsprintf(data);

        return value;
    },

    unformatCurrency: function(value, options) {
        var self = this;

        if (typeof options === 'undefined') {
            options = {};
        }

        if (typeof options.locale === 'undefined') {
            options.locale = self.getLocale('currency');
        }

        if (typeof options.precision === 'undefined') {
            options.precision = 2;
        }

        if (typeof options.currency === 'undefined') {
            options.currency = self.getCurrency();
        }

        if (typeof options.currencySymbol === 'undefined') {
            options.currencySymbol = self.getCurrencySymbol(options.locale, options.currency);
        }

        var thousandsSeparator = self.getThousandsSeparator(options.locale),
            decimalSeparator   = self.getDecimalSeparator(options.locale),
            currencyRegex      = new RegExp('(^(' + options.currencySymbol + ')?\\s*)|(\\s*(' + options.currencySymbol + ')?$)', 'g');

        value = value.replace(currencyRegex, '');

        return self.unformatNumber(value, options);
    },

    unformatNumber: function(value, options) {
        var self = this;

        if (typeof options === 'undefined') {
            options = {};
        }

        if (typeof options.locale === 'undefined') {
            options.locale = self.getLocale('number');
        }

        if (typeof options.precision === 'undefined') {
            options.precision = 2;
        }

        if (typeof options.multiplier === 'undefined' || !options.multiplier) {
            options.multiplier = 1;
        }

        var thousandsSeparator = self.getThousandsSeparator(options.locale),
            decimalSeparator   = self.getDecimalSeparator(options.locale),
            numberRegex        = new RegExp('^[0-9\\' + thousandsSeparator + '\\' + decimalSeparator + ']+$', 'g');

        if (!value.match(numberRegex)) {
            return NaN;
        }

        var thousandsSeparatorRegex = new RegExp('\\' + thousandsSeparator, 'g'),
            decimalSeparatorRegex   = new RegExp('\\' + decimalSeparator, 'g');

        value = value.replace(thousandsSeparatorRegex, '').replace(decimalSeparatorRegex, '.');
        value = (options.precision) ? parseFloat(value) : parseInt(value);

        return value / options.multiplier;
    },

    unformatPercent: function(value, options) {
        var self = this;

        if (typeof options === 'undefined') {
            options = {};
        }

        if (typeof options.precision === 'undefined') {
            options.precision = 2;
        }

        if (typeof options.fixed === 'undefined') {
            options.fixed = true;
        }

        if (typeof options.multiplier === 'undefined' || !options.multiplier) {
            options.multiplier = 100;
        }

        value = value.replace(/\s?\%$/, '');

        return self.unformatNumber(value, options);
    },

    getTimeZoneDiff: function(value) {
        var self          = this,
            dateFormatter = self.getDateTimeFormatter({
            locale: 'en-GB',
            date: 'medium',
            time: 'medium',
        });

        if (value instanceof Date) {
            value = value.getTime();
        }

        var timestamp = Date.parse(dateFormatter.format(value)).getTime()

        return Math.floor(value - timestamp);
    }
};


if (!Math.roundPrecision) {
    Math.roundPrecision = function(value, precision, fixed) {
        var self = this;

        if (isNaN(value)) {
            return NaN;
        }

        if (typeof precision === 'undefined') {
            precision = 0;
        }

        if (typeof fixed === 'undefined') {
            fixed = false;
        }

        var multiplier = self.pow(10, precision);

        value = self.round(value * multiplier) / multiplier;

        if (fixed) {
            value = value.toFixed(precision);
        }

        return value;
    };
}

if (!Math.gcd) {
    Math.gcd = function(a, b) {
        var self = this;

        if (b == 0) {
            return a;
        }

        return self.gcd(b, a % b);
    }
}


if (!Object.assign) {
    Object.assign = function(target, sources) {
        sources = [].slice.call(arguments, 1);

        sources.forEach(function(source) {
            Object.keys(source).forEach(function(key) {
                target[key] = source[key];
            });
        });

        return target;
   }
}


if (!RegExp.escape) {
    RegExp.escape = function(string) {
        return string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
    };
}


/**
 * https://developers.google.com/web/updates/2016/10/resizeobserver
 * https://github.com/que-etc/resize-observer-polyfill
 */
(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
    typeof define === 'function' && define.amd ? define(factory) :
    (global.ResizeObserver = factory());
}(this, (function () { 'use strict';

/**
 * A collection of shims that provide minimal functionality of the ES6 collections.
 *
 * These implementations are not meant to be used outside of the ResizeObserver
 * modules as they cover only a limited range of use cases.
 */
/* eslint-disable require-jsdoc, valid-jsdoc */
var MapShim = (function () {
    if (typeof Map !== 'undefined') {
        return Map;
    }

    /**
     * Returns index in provided array that matches the specified key.
     *
     * @param {Array<Array>} arr
     * @param {*} key
     * @returns {number}
     */
    function getIndex(arr, key) {
        var result = -1;

        arr.some(function (entry, index) {
            if (entry[0] === key) {
                result = index;

                return true;
            }

            return false;
        });

        return result;
    }

    return (function () {
        function anonymous() {
            this.__entries__ = [];
        }

        var prototypeAccessors = { size: { configurable: true } };

        /**
         * @returns {boolean}
         */
        prototypeAccessors.size.get = function () {
            return this.__entries__.length;
        };

        /**
         * @param {*} key
         * @returns {*}
         */
        anonymous.prototype.get = function (key) {
            var index = getIndex(this.__entries__, key);
            var entry = this.__entries__[index];

            return entry && entry[1];
        };

        /**
         * @param {*} key
         * @param {*} value
         * @returns {void}
         */
        anonymous.prototype.set = function (key, value) {
            var index = getIndex(this.__entries__, key);

            if (~index) {
                this.__entries__[index][1] = value;
            } else {
                this.__entries__.push([key, value]);
            }
        };

        /**
         * @param {*} key
         * @returns {void}
         */
        anonymous.prototype.delete = function (key) {
            var entries = this.__entries__;
            var index = getIndex(entries, key);

            if (~index) {
                entries.splice(index, 1);
            }
        };

        /**
         * @param {*} key
         * @returns {void}
         */
        anonymous.prototype.has = function (key) {
            return !!~getIndex(this.__entries__, key);
        };

        /**
         * @returns {void}
         */
        anonymous.prototype.clear = function () {
            this.__entries__.splice(0);
        };

        /**
         * @param {Function} callback
         * @param {*} [ctx=null]
         * @returns {void}
         */
        anonymous.prototype.forEach = function (callback, ctx) {
            var this$1 = this;
            if ( ctx === void 0 ) ctx = null;

            for (var i = 0, list = this$1.__entries__; i < list.length; i += 1) {
                var entry = list[i];

                callback.call(ctx, entry[1], entry[0]);
            }
        };

        Object.defineProperties( anonymous.prototype, prototypeAccessors );

        return anonymous;
    }());
})();

/**
 * Detects whether window and document objects are available in current environment.
 */
var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document;

// Returns global object of a current environment.
var global$1 = (function () {
    if (typeof global !== 'undefined' && global.Math === Math) {
        return global;
    }

    if (typeof self !== 'undefined' && self.Math === Math) {
        return self;
    }

    if (typeof window !== 'undefined' && window.Math === Math) {
        return window;
    }

    // eslint-disable-next-line no-new-func
    return Function('return this')();
})();

/**
 * A shim for the requestAnimationFrame which falls back to the setTimeout if
 * first one is not supported.
 *
 * @returns {number} Requests' identifier.
 */
var requestAnimationFrame$1 = (function () {
    if (typeof requestAnimationFrame === 'function') {
        // It's required to use a bounded function because IE sometimes throws
        // an "Invalid calling object" error if rAF is invoked without the global
        // object on the left hand side.
        return requestAnimationFrame.bind(global$1);
    }

    return function (callback) { return setTimeout(function () { return callback(Date.now()); }, 1000 / 60); };
})();

// Defines minimum timeout before adding a trailing call.
var trailingTimeout = 2;

/**
 * Creates a wrapper function which ensures that provided callback will be
 * invoked only once during the specified delay period.
 *
 * @param {Function} callback - Function to be invoked after the delay period.
 * @param {number} delay - Delay after which to invoke callback.
 * @returns {Function}
 */
var throttle = function (callback, delay) {
    var leadingCall = false,
        trailingCall = false,
        lastCallTime = 0;

    /**
     * Invokes the original callback function and schedules new invocation if
     * the "proxy" was called during current request.
     *
     * @returns {void}
     */
    function resolvePending() {
        if (leadingCall) {
            leadingCall = false;

            callback();
        }

        if (trailingCall) {
            proxy();
        }
    }

    /**
     * Callback invoked after the specified delay. It will further postpone
     * invocation of the original function delegating it to the
     * requestAnimationFrame.
     *
     * @returns {void}
     */
    function timeoutCallback() {
        requestAnimationFrame$1(resolvePending);
    }

    /**
     * Schedules invocation of the original function.
     *
     * @returns {void}
     */
    function proxy() {
        var timeStamp = Date.now();

        if (leadingCall) {
            // Reject immediately following calls.
            if (timeStamp - lastCallTime < trailingTimeout) {
                return;
            }

            // Schedule new call to be in invoked when the pending one is resolved.
            // This is important for "transitions" which never actually start
            // immediately so there is a chance that we might miss one if change
            // happens amids the pending invocation.
            trailingCall = true;
        } else {
            leadingCall = true;
            trailingCall = false;

            setTimeout(timeoutCallback, delay);
        }

        lastCallTime = timeStamp;
    }

    return proxy;
};

// Minimum delay before invoking the update of observers.
var REFRESH_DELAY = 20;

// A list of substrings of CSS properties used to find transition events that
// might affect dimensions of observed elements.
var transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];

// Check if MutationObserver is available.
var mutationObserverSupported = typeof MutationObserver !== 'undefined';

/**
 * Singleton controller class which handles updates of ResizeObserver instances.
 */
var ResizeObserverController = function() {
    this.connected_ = false;
    this.mutationEventsAdded_ = false;
    this.mutationsObserver_ = null;
    this.observers_ = [];

    this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);
    this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);
};

/**
 * Adds observer to observers list.
 *
 * @param {ResizeObserverSPI} observer - Observer to be added.
 * @returns {void}
 */


/**
 * Holds reference to the controller's instance.
 *
 * @private {ResizeObserverController}
 */


/**
 * Keeps reference to the instance of MutationObserver.
 *
 * @private {MutationObserver}
 */

/**
 * Indicates whether DOM listeners have been added.
 *
 * @private {boolean}
 */
ResizeObserverController.prototype.addObserver = function (observer) {
    if (!~this.observers_.indexOf(observer)) {
        this.observers_.push(observer);
    }

    // Add listeners if they haven't been added yet.
    if (!this.connected_) {
        this.connect_();
    }
};

/**
 * Removes observer from observers list.
 *
 * @param {ResizeObserverSPI} observer - Observer to be removed.
 * @returns {void}
 */
ResizeObserverController.prototype.removeObserver = function (observer) {
    var observers = this.observers_;
    var index = observers.indexOf(observer);

    // Remove observer if it's present in registry.
    if (~index) {
        observers.splice(index, 1);
    }

    // Remove listeners if controller has no connected observers.
    if (!observers.length && this.connected_) {
        this.disconnect_();
    }
};

/**
 * Invokes the update of observers. It will continue running updates insofar
 * it detects changes.
 *
 * @returns {void}
 */
ResizeObserverController.prototype.refresh = function () {
    var changesDetected = this.updateObservers_();

    // Continue running updates if changes have been detected as there might
    // be future ones caused by CSS transitions.
    if (changesDetected) {
        this.refresh();
    }
};

/**
 * Updates every observer from observers list and notifies them of queued
 * entries.
 *
 * @private
 * @returns {boolean} Returns "true" if any observer has detected changes in
 *  dimensions of it's elements.
 */
ResizeObserverController.prototype.updateObservers_ = function () {
    // Collect observers that have active observations.
    var activeObservers = this.observers_.filter(function (observer) {
        return observer.gatherActive(), observer.hasActive();
    });

    // Deliver notifications in a separate cycle in order to avoid any
    // collisions between observers, e.g. when multiple instances of
    // ResizeObserver are tracking the same element and the callback of one
    // of them changes content dimensions of the observed target. Sometimes
    // this may result in notifications being blocked for the rest of observers.
    activeObservers.forEach(function (observer) { return observer.broadcastActive(); });

    return activeObservers.length > 0;
};

/**
 * Initializes DOM listeners.
 *
 * @private
 * @returns {void}
 */
ResizeObserverController.prototype.connect_ = function () {
    // Do nothing if running in a non-browser environment or if listeners
    // have been already added.
    if (!isBrowser || this.connected_) {
        return;
    }

    // Subscription to the "Transitionend" event is used as a workaround for
    // delayed transitions. This way it's possible to capture at least the
    // final state of an element.
    document.addEventListener('transitionend', this.onTransitionEnd_);

    window.addEventListener('resize', this.refresh);

    if (mutationObserverSupported) {
        this.mutationsObserver_ = new MutationObserver(this.refresh);

        this.mutationsObserver_.observe(document, {
            attributes: true,
            childList: true,
            characterData: true,
            subtree: true
        });
    } else {
        document.addEventListener('DOMSubtreeModified', this.refresh);

        this.mutationEventsAdded_ = true;
    }

    this.connected_ = true;
};

/**
 * Removes DOM listeners.
 *
 * @private
 * @returns {void}
 */
ResizeObserverController.prototype.disconnect_ = function () {
    // Do nothing if running in a non-browser environment or if listeners
    // have been already removed.
    if (!isBrowser || !this.connected_) {
        return;
    }

    document.removeEventListener('transitionend', this.onTransitionEnd_);
    window.removeEventListener('resize', this.refresh);

    if (this.mutationsObserver_) {
        this.mutationsObserver_.disconnect();
    }

    if (this.mutationEventsAdded_) {
        document.removeEventListener('DOMSubtreeModified', this.refresh);
    }

    this.mutationsObserver_ = null;
    this.mutationEventsAdded_ = false;
    this.connected_ = false;
};

/**
 * "Transitionend" event handler.
 *
 * @private
 * @param {TransitionEvent} event
 * @returns {void}
 */
ResizeObserverController.prototype.onTransitionEnd_ = function (ref) {
        var propertyName = ref.propertyName; if ( propertyName === void 0 ) propertyName = '';

    // Detect whether transition may affect dimensions of an element.
    var isReflowProperty = transitionKeys.some(function (key) {
        return !!~propertyName.indexOf(key);
    });

    if (isReflowProperty) {
        this.refresh();
    }
};

/**
 * Returns instance of the ResizeObserverController.
 *
 * @returns {ResizeObserverController}
 */
ResizeObserverController.getInstance = function () {
    if (!this.instance_) {
        this.instance_ = new ResizeObserverController();
    }

    return this.instance_;
};

ResizeObserverController.instance_ = null;

/**
 * Defines non-writable/enumerable properties of the provided target object.
 *
 * @param {Object} target - Object for which to define properties.
 * @param {Object} props - Properties to be defined.
 * @returns {Object} Target object.
 */
var defineConfigurable = (function (target, props) {
    for (var i = 0, list = Object.keys(props); i < list.length; i += 1) {
        var key = list[i];

        Object.defineProperty(target, key, {
            value: props[key],
            enumerable: false,
            writable: false,
            configurable: true
        });
    }

    return target;
});

/**
 * Returns the global object associated with provided element.
 *
 * @param {Object} target
 * @returns {Object}
 */
var getWindowOf = (function (target) {
    // Assume that the element is an instance of Node, which means that it
    // has the "ownerDocument" property from which we can retrieve a
    // corresponding global object.
    var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;

    // Return the local global object if it's not possible extract one from
    // provided element.
    return ownerGlobal || global$1;
});

// Placeholder of an empty content rectangle.
var emptyRect = createRectInit(0, 0, 0, 0);

/**
 * Converts provided string to a number.
 *
 * @param {number|string} value
 * @returns {number}
 */
function toFloat(value) {
    return parseFloat(value) || 0;
}

/**
 * Extracts borders size from provided styles.
 *
 * @param {CSSStyleDeclaration} styles
 * @param {...string} positions - Borders positions (top, right, ...)
 * @returns {number}
 */
function getBordersSize(styles) {
    var positions = [], len = arguments.length - 1;
    while ( len-- > 0 ) positions[ len ] = arguments[ len + 1 ];

    return positions.reduce(function (size, position) {
        var value = styles['border-' + position + '-width'];

        return size + toFloat(value);
    }, 0);
}

/**
 * Extracts paddings sizes from provided styles.
 *
 * @param {CSSStyleDeclaration} styles
 * @returns {Object} Paddings box.
 */
function getPaddings(styles) {
    var positions = ['top', 'right', 'bottom', 'left'];
    var paddings = {};

    for (var i = 0, list = positions; i < list.length; i += 1) {
        var position = list[i];

        var value = styles['padding-' + position];

        paddings[position] = toFloat(value);
    }

    return paddings;
}

/**
 * Calculates content rectangle of provided SVG element.
 *
 * @param {SVGGraphicsElement} target - Element content rectangle of which needs
 *      to be calculated.
 * @returns {DOMRectInit}
 */
function getSVGContentRect(target) {
    var bbox = target.getBBox();

    return createRectInit(0, 0, bbox.width, bbox.height);
}

/**
 * Calculates content rectangle of provided HTMLElement.
 *
 * @param {HTMLElement} target - Element for which to calculate the content rectangle.
 * @returns {DOMRectInit}
 */
function getHTMLElementContentRect(target) {
    // Client width & height properties can't be
    // used exclusively as they provide rounded values.
    var clientWidth = target.clientWidth;
    var clientHeight = target.clientHeight;

    // By this condition we can catch all non-replaced inline, hidden and
    // detached elements. Though elements with width & height properties less
    // than 0.5 will be discarded as well.
    //
    // Without it we would need to implement separate methods for each of
    // those cases and it's not possible to perform a precise and performance
    // effective test for hidden elements. E.g. even jQuery's ':visible' filter
    // gives wrong results for elements with width & height less than 0.5.
    if (!clientWidth && !clientHeight) {
        return emptyRect;
    }

    var styles = getWindowOf(target).getComputedStyle(target);
    var paddings = getPaddings(styles);
    var horizPad = paddings.left + paddings.right;
    var vertPad = paddings.top + paddings.bottom;

    // Computed styles of width & height are being used because they are the
    // only dimensions available to JS that contain non-rounded values. It could
    // be possible to utilize the getBoundingClientRect if only it's data wasn't
    // affected by CSS transformations let alone paddings, borders and scroll bars.
    var width = toFloat(styles.width),
        height = toFloat(styles.height);

    // Width & height include paddings and borders when the 'border-box' box
    // model is applied (except for IE).
    if (styles.boxSizing === 'border-box') {
        // Following conditions are required to handle Internet Explorer which
        // doesn't include paddings and borders to computed CSS dimensions.
        //
        // We can say that if CSS dimensions + paddings are equal to the "client"
        // properties then it's either IE, and thus we don't need to subtract
        // anything, or an element merely doesn't have paddings/borders styles.
        if (Math.round(width + horizPad) !== clientWidth) {
            width -= getBordersSize(styles, 'left', 'right') + horizPad;
        }

        if (Math.round(height + vertPad) !== clientHeight) {
            height -= getBordersSize(styles, 'top', 'bottom') + vertPad;
        }
    }

    // Following steps can't be applied to the document's root element as its
    // client[Width/Height] properties represent viewport area of the window.
    // Besides, it's as well not necessary as the <html> itself neither has
    // rendered scroll bars nor it can be clipped.
    if (!isDocumentElement(target)) {
        // In some browsers (only in Firefox, actually) CSS width & height
        // include scroll bars size which can be removed at this step as scroll
        // bars are the only difference between rounded dimensions + paddings
        // and "client" properties, though that is not always true in Chrome.
        var vertScrollbar = Math.round(width + horizPad) - clientWidth;
        var horizScrollbar = Math.round(height + vertPad) - clientHeight;

        // Chrome has a rather weird rounding of "client" properties.
        // E.g. for an element with content width of 314.2px it sometimes gives
        // the client width of 315px and for the width of 314.7px it may give
        // 314px. And it doesn't happen all the time. So just ignore this delta
        // as a non-relevant.
        if (Math.abs(vertScrollbar) !== 1) {
            width -= vertScrollbar;
        }

        if (Math.abs(horizScrollbar) !== 1) {
            height -= horizScrollbar;
        }
    }

    return createRectInit(paddings.left, paddings.top, width, height);
}

/**
 * Checks whether provided element is an instance of the SVGGraphicsElement.
 *
 * @param {Element} target - Element to be checked.
 * @returns {boolean}
 */
var isSVGGraphicsElement = (function () {
    // Some browsers, namely IE and Edge, don't have the SVGGraphicsElement
    // interface.
    if (typeof SVGGraphicsElement !== 'undefined') {
        return function (target) { return target instanceof getWindowOf(target).SVGGraphicsElement; };
    }

    // If it's so, then check that element is at least an instance of the
    // SVGElement and that it has the "getBBox" method.
    // eslint-disable-next-line no-extra-parens
    return function (target) { return target instanceof getWindowOf(target).SVGElement && typeof target.getBBox === 'function'; };
})();

/**
 * Checks whether provided element is a document element (<html>).
 *
 * @param {Element} target - Element to be checked.
 * @returns {boolean}
 */
function isDocumentElement(target) {
    return target === getWindowOf(target).document.documentElement;
}

/**
 * Calculates an appropriate content rectangle for provided html or svg element.
 *
 * @param {Element} target - Element content rectangle of which needs to be calculated.
 * @returns {DOMRectInit}
 */
function getContentRect(target) {
    if (!isBrowser) {
        return emptyRect;
    }

    if (isSVGGraphicsElement(target)) {
        return getSVGContentRect(target);
    }

    return getHTMLElementContentRect(target);
}

/**
 * Creates rectangle with an interface of the DOMRectReadOnly.
 * Spec: https://drafts.fxtf.org/geometry/#domrectreadonly
 *
 * @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.
 * @returns {DOMRectReadOnly}
 */
function createReadOnlyRect(ref) {
    var x = ref.x;
    var y = ref.y;
    var width = ref.width;
    var height = ref.height;

    // If DOMRectReadOnly is available use it as a prototype for the rectangle.
    var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;
    var rect = Object.create(Constr.prototype);

    // Rectangle's properties are not writable and non-enumerable.
    defineConfigurable(rect, {
        x: x, y: y, width: width, height: height,
        top: y,
        right: x + width,
        bottom: height + y,
        left: x
    });

    return rect;
}

/**
 * Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.
 * Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit
 *
 * @param {number} x - X coordinate.
 * @param {number} y - Y coordinate.
 * @param {number} width - Rectangle's width.
 * @param {number} height - Rectangle's height.
 * @returns {DOMRectInit}
 */
function createRectInit(x, y, width, height) {
    return { x: x, y: y, width: width, height: height };
}

/**
 * Class that is responsible for computations of the content rectangle of
 * provided DOM element and for keeping track of it's changes.
 */
var ResizeObservation = function(target) {
    this.broadcastWidth = 0;
    this.broadcastHeight = 0;
    this.contentRect_ = createRectInit(0, 0, 0, 0);

    this.target = target;
};

/**
 * Updates content rectangle and tells whether it's width or height properties
 * have changed since the last broadcast.
 *
 * @returns {boolean}
 */


/**
 * Reference to the last observed content rectangle.
 *
 * @private {DOMRectInit}
 */


/**
 * Broadcasted width of content rectangle.
 *
 * @type {number}
 */
ResizeObservation.prototype.isActive = function () {
    var rect = getContentRect(this.target);

    this.contentRect_ = rect;

    return rect.width !== this.broadcastWidth || rect.height !== this.broadcastHeight;
};

/**
 * Updates 'broadcastWidth' and 'broadcastHeight' properties with a data
 * from the corresponding properties of the last observed content rectangle.
 *
 * @returns {DOMRectInit} Last observed content rectangle.
 */
ResizeObservation.prototype.broadcastRect = function () {
    var rect = this.contentRect_;

    this.broadcastWidth = rect.width;
    this.broadcastHeight = rect.height;

    return rect;
};

var ResizeObserverEntry = function(target, rectInit) {
    var contentRect = createReadOnlyRect(rectInit);

    // According to the specification following properties are not writable
    // and are also not enumerable in the native implementation.
    //
    // Property accessors are not being used as they'd require to define a
    // private WeakMap storage which may cause memory leaks in browsers that
    // don't support this type of collections.
    defineConfigurable(this, { target: target, contentRect: contentRect });
};

var ResizeObserverSPI = function(callback, controller, callbackCtx) {
    this.activeObservations_ = [];
    this.observations_ = new MapShim();

    if (typeof callback !== 'function') {
        throw new TypeError('The callback provided as parameter 1 is not a function.');
    }

    this.callback_ = callback;
    this.controller_ = controller;
    this.callbackCtx_ = callbackCtx;
};

/**
 * Starts observing provided element.
 *
 * @param {Element} target - Element to be observed.
 * @returns {void}
 */


/**
 * Registry of the ResizeObservation instances.
 *
 * @private {Map<Element, ResizeObservation>}
 */


/**
 * Public ResizeObserver instance which will be passed to the callback
 * function and used as a value of it's "this" binding.
 *
 * @private {ResizeObserver}
 */

/**
 * Collection of resize observations that have detected changes in dimensions
 * of elements.
 *
 * @private {Array<ResizeObservation>}
 */
ResizeObserverSPI.prototype.observe = function (target) {
    if (!arguments.length) {
        throw new TypeError('1 argument required, but only 0 present.');
    }

    // Do nothing if current environment doesn't have the Element interface.
    if (typeof Element === 'undefined' || !(Element instanceof Object)) {
        return;
    }

    if (!(target instanceof getWindowOf(target).Element)) {
        throw new TypeError('parameter 1 is not of type "Element".');
    }

    var observations = this.observations_;

    // Do nothing if element is already being observed.
    if (observations.has(target)) {
        return;
    }

    observations.set(target, new ResizeObservation(target));

    this.controller_.addObserver(this);

    // Force the update of observations.
    this.controller_.refresh();
};

/**
 * Stops observing provided element.
 *
 * @param {Element} target - Element to stop observing.
 * @returns {void}
 */
ResizeObserverSPI.prototype.unobserve = function (target) {
    if (!arguments.length) {
        throw new TypeError('1 argument required, but only 0 present.');
    }

    // Do nothing if current environment doesn't have the Element interface.
    if (typeof Element === 'undefined' || !(Element instanceof Object)) {
        return;
    }

    if (!(target instanceof getWindowOf(target).Element)) {
        throw new TypeError('parameter 1 is not of type "Element".');
    }

    var observations = this.observations_;

    // Do nothing if element is not being observed.
    if (!observations.has(target)) {
        return;
    }

    observations.delete(target);

    if (!observations.size) {
        this.controller_.removeObserver(this);
    }
};

/**
 * Stops observing all elements.
 *
 * @returns {void}
 */
ResizeObserverSPI.prototype.disconnect = function () {
    this.clearActive();
    this.observations_.clear();
    this.controller_.removeObserver(this);
};

/**
 * Collects observation instances the associated element of which has changed
 * it's content rectangle.
 *
 * @returns {void}
 */
ResizeObserverSPI.prototype.gatherActive = function () {
        var this$1 = this;

    this.clearActive();

    this.observations_.forEach(function (observation) {
        if (observation.isActive()) {
            this$1.activeObservations_.push(observation);
        }
    });
};

/**
 * Invokes initial callback function with a list of ResizeObserverEntry
 * instances collected from active resize observations.
 *
 * @returns {void}
 */
ResizeObserverSPI.prototype.broadcastActive = function () {
    // Do nothing if observer doesn't have active observations.
    if (!this.hasActive()) {
        return;
    }

    var ctx = this.callbackCtx_;

    // Create ResizeObserverEntry instance for every active observation.
    var entries = this.activeObservations_.map(function (observation) {
        return new ResizeObserverEntry(observation.target, observation.broadcastRect());
    });

    this.callback_.call(ctx, entries, ctx);
    this.clearActive();
};

/**
 * Clears the collection of active observations.
 *
 * @returns {void}
 */
ResizeObserverSPI.prototype.clearActive = function () {
    this.activeObservations_.splice(0);
};

/**
 * Tells whether observer has active observations.
 *
 * @returns {boolean}
 */
ResizeObserverSPI.prototype.hasActive = function () {
    return this.activeObservations_.length > 0;
};

// Registry of internal observers. If WeakMap is not available use current shim
// for the Map collection as it has all required methods and because WeakMap
// can't be fully polyfilled anyway.
var observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();

/**
 * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation
 * exposing only those methods and properties that are defined in the spec.
 */
var ResizeObserver = function(callback) {
    if (!(this instanceof ResizeObserver)) {
        throw new TypeError('Cannot call a class as a function.');
    }
    if (!arguments.length) {
        throw new TypeError('1 argument required, but only 0 present.');
    }

    var controller = ResizeObserverController.getInstance();
    var observer = new ResizeObserverSPI(callback, controller, this);

    observers.set(this, observer);
};

// Expose public methods of ResizeObserver.
['observe', 'unobserve', 'disconnect'].forEach(function (method) {
    ResizeObserver.prototype[method] = function () {
        return (ref = observers.get(this))[method].apply(ref, arguments);
        var ref;
    };
});

var index = (function () {
    // Export existing implementation if available.
    if (typeof global$1.ResizeObserver !== 'undefined') {
        return global$1.ResizeObserver;
    }

    global$1.ResizeObserver = ResizeObserver;

    return ResizeObserver;
})();

return index;

})));


var Router = function(config) {
	this.webhost = config['host'].replace(/^(https?:\/\/[^\/]+)(\/.*)?$/, '$1');
	this.req     = {};

	if (config.error_callback) {
		this.errorCallback = config.error_callback;
	}

	try {
		// parse url get all informations
		this.req = this.parseUrl(config['url']);
	} catch (err) {
		this.errorCallback(err);
	}
};

Router.prototype = {
	// get the full request object
	getRequest: function() {
		return this.req;
	},

	// get the full webhost
	getWebhost : function() {
		return this.webhost;
	},

	// get the host
	getHost: function() {
		return this.req['host'];
	},

	// get the full path
	getPath: function() {
		return this.req['path'];
	},

	// get the current module
	getModule: function() {
		return this.req['module'];
	},

	// get the current controller
	getController: function() {
		return this.req['controller'];
	},

	// get the current action
	getAction: function() {
		return this.req['action'];
	},

	// get the current moduleName (camel case)
	getModuleName: function() {
		return this.req['module_name'];
	},

	// get the current controllerName (camel case)
	getControllerName: function() {
		return this.req['controller_name'];
	},

	// get the current actionName (camel case)
	getActionName: function() {
		return this.req['action_name'];
	},

	// get the current hash
	getHash: function() {
		return this.req['hash'];
	},

	// get the current protocol
    getProtocol: function() {
        return this.req['protocol'];
    },

	// get all parameters
	getParams: function() {
		return this.req['parameters'];
	},

	// get param from the parameters object, defaultValue as parameter or null.
	getParam: function(key, defaultValue) {
		if (!defaultValue) {
			defaultValue = null;
		}

		return (typeof this.req['parameters'][key] !== 'undefined') ? this.req['parameters'][key] : defaultValue;
	},

	// check if the parameter is available
	hasParam: function(key) {
		return (typeof this.req['parameters'][key] !== 'undefined');
	},

	/**
	 * check the given path and fire callback on domready or directly
	 *
	 * @param string $rgExpPath the current path as regex.
	 * @param function $cb callback function
	 * @param string $onEvent value for when the callback are fired
	 *
	 * @return void
	 */
	request: function(rgExpPath, cb, onEvent) {
		// set default value to false
		onEvent = String(onEvent) || 'direct';

		// set lower case
		onEvent = onEvent.toLowerCase();

		// clean the rgExpPath
		rgExpPath = rgExpPath.replace(/[\/]+$/g, '');

		var cbMatches = [];
		var pathRegEx = new RegExp(rgExpPath, 'i');
		var matches   = this.getPath().match(pathRegEx);

		// path not match
		if (!matches) {
			return;
		}

		// parpare selected matches
		[].forEach.call(matches, function(pathMatch, k) {
			if (!k) {
				// skip first one
				return;
			}

			cbMatches.push(pathMatch);
		});

		// is domready event
		if (onEvent === 'domready') {
			document.addEventListener("DOMContentLoaded", function() {
				try {
					cb.bind(this).apply(null, cbMatches);
				} catch (err) {
					this.errorCallback(err);
				}
			}.bind(this));
			return;
		}

		// is load event
		if (onEvent === 'load') {
			window.addEventListener("load", function() {
				try {
					cb.bind(this).apply(null, cbMatches);
				} catch (err) {
					this.errorCallback(err);
				}
			}.bind(this), false);
			return;
		}

		try {
			cb.bind(this)();
		} catch (err) {
			this.errorCallback(err);
		}

		/**
		 * @todo add more scroll e.g.?
		 */
	},

	/**
	 * parse the url to get module, controller e.g..
	 *
	 * @param string $url the current location
	 *
	 * @return object
	 */
	parseUrl : function(url) {
		var req = {};

		if (!url) {
			return req;
		}

		var path  = '';
		var hash  = '';
		var query = '';
		var rg    = new RegExp('^' + this.webhost, 'i');

		// cleanup url: remove host, first slash, last slash and double slash
		url = url.replace(rg, '').replace(/^\/|[\/]+$/g, '').replace(/[\/]{2,}/g, '/');

		// get the hash and remove from array
		if (url.indexOf('#') !== -1) {
			hash = url.replace(/.+?#/, '');
			url  = url.replace(/#.+$/, '');
		}

		// get url query string and remove from array
		if (url.indexOf('?') !== -1) {
			query = url.replace(/.+?\?/, '');
			url   = url.replace(/\?.+/, '').replace(/\/$/, '');
		}

		// set path
		path = url;

		// replace controllerName controller-name to controllerName and split the paths
		var pathParts = path.replace(/(-[a-z])/ig, function(mat) {
			return mat.replace('-', '').toUpperCase();
		}).split('/');

		// split urls in parts
		url = url.split('/');

		// init default parameters
		var req = {
			'query'		 : query,
			'module'     : (url[0]) ? url[0] : '',
			'controller' : (url[1]) ? url[1] : '',
			'action'     : (url[2]) ? url[2] : '',
			'module_name'      : (pathParts[0]) ? pathParts[0] : '',
			'controller_name ' : (pathParts[1]) ? pathParts[1] : '',
			'action_name': (pathParts[2]) ? pathParts[2] : '',
			'path'       : path,
			'hash'		 : hash,
			'host'		 : this.webhost.replace(/^https?:\/\//, '').replace(/\/.*$/, ''),
			'protocol'   : location.protocol.replace(/[^\w]+/, ''),
			'parameters' : {}
		};

		if (String.toUpperCaseFirst) {
			req['module_name']     = String.toUpperCaseFirst(req['module_name']);
			req['controller_name'] = String.toUpperCaseFirst(req['controller_name']);
		}

		// if the query is not empty check parameters
		if (query !== '') {
			// counter to get currect obj structure
			var objNameCounter = {};

			// split query
			[].forEach.call(query.split('&'), function(paramParts) {
				var parts    = paramParts.split('=');

				// check if the part is multidimensional
				var arrParts = parts[0].match(/\[(.+?|)\]/g);

				if (!arrParts) {
					// not set to default parameters obj
					req['parameters'][decodeURIComponent(parts[0])] = decodeURIComponent(parts[1]);
					return;
				}

				// get multidimensional obj name
				parts[0] = parts[0].replace(/\[.+$/, '');

				var objStr = [];
				[].forEach.call(arrParts, function(arrPart) {
					arrPart = arrPart.replace(/\[|\]/g, '');

					objStr.push(arrPart);
				});

				// build object structure to get multi objects e.g.: obj[value1][value2] if the structure is ready fill the req parameters obj with eval
				var tmpStr = 'req["parameters"]["' + parts[0] + '"]';
				[].forEach.call(objStr, function(objPart, k) {
					eval('if (!' + tmpStr + ' || typeof ' + tmpStr + ' !== "object") ' + tmpStr + ' = {};');

					// if the objPart is empty e.g. param[]= fill with numbers
					if (objPart === '') {
						if (typeof objNameCounter[tmpStr] === 'undefined') {
							objNameCounter[tmpStr] = -1;
						}

						objNameCounter[tmpStr]++;

						objPart = objNameCounter[tmpStr];
					}

					tmpStr += '["' + objPart + '"]';

					eval('if (!' + tmpStr + ') ' + tmpStr + ' = {};');
				});

				eval(tmpStr + ' = decodeURIComponent("' + parts[1] + '");');
			});
		}

		// get the url structure parameters module/controller/action/param/value
		var len = url.length;

		// ignore the first tree, they area module controller action
		for (var i = 3; i < len; i += 2) {
			if (url[i]) {
				url[i] = decodeURIComponent(url[i]);
			}

			// check if the obj key is alreay exists and build a new obj if needed
			if (req['parameters'][url[i]]) {
				if (typeof req['parameters'][url[i]] !== 'object') {
					req['parameters'][url[i]] = [req['parameters'][url[i]]];
				}

				req['parameters'][url[i]].push((url[i+1]) ? decodeURIComponent(url[i+1]) : null);

				continue;
			}

			// fill the parameters obj values and decode the values
			req['parameters'][url[i]] = (url[i+1]) ? decodeURIComponent(url[i+1]) : null;
		}

		return req;
	},

	// error callback function fired on catch an error
	errorCallback : function(err) {
		console.warn(err);
	}
};

if (!String.prototype.trim) {
    String.prototype.trim = function() {
        return this.replace(/^\s+|\s+$/g, '');
    };
}

if (!String.prototype.vsprintf) {
    String.prototype.vsprintf = function(args) {
        var self = this;

        if (!(args instanceof Array)) {
            args = [];
        }

        args.forEach(function(arg) {
            if (['string', 'number', 'boolean'].indexOf(typeof arg) === -1) {
                arg = '';
            }

            self = self.replace(/\%s/, arg);
        });

        self = self.replace(/\%s/g, '');

        return self;
    };
}

if (!String.prototype.sprintf) {
    String.prototype.sprintf = function() {
        return this.vsprintf([].slice.call(arguments));
    };
}

if (!String.prototype.toUpperCaseFirst) {
    String.prototype.toUpperCaseFirst = function() {
        return this.charAt(0).toUpperCase() + this.substr(1);
    };
}

if (!String.prototype.toLowerCaseFirst) {
    String.prototype.toLowerCaseFirst = function() {
        return this.charAt(0).toLowerCase() + this.substr(1);
    };
}

if (!String.prototype.toUpperCaseWords) {
    String.prototype.toUpperCaseWords = function() {
        return this.replace(/^(.)|\s+(.)/g, function ($1) {
            return $1.toUpperCase();
        });
    };
}

if (!String.prototype.latinize) {
    String.prototype.latinize = function() {
		var characters = {
			'Á' : 'A',
			'Ă' : 'A',
			'Ắ' : 'A',
			'Ặ' : 'A',
			'Ằ' : 'A',
			'Ẳ' : 'A',
			'Ẵ' : 'A',
			'Ǎ' : 'A',
			'Â' : 'A',
			'Ấ' : 'A',
			'Ậ' : 'A',
			'Ầ' : 'A',
			'Ẩ' : 'A',
			'Ẫ' : 'A',
			'Ä' : 'A',
			'Ǟ' : 'A',
			'Ȧ' : 'A',
			'Ǡ' : 'A',
			'Ạ' : 'A',
			'Ȁ' : 'A',
			'À' : 'A',
			'Ả' : 'A',
			'Ȃ' : 'A',
			'Ā' : 'A',
			'Ą' : 'A',
			'Å' : 'A',
			'Ǻ' : 'A',
			'Ḁ' : 'A',
			'Ⱥ' : 'A',
			'Ã' : 'A',
			'Æ' : 'AE',
			'Ǽ' : 'AE',
			'Ǣ' : 'AE',
			'Ḃ' : 'B',
			'Ḅ' : 'B',
			'Ɓ' : 'B',
			'Ḇ' : 'B',
			'Ƀ' : 'B',
			'Ƃ' : 'B',
			'Ć' : 'C',
			'Č' : 'C',
			'Ç' : 'C',
			'Ḉ' : 'C',
			'Ĉ' : 'C',
			'Ċ' : 'C',
			'Ƈ' : 'C',
			'Ȼ' : 'C',
			'Ď' : 'D',
			'Ḑ' : 'D',
			'Ḓ' : 'D',
			'Ḋ' : 'D',
			'Ḍ' : 'D',
			'Ɗ' : 'D',
			'Ḏ' : 'D',
			'Dz' : 'D',
			'Dž' : 'D',
			'Đ' : 'D',
			'Ƌ' : 'D',
			'DZ' : 'DZ',
			'DŽ' : 'DZ',
			'É' : 'E',
			'Ĕ' : 'E',
			'Ě' : 'E',
			'Ȩ' : 'E',
			'Ḝ' : 'E',
			'Ê' : 'E',
			'Ế' : 'E',
			'Ệ' : 'E',
			'Ề' : 'E',
			'Ể' : 'E',
			'Ễ' : 'E',
			'Ḙ' : 'E',
			'Ë' : 'E',
			'Ė' : 'E',
			'Ẹ' : 'E',
			'Ȅ' : 'E',
			'È' : 'E',
			'Ẻ' : 'E',
			'Ȇ' : 'E',
			'Ē' : 'E',
			'Ḗ' : 'E',
			'Ḕ' : 'E',
			'Ę' : 'E',
			'Ɇ' : 'E',
			'Ẽ' : 'E',
			'Ḛ' : 'E',
			'Ꝫ' : 'ET',
			'Ḟ' : 'F',
			'Ƒ' : 'F',
			'Ǵ' : 'G',
			'Ğ' : 'G',
			'Ǧ' : 'G',
			'Ģ' : 'G',
			'Ĝ' : 'G',
			'Ġ' : 'G',
			'Ɠ' : 'G',
			'Ḡ' : 'G',
			'Ǥ' : 'G',
			'Ḫ' : 'H',
			'Ȟ' : 'H',
			'Ḩ' : 'H',
			'Ĥ' : 'H',
			'Ⱨ' : 'H',
			'Ḧ' : 'H',
			'Ḣ' : 'H',
			'Ḥ' : 'H',
			'Ħ' : 'H',
			'Í' : 'I',
			'Ĭ' : 'I',
			'Ǐ' : 'I',
			'Î' : 'I',
			'Ï' : 'I',
			'Ḯ' : 'I',
			'İ' : 'I',
			'Ị' : 'I',
			'Ȉ' : 'I',
			'Ì' : 'I',
			'Ỉ' : 'I',
			'Ȋ' : 'I',
			'Ī' : 'I',
			'Į' : 'I',
			'Ɨ' : 'I',
			'Ĩ' : 'I',
			'Ḭ' : 'I',
			'Ꝺ' : 'D',
			'Ꝼ' : 'F',
			'Ᵹ' : 'G',
			'Ꞃ' : 'R',
			'Ꞅ' : 'S',
			'Ꞇ' : 'T',
			'Ꝭ' : 'IS',
			'Ĵ' : 'J',
			'Ɉ' : 'J',
			'Ḱ' : 'K',
			'Ǩ' : 'K',
			'Ķ' : 'K',
			'Ⱪ' : 'K',
			'Ꝃ' : 'K',
			'Ḳ' : 'K',
			'Ƙ' : 'K',
			'Ḵ' : 'K',
			'Ꝁ' : 'K',
			'Ꝅ' : 'K',
			'Ĺ' : 'L',
			'Ƚ' : 'L',
			'Ľ' : 'L',
			'Ļ' : 'L',
			'Ḽ' : 'L',
			'Ḷ' : 'L',
			'Ḹ' : 'L',
			'Ⱡ' : 'L',
			'Ꝉ' : 'L',
			'Ḻ' : 'L',
			'Ŀ' : 'L',
			'Ɫ' : 'L',
			'Lj' : 'L',
			'Ł' : 'L',
			'LJ' : 'LJ',
			'Ḿ' : 'M',
			'Ṁ' : 'M',
			'Ṃ' : 'M',
			'Ɱ' : 'M',
			'Ń' : 'N',
			'Ň' : 'N',
			'Ņ' : 'N',
			'Ṋ' : 'N',
			'Ṅ' : 'N',
			'Ṇ' : 'N',
			'Ǹ' : 'N',
			'Ɲ' : 'N',
			'Ṉ' : 'N',
			'Ƞ' : 'N',
			'Nj' : 'N',
			'Ñ' : 'N',
			'NJ' : 'NJ',
			'Ó' : 'O',
			'Ŏ' : 'O',
			'Ǒ' : 'O',
			'Ô' : 'O',
			'Ố' : 'O',
			'Ộ' : 'O',
			'Ồ' : 'O',
			'Ổ' : 'O',
			'Ỗ' : 'O',
			'Ö' : 'O',
			'Ȫ' : 'O',
			'Ȯ' : 'O',
			'Ȱ' : 'O',
			'Ọ' : 'O',
			'Ő' : 'O',
			'Ȍ' : 'O',
			'Ò' : 'O',
			'Ỏ' : 'O',
			'Ơ' : 'O',
			'Ớ' : 'O',
			'Ợ' : 'O',
			'Ờ' : 'O',
			'Ở' : 'O',
			'Ỡ' : 'O',
			'Ȏ' : 'O',
			'Ꝋ' : 'O',
			'Ꝍ' : 'O',
			'Ō' : 'O',
			'Ṓ' : 'O',
			'Ṑ' : 'O',
			'Ɵ' : 'O',
			'Ǫ' : 'O',
			'Ǭ' : 'O',
			'Ø' : 'O',
			'Ǿ' : 'O',
			'Õ' : 'O',
			'Ṍ' : 'O',
			'Ṏ' : 'O',
			'Ȭ' : 'O',
			'Ƣ' : 'OI',
			'Ɛ' : 'E',
			'Ɔ' : 'O',
			'Ȣ' : 'OU',
			'Ṕ' : 'P',
			'Ṗ' : 'P',
			'Ꝓ' : 'P',
			'Ƥ' : 'P',
			'Ꝕ' : 'P',
			'Ᵽ' : 'P',
			'Ꝑ' : 'P',
			'Ꝙ' : 'Q',
			'Ꝗ' : 'Q',
			'Ŕ' : 'R',
			'Ř' : 'R',
			'Ŗ' : 'R',
			'Ṙ' : 'R',
			'Ṛ' : 'R',
			'Ṝ' : 'R',
			'Ȑ' : 'R',
			'Ȓ' : 'R',
			'Ṟ' : 'R',
			'Ɍ' : 'R',
			'Ɽ' : 'R',
			'Ꜿ' : 'C',
			'Ǝ' : 'E',
			'Ś' : 'S',
			'Ṥ' : 'S',
			'Š' : 'S',
			'Ṧ' : 'S',
			'Ş' : 'S',
			'Ŝ' : 'S',
			'Ș' : 'S',
			'Ṡ' : 'S',
			'Ṣ' : 'S',
			'Ṩ' : 'S',
			'ß' : 'ss',
			'Ť' : 'T',
			'Ţ' : 'T',
			'Ṱ' : 'T',
			'Ț' : 'T',
			'Ⱦ' : 'T',
			'Ṫ' : 'T',
			'Ṭ' : 'T',
			'Ƭ' : 'T',
			'Ṯ' : 'T',
			'Ʈ' : 'T',
			'Ŧ' : 'T',
			'Ɐ' : 'A',
			'Ꞁ' : 'L',
			'Ɯ' : 'M',
			'Ʌ' : 'V',
			'Ꜩ' : 'TZ',
			'Ú' : 'U',
			'Ŭ' : 'U',
			'Ǔ' : 'U',
			'Û' : 'U',
			'Ṷ' : 'U',
			'Ü' : 'U',
			'Ǘ' : 'U',
			'Ǚ' : 'U',
			'Ǜ' : 'U',
			'Ǖ' : 'U',
			'Ṳ' : 'U',
			'Ụ' : 'U',
			'Ű' : 'U',
			'Ȕ' : 'U',
			'Ù' : 'U',
			'Ủ' : 'U',
			'Ư' : 'U',
			'Ứ' : 'U',
			'Ự' : 'U',
			'Ừ' : 'U',
			'Ử' : 'U',
			'Ữ' : 'U',
			'Ȗ' : 'U',
			'Ū' : 'U',
			'Ṻ' : 'U',
			'Ų' : 'U',
			'Ů' : 'U',
			'Ũ' : 'U',
			'Ṹ' : 'U',
			'Ṵ' : 'U',
			'Ꝟ' : 'V',
			'Ṿ' : 'V',
			'Ʋ' : 'V',
			'Ṽ' : 'V',
			'Ꝡ' : 'VY',
			'Ẃ' : 'W',
			'Ŵ' : 'W',
			'Ẅ' : 'W',
			'Ẇ' : 'W',
			'Ẉ' : 'W',
			'Ẁ' : 'W',
			'Ⱳ' : 'W',
			'Ẍ' : 'X',
			'Ẋ' : 'X',
			'Ý' : 'Y',
			'Ŷ' : 'Y',
			'Ÿ' : 'Y',
			'Ẏ' : 'Y',
			'Ỵ' : 'Y',
			'Ỳ' : 'Y',
			'Ƴ' : 'Y',
			'Ỷ' : 'Y',
			'Ỿ' : 'Y',
			'Ȳ' : 'Y',
			'Ɏ' : 'Y',
			'Ỹ' : 'Y',
			'Ź' : 'Z',
			'Ž' : 'Z',
			'Ẑ' : 'Z',
			'Ⱬ' : 'Z',
			'Ż' : 'Z',
			'Ẓ' : 'Z',
			'Ȥ' : 'Z',
			'Ẕ' : 'Z',
			'Ƶ' : 'Z',
			'IJ' : 'IJ',
			'Œ' : 'OE',
			'ᴀ' : 'A',
			'ᴁ' : 'AE',
			'ʙ' : 'B',
			'ᴃ' : 'B',
			'ᴄ' : 'C',
			'ᴅ' : 'D',
			'ᴇ' : 'E',
			'ꜰ' : 'F',
			'ɢ' : 'G',
			'ʛ' : 'G',
			'ʜ' : 'H',
			'ɪ' : 'I',
			'ʁ' : 'R',
			'ᴊ' : 'J',
			'ᴋ' : 'K',
			'ʟ' : 'L',
			'ᴌ' : 'L',
			'ᴍ' : 'M',
			'ɴ' : 'N',
			'ᴏ' : 'O',
			'ɶ' : 'OE',
			'ᴐ' : 'O',
			'ᴕ' : 'OU',
			'ᴘ' : 'P',
			'ʀ' : 'R',
			'ᴎ' : 'N',
			'ᴙ' : 'R',
			'ꜱ' : 'S',
			'ᴛ' : 'T',
			'ⱻ' : 'E',
			'ᴚ' : 'R',
			'ᴜ' : 'U',
			'ᴠ' : 'V',
			'ᴡ' : 'W',
			'ʏ' : 'Y',
			'ᴢ' : 'Z',
			'á' : 'a',
			'ă' : 'a',
			'ắ' : 'a',
			'ặ' : 'a',
			'ằ' : 'a',
			'ẳ' : 'a',
			'ẵ' : 'a',
			'ǎ' : 'a',
			'â' : 'a',
			'ấ' : 'a',
			'ậ' : 'a',
			'ầ' : 'a',
			'ẩ' : 'a',
			'ẫ' : 'a',
			'ä' : 'a',
			'ǟ' : 'a',
			'ȧ' : 'a',
			'ǡ' : 'a',
			'ạ' : 'a',
			'ȁ' : 'a',
			'à' : 'a',
			'ả' : 'a',
			'ȃ' : 'a',
			'ā' : 'a',
			'ą' : 'a',
			'ᶏ' : 'a',
			'ẚ' : 'a',
			'å' : 'a',
			'ǻ' : 'a',
			'ḁ' : 'a',
			'ⱥ' : 'a',
			'ã' : 'a',
			'ꜳ' : 'aa',
			'æ' : 'ae',
			'ǽ' : 'ae',
			'ǣ' : 'ae',
			'ꜵ' : 'ao',
			'ꜷ' : 'au',
			'ꜹ' : 'av',
			'ꜻ' : 'av',
			'ꜽ' : 'ay',
			'ḃ' : 'b',
			'ḅ' : 'b',
			'ɓ' : 'b',
			'ḇ' : 'b',
			'ᵬ' : 'b',
			'ᶀ' : 'b',
			'ƀ' : 'b',
			'ƃ' : 'b',
			'ɵ' : 'o',
			'ć' : 'c',
			'č' : 'c',
			'ç' : 'c',
			'ḉ' : 'c',
			'ĉ' : 'c',
			'ɕ' : 'c',
			'ċ' : 'c',
			'ƈ' : 'c',
			'ȼ' : 'c',
			'ď' : 'd',
			'ḑ' : 'd',
			'ḓ' : 'd',
			'ȡ' : 'd',
			'ḋ' : 'd',
			'ḍ' : 'd',
			'ɗ' : 'd',
			'ᶑ' : 'd',
			'ḏ' : 'd',
			'ᵭ' : 'd',
			'ᶁ' : 'd',
			'đ' : 'd',
			'ɖ' : 'd',
			'ƌ' : 'd',
			'ı' : 'i',
			'ȷ' : 'j',
			'ɟ' : 'j',
			'ʄ' : 'j',
			'dz' : 'dz',
			'dž' : 'dz',
			'é' : 'e',
			'ĕ' : 'e',
			'ě' : 'e',
			'ȩ' : 'e',
			'ḝ' : 'e',
			'ê' : 'e',
			'ế' : 'e',
			'ệ' : 'e',
			'ề' : 'e',
			'ể' : 'e',
			'ễ' : 'e',
			'ḙ' : 'e',
			'ë' : 'e',
			'ė' : 'e',
			'ẹ' : 'e',
			'ȅ' : 'e',
			'è' : 'e',
			'ẻ' : 'e',
			'ȇ' : 'e',
			'ē' : 'e',
			'ḗ' : 'e',
			'ḕ' : 'e',
			'ⱸ' : 'e',
			'ę' : 'e',
			'ᶒ' : 'e',
			'ɇ' : 'e',
			'ẽ' : 'e',
			'ḛ' : 'e',
			'ꝫ' : 'et',
			'ḟ' : 'f',
			'ƒ' : 'f',
			'ᵮ' : 'f',
			'ᶂ' : 'f',
			'ǵ' : 'g',
			'ğ' : 'g',
			'ǧ' : 'g',
			'ģ' : 'g',
			'ĝ' : 'g',
			'ġ' : 'g',
			'ɠ' : 'g',
			'ḡ' : 'g',
			'ᶃ' : 'g',
			'ǥ' : 'g',
			'ḫ' : 'h',
			'ȟ' : 'h',
			'ḩ' : 'h',
			'ĥ' : 'h',
			'ⱨ' : 'h',
			'ḧ' : 'h',
			'ḣ' : 'h',
			'ḥ' : 'h',
			'ɦ' : 'h',
			'ẖ' : 'h',
			'ħ' : 'h',
			'ƕ' : 'hv',
			'í' : 'i',
			'ĭ' : 'i',
			'ǐ' : 'i',
			'î' : 'i',
			'ï' : 'i',
			'ḯ' : 'i',
			'ị' : 'i',
			'ȉ' : 'i',
			'ì' : 'i',
			'ỉ' : 'i',
			'ȋ' : 'i',
			'ī' : 'i',
			'į' : 'i',
			'ᶖ' : 'i',
			'ɨ' : 'i',
			'ĩ' : 'i',
			'ḭ' : 'i',
			'ꝺ' : 'd',
			'ꝼ' : 'f',
			'ᵹ' : 'g',
			'ꞃ' : 'r',
			'ꞅ' : 's',
			'ꞇ' : 't',
			'ꝭ' : 'is',
			'ǰ' : 'j',
			'ĵ' : 'j',
			'ʝ' : 'j',
			'ɉ' : 'j',
			'ḱ' : 'k',
			'ǩ' : 'k',
			'ķ' : 'k',
			'ⱪ' : 'k',
			'ꝃ' : 'k',
			'ḳ' : 'k',
			'ƙ' : 'k',
			'ḵ' : 'k',
			'ᶄ' : 'k',
			'ꝁ' : 'k',
			'ꝅ' : 'k',
			'ĺ' : 'l',
			'ƚ' : 'l',
			'ɬ' : 'l',
			'ľ' : 'l',
			'ļ' : 'l',
			'ḽ' : 'l',
			'ȴ' : 'l',
			'ḷ' : 'l',
			'ḹ' : 'l',
			'ⱡ' : 'l',
			'ꝉ' : 'l',
			'ḻ' : 'l',
			'ŀ' : 'l',
			'ɫ' : 'l',
			'ᶅ' : 'l',
			'ɭ' : 'l',
			'ł' : 'l',
			'lj' : 'lj',
			'ſ' : 's',
			'ẜ' : 's',
			'ẛ' : 's',
			'ẝ' : 's',
			'ḿ' : 'm',
			'ṁ' : 'm',
			'ṃ' : 'm',
			'ɱ' : 'm',
			'ᵯ' : 'm',
			'ᶆ' : 'm',
			'ń' : 'n',
			'ň' : 'n',
			'ņ' : 'n',
			'ṋ' : 'n',
			'ȵ' : 'n',
			'ṅ' : 'n',
			'ṇ' : 'n',
			'ǹ' : 'n',
			'ɲ' : 'n',
			'ṉ' : 'n',
			'ƞ' : 'n',
			'ᵰ' : 'n',
			'ᶇ' : 'n',
			'ɳ' : 'n',
			'ñ' : 'n',
			'nj' : 'nj',
			'ó' : 'o',
			'ŏ' : 'o',
			'ǒ' : 'o',
			'ô' : 'o',
			'ố' : 'o',
			'ộ' : 'o',
			'ồ' : 'o',
			'ổ' : 'o',
			'ỗ' : 'o',
			'ö' : 'o',
			'ȫ' : 'o',
			'ȯ' : 'o',
			'ȱ' : 'o',
			'ọ' : 'o',
			'ő' : 'o',
			'ȍ' : 'o',
			'ò' : 'o',
			'ỏ' : 'o',
			'ơ' : 'o',
			'ớ' : 'o',
			'ợ' : 'o',
			'ờ' : 'o',
			'ở' : 'o',
			'ỡ' : 'o',
			'ȏ' : 'o',
			'ꝋ' : 'o',
			'ꝍ' : 'o',
			'ⱺ' : 'o',
			'ō' : 'o',
			'ṓ' : 'o',
			'ṑ' : 'o',
			'ǫ' : 'o',
			'ǭ' : 'o',
			'ø' : 'o',
			'ǿ' : 'o',
			'õ' : 'o',
			'ṍ' : 'o',
			'ṏ' : 'o',
			'ȭ' : 'o',
			'ƣ' : 'oi',
			'ꝏ' : 'oo',
			'ɛ' : 'e',
			'ᶓ' : 'e',
			'ɔ' : 'o',
			'ᶗ' : 'o',
			'ȣ' : 'ou',
			'ṕ' : 'p',
			'ṗ' : 'p',
			'ꝓ' : 'p',
			'ƥ' : 'p',
			'ᵱ' : 'p',
			'ᶈ' : 'p',
			'ꝕ' : 'p',
			'ᵽ' : 'p',
			'ꝑ' : 'p',
			'ꝙ' : 'q',
			'ʠ' : 'q',
			'ɋ' : 'q',
			'ꝗ' : 'q',
			'ŕ' : 'r',
			'ř' : 'r',
			'ŗ' : 'r',
			'ṙ' : 'r',
			'ṛ' : 'r',
			'ṝ' : 'r',
			'ȑ' : 'r',
			'ɾ' : 'r',
			'ᵳ' : 'r',
			'ȓ' : 'r',
			'ṟ' : 'r',
			'ɼ' : 'r',
			'ᵲ' : 'r',
			'ᶉ' : 'r',
			'ɍ' : 'r',
			'ɽ' : 'r',
			'ↄ' : 'c',
			'ꜿ' : 'c',
			'ɘ' : 'e',
			'ɿ' : 'r',
			'ś' : 's',
			'ṥ' : 's',
			'š' : 's',
			'ṧ' : 's',
			'ş' : 's',
			'ŝ' : 's',
			'ș' : 's',
			'ṡ' : 's',
			'ṣ' : 's',
			'ṩ' : 's',
			'ʂ' : 's',
			'ᵴ' : 's',
			'ᶊ' : 's',
			'ȿ' : 's',
			'ɡ' : 'g',
			'ᴑ' : 'o',
			'ᴓ' : 'o',
			'ᴝ' : 'u',
			'ť' : 't',
			'ţ' : 't',
			'ṱ' : 't',
			'ț' : 't',
			'ȶ' : 't',
			'ẗ' : 't',
			'ⱦ' : 't',
			'ṫ' : 't',
			'ṭ' : 't',
			'ƭ' : 't',
			'ṯ' : 't',
			'ᵵ' : 't',
			'ƫ' : 't',
			'ʈ' : 't',
			'ŧ' : 't',
			'ᵺ' : 'th',
			'ɐ' : 'a',
			'ᴂ' : 'ae',
			'ǝ' : 'e',
			'ᵷ' : 'g',
			'ɥ' : 'h',
			'ʮ' : 'h',
			'ʯ' : 'h',
			'ᴉ' : 'i',
			'ʞ' : 'k',
			'ꞁ' : 'l',
			'ɯ' : 'm',
			'ɰ' : 'm',
			'ᴔ' : 'oe',
			'ɹ' : 'r',
			'ɻ' : 'r',
			'ɺ' : 'r',
			'ⱹ' : 'r',
			'ʇ' : 't',
			'ʌ' : 'v',
			'ʍ' : 'w',
			'ʎ' : 'y',
			'ꜩ' : 'tz',
			'ú' : 'u',
			'ŭ' : 'u',
			'ǔ' : 'u',
			'û' : 'u',
			'ṷ' : 'u',
			'ü' : 'u',
			'ǘ' : 'u',
			'ǚ' : 'u',
			'ǜ' : 'u',
			'ǖ' : 'u',
			'ṳ' : 'u',
			'ụ' : 'u',
			'ű' : 'u',
			'ȕ' : 'u',
			'ù' : 'u',
			'ủ' : 'u',
			'ư' : 'u',
			'ứ' : 'u',
			'ự' : 'u',
			'ừ' : 'u',
			'ử' : 'u',
			'ữ' : 'u',
			'ȗ' : 'u',
			'ū' : 'u',
			'ṻ' : 'u',
			'ų' : 'u',
			'ᶙ' : 'u',
			'ů' : 'u',
			'ũ' : 'u',
			'ṹ' : 'u',
			'ṵ' : 'u',
			'ᵫ' : 'ue',
			'ꝸ' : 'um',
			'ⱴ' : 'v',
			'ꝟ' : 'v',
			'ṿ' : 'v',
			'ʋ' : 'v',
			'ᶌ' : 'v',
			'ⱱ' : 'v',
			'ṽ' : 'v',
			'ꝡ' : 'vy',
			'ẃ' : 'w',
			'ŵ' : 'w',
			'ẅ' : 'w',
			'ẇ' : 'w',
			'ẉ' : 'w',
			'ẁ' : 'w',
			'ⱳ' : 'w',
			'ẘ' : 'w',
			'ẍ' : 'x',
			'ẋ' : 'x',
			'ᶍ' : 'x',
			'ý' : 'y',
			'ŷ' : 'y',
			'ÿ' : 'y',
			'ẏ' : 'y',
			'ỵ' : 'y',
			'ỳ' : 'y',
			'ƴ' : 'y',
			'ỷ' : 'y',
			'ỿ' : 'y',
			'ȳ' : 'y',
			'ẙ' : 'y',
			'ɏ' : 'y',
			'ỹ' : 'y',
			'ź' : 'z',
			'ž' : 'z',
			'ẑ' : 'z',
			'ʑ' : 'z',
			'ⱬ' : 'z',
			'ż' : 'z',
			'ẓ' : 'z',
			'ȥ' : 'z',
			'ẕ' : 'z',
			'ᵶ' : 'z',
			'ᶎ' : 'z',
			'ʐ' : 'z',
			'ƶ' : 'z',
			'ɀ' : 'z',
			'ff' : 'ff',
			'ffi' : 'ffi',
			'ffl' : 'ffl',
			'fi' : 'fi',
			'fl' : 'fl',
			'ij' : 'ij',
			'œ' : 'oe',
			'st' : 'st',
			'ₐ' : 'a',
			'ₑ' : 'e',
			'ᵢ' : 'i',
			'ⱼ' : 'j',
			'ₒ' : 'o',
			'ᵣ' : 'r',
			'ᵤ' : 'u',
			'ᵥ' : 'v',
			'ₓ' : 'x',
			'Ё' : 'YO',
			'Й' : 'I',
			'Ц' : 'TS',
			'У' : 'U',
			'К' : 'K',
			'Е' : 'E',
			'Н' : 'N',
			'Г' : 'G',
			'Ш' : 'SH',
			'Щ' : 'SCH',
			'З' : 'Z',
			'Х' : 'H',
			'Ъ' : "'",
			'ё' : 'yo',
			'й' : 'i',
			'ц' : 'ts',
			'у' : 'u',
			'к' : 'k',
			'е' : 'e',
			'н' : 'n',
			'г' : 'g',
			'ш' : 'sh',
			'щ' : 'sch',
			'з' : 'z',
			'х' : 'h',
			'ъ' : "'",
			'Ф' : 'F',
			'Ы' : 'I',
			'В' : 'V',
			'А' : 'a',
			'П' : 'P',
			'Р' : 'R',
			'О' : 'O',
			'Л' : 'L',
			'Д' : 'D',
			'Ж' : 'ZH',
			'Э' : 'E',
			'ф' : 'f',
			'ы' : 'i',
			'в' : 'v',
			'а' : 'a',
			'п' : 'p',
			'р' : 'r',
			'о' : 'o',
			'л' : 'l',
			'д' : 'd',
			'ж' : 'zh',
			'э' : 'e',
			'Я' : 'Ya',
			'Ч' : 'CH',
			'С' : 'S',
			'М' : 'M',
			'И' : 'I',
			'Т' : 'T',
			'Ь' : "'",
			'Б' : 'B',
			'Ю' : 'YU',
			'я' : 'ya',
			'ч' : 'ch',
			'с' : 's',
			'м' : 'm',
			'и' : 'i',
			'т' : 't',
			'ь' : "'",
			'б' : 'b',
			'ю' : 'yu'
		};

		return this.replace(/[^A-Za-z0-9]/g, function(x) {
			return characters[x] || x;
		});
	}
}


var Ace = function() {
    if (typeof ace === 'undefined') {
        return;
    }

    this.scriptPath      = app.get('webhost') + 'theme/nativendo/asset/js/vendor/ace/'
    this.theme           = 'eclipse';
    this.editors         = {};
    this.defaultSettings = {
        'minLines'                 : 15,
        'maxLines'                 : 15,
        'showPrintMargin'          : false,
        'autoScrollEditorIntoView' : true,
        'useWorker'                : true,
        'cursorStyle'              : 'slim',
        'foldStyle'                : 'markbeginend'
    };

    ace.config.set('basePath', this.scriptPath);
    ace.config.set('modePath', this.scriptPath);
    ace.config.set('themePath', this.scriptPath);

    // add to textarea fields
    if (document.getElements('textarea.ace')) {
        var self    = this,
            editors = document.getElements('textarea.ace');

        editors.each(function(textarea) {
            var id,
                type           = textarea.get('data-ace-type') || 'html',
                editorSettings = textarea.get('data-ace-settings')
                    ? JSON.decode(textarea.get('data-ace-settings'))
                    : {};

            if (!textarea.id) {
                id          = String.uniqueID();
                textarea.id = id;
            } else {
                id = textarea.id;
            }

            self.createEditor(id, type, editorSettings);
        });
    }
};

Ace.prototype = {
    getEditor: function(id) {
        return (typeof this.editors[id] !== 'undefined') ? this.editors[id] : null;
    },

    setEditor: function(id, editor) {
        this.editors[id] = editor;
    },

    unsetEditor: function(id) {
        if (typeof this.editors[id] !== 'undefined') {
            delete this.editors[id];
        }
    },

    createEditor: function(id, type, options) {
        var element = document.id(id);

        if (!element) {
            return;
        }

        if (typeof type !== 'string') {
            type = 'html';
        }

        if (typeof options !== 'object') {
            options = {};
        }

        var options = Object.merge({}, this.defaultSettings, options);

        if (element.tagName == 'TEXTAREA') {
            var clone = element.clone(true, true)
                               .cloneEvents(element)
                               .store('length-check-counter', element.retrieve('length-check-counter'))
                               .addClass('hide')
                               .inject(element, 'after');
        }

        var editor  = ace.edit(element),
            session = editor.getSession();

        Object.each(options, function(val, key) {
            if (typeof editor[key] === 'function') {
                editor[key](val);
                return;
            }

            editor.setOption(key, val);
        });

        editor.setTheme('ace/theme/' + this.theme);
        session.setMode('ace/mode/' + type);

        if (element.tagName == 'TEXTAREA') {
            editor.on('change', function(e) {
                clone.set('value', editor.getValue()).fireEvent('change');
            });
        }

        var elementHeight = element.getStyle('height');

        if (elementHeight) {
            editor.container.setStyle('height', elementHeight);
        }

        session.on('changeAnnotation', function(e, s) {
            var annotations     = s.getAnnotations() || [],
                annotationCount = annotations.length;

            for (var i = annotationCount - 1; i >= 0; i--) {
                var annotation = annotations[i];

                if (type == 'html') {
                    if (annotation.type == 'info' && annotation.text.match(/doctype/gi)) {
                        annotations.splice(i, 1);
                    }
                }
            };

            if (annotationCount > annotations.length) {
                s.setAnnotations(annotations);
            }
        });

        this.setEditor(id, editor);

        return editor;
    }
};


var AdUnitEditor = function() {
    this.ace            = app.get('ace');
    this.ellipsis       = new Ellipsis();
    this.visibility     = new Visibility();
    this.history        = new History();
    this.editor         = window.sessionData['adUnitEditor'];
    this.historyEnabled = this.editor['options']['history'],

    this.alert                = document.id('mt-ad-unit-editor-alert');
    this.contentBlockers      = $$('.mt-content-blocker');
    this.deviceSelect         = document.id('mt-device');
    this.form                 = document.id('mt-ad-unit-editor-form');
    this.iframe               = document.id('website-preview');
    this.modeSelect           = document.id('mt-mode');
    this.placeholderAttachBtn = document.id('mt-placeholder-attach');
    this.placeholderContainer = document.id('mt-placement-placeholder-found');
    this.placeholderInfo      = document.id('mt-placement-placeholder-info');
    this.placeholderSearchBtn = document.id('mt-placeholder-search');
    this.placeholderSelect    = document.id('mt-placeholders');
    this.positionSelect       = document.id('mt-placement-position');
    this.previewButton        = document.id('mt-show-preview');
    this.readmoreInput        = document.id('mt-change-label');
    this.saveButton           = document.getElements('.mt-save-placement');
    this.selectionMode        = document.id('mt-selection-mode');
    this.submitButton         = document.id('mt-submit');
    this.teaserSelect         = document.id('mt-teaser');
    this.templateSelect       = document.id('mt-teaser-template-sel');
    this.templateButton       = document.id('mt-load-teaser-template');
    this.urlInput             = document.id('mt-url');
    this.widthSelect          = document.id('mt-width');
    this.xpathInspector       = document.id('xpath-inspector');
    this.xpathInspectorLogger = document.id('xpath-inspector-logger');

    this.fullscreenBtn               = document.getElements('.mt-editor-fullscreen');
    this.fullscreenExitBtn           = document.getElements('.mt-editor-fullscreen-exit');
    this.tabControlsContainer        = document.id('mt-ad-unit-editor-tab-controls'),
    this.controlsContainer           = document.id('mt-ad-unit-editor-controls'),
    this.templateControlsContainer   = document.id('mt-teaser-template-controls'),
    this.templateControlsContainerFs = document.id('mt-teaser-template-controls-fs'),
    this.templateControls            = document.id('mt-teaser-template'),
    this.styleControlsFs             = document.id('mt-mode-styling-fullscreen-controls');

    this.css            = '';
    this.iFrameDoc      = null;
    this.editors        = {};
    this.editorTimeout  = 500;
    this.editorTimeouts = {};
    this.element        = null;
    this.inspectorOn    = true;
    this.nodes          = [];
    this.position       = null;
    this.teaserLength   = 'normal';
    this.vars           = {},

    this.writeAccess         = this.form.get('data-write-access');
	this.defaultCssUrl       = app.get('endpoints').c + '/cdn/asset/css/nativendo.css?v=' + this.form.get('data-cache-version');
	this.defaultCssAvailable = false;

    this.inspectorStyles = {
        outline: '4px dashed #EDBC53'
    };

    this.selectedStyles = {
        outline: '4px dashed #A6ED8A'
    };

    this.visibility.frame = null;
    this.visibility.getCorrectElements = function(el) {
        var win = window, doc = document, isFrame = false;

        try {
            if (this.frame) {
                isFrame = !!this.frame.contentWindow.frameElement;

                if (this.frame.contentDocument || this.frame.contentWindow.document) {
                    win = this.frame.contentWindow
                    doc = this.frame.contentDocument || this.frame.contentWindow.document;
                }
            }
        } catch(e) {}

        return {win: win, doc: doc, el: el, isFrame: isFrame};
    };

    this.init();
};

AdUnitEditor.prototype = {
    from: function(text, excludeScripts){
        if (excludeScripts || excludeScripts == null) text = text.stripScripts();

        var container,
            match = text.match(/^\s*(?:<!--.*?-->\s*)*<(t[dhr]|tbody|tfoot|thead)/i);

        if (match){
            container = new Element('table');

            var tag = match[1].toLowerCase();

            if (['td', 'th', 'tr'].contains(tag)){
                container = new Element('tbody').inject(container);

                if (tag != 'tr') container = new Element('tr').inject(container);
            }
        }

        return (container || new Element('div')).set('html', text).getChildren();
    },

    getElementByXPath: function(xpath, doc) {
        var nodes = [],
            res   = false;

        xpath = xpath.replace(/\[@id\s*=\s*'([^\*]+)\*([^\*]*)'\]/, "[starts-with(@id, '$1') and substring(@id, string-length(@id) - string-length('$2') + 1) = '$2']");

        try {
            res = doc.evaluate(xpath, doc, null, XPathResult.ANY_TYPE, null);
        } catch (e) {}

        if (!res) {
            return nodes;
        }

        while (node = res.iterateNext()) {
            nodes.push(node);
        }

        return nodes;
    },

    getFrameContents: function(a, d) {
        var c;

        if (a.contentDocument) {
            if (d) {
                return a.contentDocument;
            }

            c = a.contentDocument.getElementsByTagName("body")[0];
        } else {
            if (a.contentWindow) {
                if (d) {
                    return a.contentWindow.document;
                }

                c = a.contentWindow.document.getElementsByTagName("body")[0];
            }
        }

        return c;
    },

    getIframeUrl: function(url, device) {
        var self = this;

        return self.editor['proxyUrl'] + '?device=' + device.trim() + '&url=' + encodeURIComponent(url.trim() + '#nativeads_demo');
    },

    getXPath: function(a, d) {
        if (a.id && !d) {
            return "//*[@id='" + a.id + "']";
        }

        var x = function(a, d) {
            d = d || [];
            a.parentNode && (d = x(a.parentNode, d));

            if (a.previousSibling) {
                var c = 1, b = a.previousSibling;

                do {
                    1 == b.nodeType && b.nodeName == a.nodeName && c++, b = b.previousSibling;
                } while (b);

                1 == c && (c = 1);
            } else {
                if (a.nextSibling) {
                    b = a.nextSibling;

                    do {
                        1 == b.nodeType && b.nodeName == a.nodeName ? (c = 1, b = null) : (c = null, b = b.previousSibling);
                    } while (b);
                }
            }

            1 == a.nodeType && d.push(a.nodeName.toLowerCase() + (0 < c ? "[" + c + "]" : ""));

            return d;
        }

        return x(a, d).join('/');
    },

    init: function() {
        var self = this;

        Array.each(self.editor.fields, function(field) {
            var placeholder = field['demo_data'];

            if (placeholder instanceof Object) {
                Object.each(placeholder, function(value, key) {
                    placeholder[key] = value.replace(/\n/g, ' ');
                });
            } else {
                placeholder = placeholder.replace(/\n/g, ' ');
            }

            self.vars[field['placeholder']] = placeholder;
        });

        Sass.options({
            style             : Sass.style.compressed,
            sourceMapContents : 0,
            sourceMapEmbed    : 0
        });

        self.initIframe();
        self.initObserver();
        self.initMode();
        self.initPositioning();
        self.initSave();
        self.initStyling();
        self.initTeaser();
        self.initTemplates();
    },

    initIframe: function() {
        var self = this;

        /**
         * Liste mit nicht nutzbaren Tags, da diese kein innerHTML haben und somit die Insertion für inner/top und inner/bottom fehlschlagen würde.
         */
        var notUsableTagList = 'area base br col command embed hr img input keygen link meta param source track wbr'.split(' '),
            notUsableTags    = {};

        for (i = 0, l = notUsableTagList.length; i < l; i++) {
            notUsableTags[notUsableTagList[i]] = true;
        }

        var previewIframe = new IFrame({
            id: 'website-preview',
            src : '',
            'class': 'preview-iframe loading-iframe',

            styles : {
                width:  self.setIframeDimension()[0],
                height: self.setIframeDimension()[1],
            },

            events: {
                load: function(e) {
                    self.iframe.removeClass('loading-iframe');

                    /**
                     * Prüfen ob Nativendo eingebunden ist
                     */
                    win = self.iframe.contentWindow || self.iframe;

                    if (!win.resizeEvent) {
                        win.addEventListener('resize', function() {
                            try {
                                if (this.outerHTML !== this.retrieve('outerHTML')) {
                                    Object.each(this.retrieve('attributes'), function(val, key) {
                                        if (key === 'src') {
                                            return;
                                        }

                                        document.id(this).set(key, val);
                                    }.bind(this));

                                    var attrs = this.attributes;

                                    for (var i = 0; i < attrs.length; i++) {
                                        if (!this.retrieve('attributes')[attrs[i].nodeName]) {
                                            this.removeAttribute(attrs[i].nodeName);
                                        }
                                    }
                                }
                            } catch (err) {}
                        }.bind(self.iframe));
                    }

                    win.resizeEvent = true;

                    /**
                     * Body und document Elemente des IFrames
                     */
                    var body = self.getFrameContents(self.iframe, false);
                    var doc  = self.iFrameDoc = self.getFrameContents(self.iframe, true);


                    if (doc) {
                    	/**
                    	 * Die Verfuegbarkeit des Default CSS wieder auf falsch stellen!
                    	 */
                    	self.defaultCssAvailable = false;
                    }

                    /**
                     * Prüfen ob XPath vorhanden ist und falls ja, dynamisch die Ad einfügen
                     */
                    var currentXPath = self.xpathInspector.get('value').trim();

                    if (currentXPath) {
                        var nodes = self.getElementByXPath(currentXPath, doc);

                        if (nodes.length > 0) {
                            self.selectPlaceholder(nodes[0], false);
                            self.insertPlacement({}, nodes[0], self.editor['options']['position'], self.vars, true);

                            var pos = nodes[0].getBoundingClientRect();

                            self.iframe.contentWindow.scrollTo(pos.left, pos.top + self.iframe.contentWindow.pageYOffset - 150);
                        }
                    }

                    /**
                     * Hit xpath search/replace on keyup in the inspector input
                     */
                    self.xpathInspector.addEvent('keyup', function() {
                        var currentXPath = self.xpathInspector.get('value').trim();

                        if (currentXPath) {
                            var nodes = self.getElementByXPath(currentXPath, doc);

                            if (nodes.length > 0) {
                                if (self.element !== nodes[0]) {
                                    self.selectPlaceholder(nodes[0], false);
                                    self.insertPlacement({}, nodes[0], self.editor['options']['position'], self.vars, true);

                                    var pos = nodes[0].getBoundingClientRect();

                                    self.iframe.contentWindow.scrollTo(pos.left, pos.top + self.iframe.contentWindow.pageYOffset - 150);

                                    if (self.positionSelect) {
                                        self.positionSelect.set('value', '');
                                    }
                                }
                            } else {
                                if (self.element) {
                                    self.selectPlaceholder(self.element, false);
                                }
                            }
                        }
                    });

                    /**
                     * Onclick-Events des Frames entfernen, die auf dem body liegen.
                     */
                    if (body) {
                    	body.onclick = null;
                    }

                    /**
                     * Es wird nach vorhandenen Platzhaltern gesucht. Diese kann der Benutzer direkt auswählen.
                     */
                    var selectablePlaceholders = [];
                    var searchKeys = ['nativendo', 'Nativendo'];

                    for (var i = 0; i < searchKeys.length; i++) {
                    	if (!doc) {
                    		continue;
                    	}

                        var possibleSelections = doc.evaluate("//*[contains(@class, '" + searchKeys[i] + "-') or contains(@id, '" + searchKeys[i] + "-')]", doc, null, XPathResult.ANY_TYPE, null),
                             possibleSelection = null,
                                         match = [];

                        while (possibleSelection = possibleSelections.iterateNext()) {
                            match = [];

                            if (possibleSelection.id) {
                                match        = (/nativendo\-([^\s"']+)/i).exec(possibleSelection.id);
                                excludeMatch = (/nativendo\-widget(\-frame)?\-[0-9a-fA-F]{8}(\-[0-9a-fA-F]{4}){3}\-[0-9a-fA-F]{12}/i).exec(possibleSelection.id);

                                if (match && match.length && (!excludeMatch || !excludeMatch.length)) {
                                    selectablePlaceholders.push({type: 'id', id: '#' + match[0], element: possibleSelection});
                                }
                            }

                            if ((!match || !match.length) && possibleSelection.className) {
                                match        = (/nativendo\-([^\s"']+)/i).exec(possibleSelection.className);
                                excludeMatch = (/nativendo\-(truncate\-(container|text)|oba\-icon)/i).exec(possibleSelection.className);

                                if (match && match.length && (!excludeMatch || !excludeMatch.length)) {
                                    selectablePlaceholders.push({type: 'className', className: '.' + match[0], element: possibleSelection});
                                }
                            }
                        }
                    }

                    /**
                     * Mögliche Platzhalter wurden gefunden und werden jetzt in einer Auswahlliste angezeigt.
                     */
                    if (self.placeholderContainer && self.placeholderSelect && self.placeholderInfo) {
                        if (selectablePlaceholders.length) {
                            $$('.mt-select-option').destroy();

                            var lastPlaceholder = null;
                            for (k = 0, l = selectablePlaceholders.length; k < l; k++) {
                                new Element('option', {value: k, html: selectablePlaceholders[k][selectablePlaceholders[k].type], 'class': 'mt-select-option'})
                                    .store('placeholder', selectablePlaceholders[k].element)
                                    .inject(self.placeholderSelect);


                               lastPlaceholder = selectablePlaceholders[k].element;
                            }

                            if (l > 1 || (self.getXPath(lastPlaceholder) !== self.xpathInspector.get('value'))) {
                                self.placeholderContainer.removeClass('hide');
                                self.placeholderInfo.addClass('hide');
                            } else {
                                self.selectPlaceholder(lastPlaceholder, true, true);
                            }

                            self.placeholderSelect.addEvent('change', function(e) {
                                try {
                                    var placeholder = this.getSelected()[0].retrieve('placeholder');
                                } catch (e) {
                                    var placeholder = this.getSelected().retrieve('placeholder')[0];
                                }

                                if (!placeholder) {
                                    self.placeholderAttachBtn.removeClass('btn-info');
                                } else {
                                    self.placeholderAttachBtn.addClass('btn-info');
                                }
                            });

                            self.placeholderAttachBtn.addEvent('click', function(e) {
                                e && e.stop();

                                try {
                                    var placeholder = self.placeholderSelect.getSelected()[0].retrieve('placeholder');
                                } catch (e) {
                                    var placeholder = self.placeholderSelect.getSelected().retrieve('placeholder')[0];
                                }

                                if (!placeholder) {
                                    return false;
                                }

                                self.selectPlaceholder(placeholder, true, true);

                                if (self.positionSelect) {
                                    self.positionSelect.set('value', '');
                                }

                                self.scrollToPlaceholder();

                                return false;
                            });
                        } else {
                            self.placeholderContainer.addClass('hide');
                            self.placeholderInfo.removeClass('hide');
                        }
                    }

                    /**
                     * Korrekte Höhe des Iframes setzen, damit das Fenster ausgefüllt wird.
                     */
                    self.setIframeDimension();

                    /**
                     * Alle body-Elemente des Iframes durchlaufen und Events zuweisen
                     */
                    var childNodesLen = body ? body.childNodes.length : 0;

                    for (var i = 0; i < childNodesLen; i++) {
                        if (typeof body.childNodes[i].tagName == 'undefined') {
                            continue;
                        }

                        /**
                         * Klick-Events:
                         *
                         * - Verhindert das auf der Seite navigiert wird
                         * - Platzieren der Anzeige
                         */
                        body.childNodes[i].onclick = function(e) {
                            e.cancelBubble = !0, e.preventDefault();

                            var el             = e.target,
                                clickableLinks = !self.inspectorOn;

                            if (clickableLinks) {
                                var i = 0;
                                var t = el;

                                while ((el.tagName !== 'A' || !el.href)) {
                                    i++;

                                    el = el.parentNode;
                                    if (!el || i === 3) {
                                        break;
                                    }
                                }

                                if (el.tagName == 'A' && el.href) {
                                    websiteHost = self.urlInput.get('value')
                                        .replace(/^(https?:)?\/\/(www\.)?/, '')
                                        .replace(/(\/.*)?$/, '');

                                    var inHrefRegExp    = new RegExp('^(https?:)?\\/\\/(www\\.)?' + RegExp.escape(websiteHost) + '/'),
                                        inWebhostRegExp = new RegExp('^' + RegExp.escape(app.get('webhost')) + '.+(\\?|&)url=([^\\&]*?(www\\.)?' + RegExp.escape(encodeURIComponent(websiteHost)) + '[^&]*)');

                                    if (inHrefRegExp.test(el.href) || inWebhostRegExp.test(el.href)) {
                                        var url = (inWebhostRegExp.test(el.href)) ? decodeURIComponent(el.href.replace(inWebhostRegExp, '$2')) : el.href;

                                        self.setIframeSource(self.getIframeUrl(url, self.deviceSelect.get('value')));
                                        self.urlInput.set('value', url);
                                        self.element = null;
                                        self.nodes = [];
                                        self.contentBlockers.removeClass('hide');
                                    } else {
                                        alert(app.get('i18n').translate('ad.unit.external.link.warning'));
                                    }

                                    return false;
                                }

                                return false;
                            }

                            if (!self.inspectorOn) {
                                return false;
                            }

                            if (notUsableTags.hasOwnProperty(el.tagName.toLowerCase())) {
                                return;
                            }

                            self.selectPlaceholder(el, true);

                            if (self.positionSelect) {
                                self.positionSelect.set('value', '');
                            }

                            return false;
                        };

                        /**
                         * Over-Events:
                         *
                         * - Anzeige wo die Platzierung hinkommt
                         */
                        body.childNodes[i].onmouseover = function(e) {
                            if (!self.inspectorOn) {
                                return;
                            }

                            var el = e.target;

                            if (el == self.element) {
                                return;
                            }

                            if (notUsableTags.hasOwnProperty(el.tagName.toLowerCase())) {
                                return;
                            }

                            for (key in self.inspectorStyles) {
                                if (!self.inspectorStyles.hasOwnProperty(key)) {
                                    continue;
                                }

                                try {
                                    el.setAttribute('data-nat-style-' + key, el.style[key]);
                                    el.style[key] = self.inspectorStyles[key];
                                } catch (ex) {}
                            }

                            try {
                                self.xpathInspectorLogger.set('value', self.getXPath(el));
                            } catch (ex) {}
                        };

                        /**
                         * Out-Events:
                         *
                         * - Entfernen der Platzierungspositionsanzeige
                         */
                        body.childNodes[i].onmouseout = function(e) {
                            var el = e.target;

                            if (el == self.element) {
                                return;
                            }

                            for (key in self.inspectorStyles) {
                                if (!self.inspectorStyles.hasOwnProperty(key)) {
                                    continue;
                                }

                                try {
                                    el.style[key] = el.getAttribute('data-nat-style-' + key);
                                } catch (ex) {}
                            }

                            try {
                                self.xpathInspectorLogger.set('value', '');
                            } catch (ex) {}
                        };
                    }

                    var els = (self.iframe.contentDocument && self.iframe.contentDocument.getElementsByTagName("body")) ? self.iframe.contentDocument.getElementsByTagName("body")[0].getElementsByTagName("*") : [];

                    for (k in els) {
                      if (null != els[k] && "function" == typeof els[k].getAttribute && "function" == typeof els[k].setAttribute && null != els[k].getAttribute("onclick") && "" != els[k].getAttribute("onclick")) {
                        var ce = els[k].getAttribute("onclick");

                        els[k].setAttribute("onclick", "");

                        els[k].onclick = function() {
                            if ("function" == typeof els[k].getAttribute && "function" == typeof els[k].setAttribute) {
                                self.inspectorOn || (null != els[k].getAttribute("onclick") ? els[k].setAttribute("onclick", "") : (els[k].setAttribute("onclick", ce), els[k].click()));
                            }
                        };
                      }
                    }

					if (self.iframe.contentDocument) {
	                    self.iframe.contentDocument.onclick = function(a) {
	                        self.inspectorOn && (a.cancelBubble = !0, a.preventDefault());
	                    };
                   }
                }
            }
        });

        previewIframe.replaces(self.iframe);
        self.iframe = previewIframe;
        this.visibility.frame = self.iframe;

        setTimeout(function() {
            self.iframe.src = self.getIframeUrl(self.urlInput.get('value'), self.deviceSelect.get('value'));
        }, 1);

        setInterval(function() {
            self.setIframeDimension();
        }, 100);
    },

    initMode: function() {
        var self = this;

        if (!self.modeSelect) {
            return;
        }

        self.modeSelect.addEvent('change', function(e) {
            var mode = this.get('value');

            if (!mode) {
                return;
            }

            $$('.mt-editor-show-mode').each(function(wrapper) {
                wrapper.addClass('hide');

                var wrapperMode = wrapper.get('data-mode');

                if (wrapperMode && wrapperMode == mode) {
                    wrapper.removeClass('hide');
                    if (self.historyEnabled) self.history.setParam('mode', wrapperMode);
                }

                self.setIframeDimension();
            });

            if (mode == 'styling') {
                self.templateControlsContainerFs.removeClass('hide');
            } else {
                self.templateControlsContainerFs.addClass('hide');
            }
        }).fireEvent('change');
    },

    initObserver: function() {
        var self = this;

        try {
            // create an observer instance
            var observer = new MutationObserver(function(mutations) {
                try {
                    mutations.forEach(function(mutation) {
                        if (mutation.type == 'childList') {
                            var len = mutation.addedNodes.length;

                            if (len > 0) {
                                for (var i = 0; i < len; i++) {
                                    if (document.id(mutation.addedNodes[i]) && document.id(mutation.addedNodes[i]).hasClass('colpick')) {
                                        continue;
                                    }

                                    if (document.id(mutation.addedNodes[i]) && document.id(mutation.addedNodes[i]).hasClass('tooltip')) {
                                        continue;
                                    }

                                    if (document.id(mutation.addedNodes[i]) && document.id(mutation.addedNodes[i]).hasClass('nati-select-list')) {
                                        continue;
                                    }

                                    if (document.id(mutation.addedNodes[i]) && document.id(mutation.addedNodes[i]).tagName == 'STYLE' && document.id(mutation.addedNodes[i]).getAttribute('id') == 'ace-eclipse') {
                                        continue;
                                    }

                                    if (document.id(mutation.addedNodes[i]) && document.id(mutation.addedNodes[i]).tagName == 'SCRIPT') {
                                        if (document.id(mutation.addedNodes[i]).src) {
                                            var scriptHost = document.id(mutation.addedNodes[i]).src
                                                .replace(/^(https?:)?\/\//, '')
                                                .replace(/(\/.*)?$/, '')
                                                .replace(/\//g, '\\/')
                                                .replace(/\./g, '\\.')
                                                .replace(/\-/g, '\\-');

                                            var hostRegExp = new RegExp('^(https?:)?\/\/' + scriptHost + '/');

                                            if (hostRegExp.test(app.get('webhost'))) {
                                                continue;
                                            }
                                        }
                                    }

                                    if (document.id(mutation.previousSibling)) {
                                        if (document.id(mutation.previousSibling).src) {
                                            var scriptHost = document.id(mutation.previousSibling).src
                                                .replace(/^(https?:)?\/\//, '')
                                                .replace(/(\/.*)?$/, '')
                                                .replace(/\//g, '\\/')
                                                .replace(/\./g, '\\.')
                                                .replace(/\-/g, '\\-');

                                            var hostRegExp = new RegExp('^(https?:)?\/\/' + scriptHost + '/');

                                            if (hostRegExp.test(app.get('webhost'))) {
                                                continue;
                                            }
                                        }
                                    }

                                    document.id(mutation.addedNodes[i]).remove();
                                    // console.log('DOM node addition tracked: ', mutation.addedNodes[i]);
                                }
                            }
                        } else if (mutation.type == 'attributes') {
                            if ((mutation.target.get(mutation.attributeName) && !mutation.oldValue) || (mutation.target.get(mutation.attributeName) && mutation.oldValue && mutation.target.get(mutation.attributeName).split(/\s+/).length > mutation.oldValue.split(/\s+/).length)) {
                                mutation.target.set(mutation.attributeName, mutation.oldValue);
                                // console.log('DOM ' + mutation.attributeName + ' addition tracked: ', mutation.target);
                            }
                        }
                    });
                } catch (err) {}
            });

            var observerOptions = {
                attributes        : true,
                attributeOldValue : true,
                childList         : true,
                characterData     : true
            };

            observer.observe(document.head, observerOptions);
            observer.observe(document.body, observerOptions);
            observer.observe(self.iframe.getParent(), observerOptions);
        } catch (err) {}
    },

    initPositioning: function() {
        var self = this;

        if (self.previewButton) {
            self.previewButton.addEvent('click', function(e) {
                e && e.stop();

                self.setIframeSource(self.getIframeUrl(self.urlInput.get('value'), self.deviceSelect.get('value')));

                if (self.placementSelect) {
                    self.placementSelect.set('value', '');
                }

                return;
            });

            if (self.placeholderSearchBtn) {
                self.placeholderSearchBtn.addEvent('click', function(e) {
                    e && e.stop();
                    self.scrollToPlaceholder();
                });
            }

            if (self.urlInput) {
                self.urlInput.addEvent('keypress', function(e) {
                    if (e && e.code == 13) {
                        e.stop();
                        self.previewButton.fireEvent('click');
                    }
                });
            }

            if (self.xpathInspector) {
                self.xpathInspector.addEvent('keypress', function(e) {
                    if (e && e.code == 13) {
                        e.stop();

                        if (self.placeholderSearchBtn) {
                            self.placeholderSearchBtn.fireEvent('click');
                        }
                    }
                });
            }

            if (self.xpathInspectorLogger) {
                self.xpathInspectorLogger.addEvent('keypress', function(e) {
                    if (e && e.code == 13) {
                        e.stop();
                    }
                });
            }
        }

        if (self.selectionMode) {
            self.selectionMode.addEvent('change', function(e) {
                e && e.stop();

                self.inspectorOn = this.checked;

                //if (self.historyEnabled) self.history.setParam('selection', (self.inspectorOn) ? 1 : 0);

                return;
            }).fireEvent('change');
        }

        if (self.positionSelect) {
            self.positionSelect.addEvent('change', function(e) {
                e && e.stop();

                if (this.get('value') === '') {
                    return;
                }

                if (self.element !== null) {
                    self.insertPlacement({}, self.element, this.get('value'), self.vars);
                }

                // if (self.historyEnabled) self.history.setParam('position', this.get('value'));

                return;
            });
        }

        if (self.deviceSelect) {
            self.deviceSelect.addEvent('change', function(e) {
                e && e.stop();

                var device = this.get('value');

                if (!device) {
                    return;
                }

                self.setIframeSource(self.getIframeUrl(self.urlInput.get('value'), device));

                if (self.historyEnabled) self.history.setParam('device', this.get('value'));

                return;
            }).fireEvent('change');
        }

        if (self.widthSelect) {
            self.widthSelect.addEvent('change', function(e) {
                e && e.stop();

                var width = this.get('value');

                if (!width) {
                    return;
                }

                self.setIframeDimension();
                self.scrollToPlaceholder();

                if (self.historyEnabled) self.history.setParam('width', width);

                return;
            }).fireEvent('change');
        }

        if (self.fullscreenBtn && self.fullscreenExitBtn && self.form) {
            self.fullscreenBtn.addEvent('click', function(e) {
                e && e.stop();

                self.form.addClass('fullscreen');
                self.fullscreenBtn.addClass('hide');
                self.fullscreenExitBtn.removeClass('hide');

                document.getElements('.ad-unit-editor-settings').each(function(node) {
                    var id = node.id.replace(/^mt\-/i, '');

                    self.tabControlsContainer.getElement('.mt-tab-control-' + id).grab(node);
                });

                if (self.templateControls) {
                    self.templateControlsContainerFs.grab(self.templateControls);
                }

                self.tabControlsContainer.removeClass('hide').addClass('m3');
                self.controlsContainer.addClass('m9');
                self.templateControlsContainer.addClass('hide');
                self.styleControlsFs.addClass('hide');

                return;
            });

            self.fullscreenExitBtn.addEvent('click', function(e) {
                e && e.stop();

                self.form.removeClass('fullscreen');
                self.fullscreenExitBtn.addClass('hide');
                self.fullscreenBtn.removeClass('hide');

                document.getElements('.ad-unit-editor-settings').each(function(node) {
                    var id = node.id.replace(/^mt\-/i, '');

                    document.getElement('.md-tabs .mt-tab-control-' + id).grab(node);
                });

                if (self.templateControls) {
                    self.templateControlsContainer.grab(self.templateControls);
                }

                self.tabControlsContainer.addClass('hide').removeClass('m3');
                self.controlsContainer.removeClass('m9');
                self.templateControlsContainer.removeClass('hide');
                self.styleControlsFs.removeClass('hide');

                return;
            });

            document.addEvent('keyup', function(e) {
               if (self.form.hasClass('fullscreen')) {
                   if (e && e.code == 27) {
                       e.stop();
                       self.fullscreenExitBtn.fireEvent('click');
                   }
               }

               return;
            });
        }
    },

    initSave: function() {
        var self = this;

        if (!self.saveButton) {
            return;
        }

        self.saveButton.addEvent('click', function(e) {
            e && e.stop();
            self.unsetStatus();

            if (!self.submitButton) {
                return;
            }

            var position   = (self.positionSelect) ? self.positionSelect.get('value') : '',
                templateId = (self.templateSelect) ? self.templateSelect.retrieve('template-id') : '';

            if (self.urlInput) {
                self.urlInput.set('value', self.urlInput.get('value').trim());
            }

            if (self.positionSelect) {
                self.positionSelect.set('value', (position !== '') ? position : self.position).fireEvent('change');
            }

            if (self.templateSelect) {
                self.templateSelect.set('value', (templateId) ? templateId : '').fireEvent('change');
            }

            document.body.fireEvent('click', {
                target : self.submitButton,
                stop   : function() {}
            });
        });
    },

    initStyling: function() {
        var self              = this,
            editorDefinitions = {
                'mt-placement-html' : 'html',
                'mt-placement-css'  : 'css'
            },
            editorOptions = {
                'minLines' : 15,
                'maxLines' : 15
            };

        Object.each(editorDefinitions, function(type, id) {
            var editorTypeOptions = editorOptions;

            if (type == 'css') {
                editorTypeOptions['useWorker'] = false;
            }

            self.editorTimeouts[type] = null;

            var editor = self.ace.createEditor(id, type, editorTypeOptions);

            if (type === 'html') {
                editor.on('change', function() {
                    if (self.editorTimeouts[type]) {
                        clearTimeout(self.editorTimeouts[type]);
                    }

                    self.editorTimeouts[type] = setTimeout(function() {
                        self.insertPlacement({}, self.element, self.position, self.vars);
                    }, self.editorTimeout);
                });
            } else if (type === 'css') {
                editor.on('change', function(e) {
                    if (e.action == 'removeLines') {
                        return;
                    }

                    if (self.editorTimeouts[type]) {
                        clearTimeout(self.editorTimeouts[type]);
                    }

                    var that = this;

                    self.editorTimeouts[type] = setTimeout(function() {
                        Sass.compile(that.getValue(), function(sassResult) {
                            self.css = (sassResult.status == 0) ? sassResult.text : '';

                            self.insertPlacement({}, self.element, self.position, self.vars);
                        });
                    }, self.editorTimeout);
                }.bind(editor));
            }

            // Force change event
            editor.setValue(editor.getValue());
            editor.clearSelection();

            self.editors[type] = editor;
        });
    },

    initTeaser: function() {
        var self = this;

        if (!self.teaserSelect) {
            return;
        }

        self.teaserSelect.addEvent('change', function(e) {
            var teaserLength = this.get('value');

            if (!teaserLength) {
                return;
            }

            self.teaserLength = teaserLength;

            if (self.element !== null) {
                self.insertPlacement({}, self.element, self.position, self.vars);
            }

            if (self.historyEnabled) self.history.setParam('teaser', teaserLength);
        }).fireEvent('change');
    },

    initTemplates: function() {
        var self = this;

        if (self.editor.templateId || self.writeAccess == 0) {
            self.editors['html'].setReadOnly(true);
            self.editors['html'].container.addClass('ace_readonly');

            self.editors['css'].setReadOnly(true);
            self.editors['css'].container.addClass('ace_readonly');
        }

        if (self.templateButton && self.writeAccess == 1) {
            self.templateButton.addEvent('click', function(e) {
                e && e.stop();

                if (!self.templateSelect || self.templateButton.hasClass('blocked') || self.templateButton.hasClass('disabled')) {
                    return;
                }

                self.templateButton.addClass('blocked');
                self.unsetStatus();

                var templateId = self.templateSelect.get('value'),
                    data       = self.templateButton.retrieve('data');

                if (templateId && self.templateSelect.get('tag') !== 'input') {
                    if (self.form) {
                        // app.get('xhrForm').setLoader(self.form);
                        // app.get('xhrForm').setStatus(self.form, app.get('i18n').translate('please.wait'), 'cached', {'icon' : 'cached'});
                    }

                    if (!data) {
                        self.templateButton.store('data', {
                           html : self.editors['html'].getValue(),
                           css  : self.editors['css'].getValue()
                        });
                    }

                    new XmlHttpRequest.JSON({
                        url    : app.get('webhost') + 'ssp/ad-unit-template/load/id/' + templateId,
                        method : 'get',

                        onSuccess: function(rsp) {
                            if (typeof rsp == 'object' && 'status' in rsp && rsp.status == '1') {
                                self.editors['html'].setReadOnly(true);
                                self.editors['html'].container.addClass('ace_readonly');
                                self.editors['html'].setValue(rsp.html);

                                self.editors['css'].setReadOnly(true);
                                self.editors['css'].container.addClass('ace_readonly');
                                self.editors['css'].setValue(rsp.css);

                                self.templateSelect.store('template-id', templateId);

                                self.templateButton.removeClass('blocked');
                                self.unsetStatus();
                            } else {
                                self.setTemplateError();
                            }
                        },
                        onTimeout: function() {
                            self.setTemplateError();
                        },
                        onCancel: function() {
                            self.setTemplateError();
                        },
                        onError: function() {
                            self.setTemplateError();
                        },
                        onFailure: function() {
                            self.setTemplateError();
                        }
                    }).send();
                } else {
                    if (data) {
                        self.editors['html'].setValue(data.html);
                        self.editors['css'].setValue(data.css);

                        self.templateButton.eliminate('data');
                    }

                    self.editors['html'].setReadOnly(false);
                    self.editors['html'].container.removeClass('ace_readonly');

                    self.editors['css'].setReadOnly(false);
                    self.editors['css'].container.removeClass('ace_readonly');

                    self.templateSelect.store('template-id', '');

                    self.templateButton.removeClass('blocked');
                }

                return;
            });

            self.templateButton.fireEvent('click');
        }
    },

    insertPlacement: function(placement, element, position, vars, auto) {
        var self = this;

        if (!element) {
            return;
        }

        var html           = self.editors['html'].getValue(),
            css            = self.css,
            quiet          = quiet || false,
            videoIframeSrc = null;

        self.position = position;

        for (key in vars) {
            if (!vars.hasOwnProperty(key)) {
                continue;
            }

            var keyBase    = key.replace(/^%|%$/g, ''),
                keyMatches = html.match(new RegExp('%' + keyBase + '(?:_.+)?%', 'gi'));

            if (keyMatches) {
                keyMatches.each(function(keyMatch) {
                    var lengthMatches = keyMatch.match(new RegExp('^%' + keyBase + '(?:_(.+))?%$', 'i'))
                        placeholder   = vars[key];

                    if (placeholder instanceof Object) {
                        placeholder = (typeof lengthMatches[1] !== 'undefined' && typeof placeholder[lengthMatches[1]] !== 'undefined') ? placeholder[lengthMatches[1]] : placeholder[self.teaserLength];
                    }

                    if (keyBase == 'video') {
                        videoIframeSrc = placeholder;
                    }

                    html = html.replace(new RegExp(keyMatch, 'ig'), placeholder);
                });
            }
        }

        if (self.nodes.length > 0) {
            for (i = 0, l = self.nodes.length; i < l; i++) {
                if (self.nodes[i].parentNode != null) {
                    self.nodes[i].parentNode.removeChild(self.nodes[i]);
                }
            }
        }

        self.nodes = [].slice.call(self.from(html + '<style>' + css + '</style>'));

        try {
            var clickEvent = function(e) {
                e && e.stop();
                return false;
            };

            self.nodes.forEach(function(node) {
                var links = [].slice.call(node.querySelectorAll('a'));

                if (node.tagName === 'A') {
                    links.push(node);
                }

                links.forEach(function(link) {
                    link.addEvent('click',  clickEvent);
                    link.addEvent('auxclick', clickEvent); // auxclick: clicks other than left in modern browsers
                });
            });
        } catch (e) {}

        try {
            if (['top', 'after'].indexOf(position) > -1) {
                self.nodes = self.nodes.reverse();
            }

            var parentNode = (['before', 'after'].indexOf(position) > -1) ? element.parentNode : element;

            self.nodes.forEach(function(node) {
	            switch (position) {
	            	case 'before':
	            		parentNode.insertBefore(node, element);
	            		break;

	            	case 'after':
	            		parentNode.insertBefore(node, element.nextSibling);
	            		break;

	            	case 'top':
	            		parentNode.insertBefore(node, element.firstChild);
	            		break;

	            	case 'bottom':
	            		parentNode.appendChild(node);
	            		break;

	            	case 'clear_inside':
	            		if (node.tagName !== 'STYLE') {
	            			parentNode.innerHTML = '';
	            		}

	            		parentNode.appendChild(node);
	            		break;
	            }
            });

            if (videoIframeSrc) {
                var videoIframe = parentNode.querySelector('iframe[src="' + videoIframeSrc + '"]');

                if (videoIframe) {
                    var iframeVisibility = function(ms, iframe) {
                        if (iframe.contentWindow) {
                            if (self.visibility.isInViewport(iframe) && self.visibility.isVisibleByStyle(iframe) && self.visibility.percentage(iframe) >= 1) {
                                iframe.contentWindow.postMessage({nat_visible: true}, '*');
                            } else {
                                iframe.contentWindow.postMessage({nat_visible: false}, '*');
                            }
                        }
                    };

                    self.visibility.every(100, function(ms) {
                        iframeVisibility(ms, videoIframe);
                    });
                }
            }

            self.truncateTeaser(element, position);
        } catch (e) {
        	console.log(e);
        }

        /**
         * Insert nativendo default css if we need it
         */
		if (self.iFrameDoc && !self.defaultCssAvailable) {

			// first check if default css is already added
			var allLinks = self.iFrameDoc.getElementsByTagName('link');

			for (var i = 0; i < allLinks.length; i++) {
				if (allLinks[i].getAttribute('href') == self.defaultCssUrl) {
					self.defaultCssAvailable = true;
					break;
				}
			}

			if (!self.defaultCssAvailable) {
			    var head  = self.iFrameDoc.getElementsByTagName('head')[0];
			    var link  = self.iFrameDoc.createElement('link');

			    link.rel  = 'stylesheet';
			    link.type = 'text/css';
			    link.href = self.defaultCssUrl;
			    link.media = 'all';
			    head.appendChild(link);

			    self.defaultCssAvailable = true;
		    }
		}

        self.contentBlockers.addClass('hide');
    },

    truncateTeaser: function(element, position) {
        var self = this;

        try {
            var parent = element;

            if (['before', 'after'].indexOf(position) !== -1) {
                parent = parent.parentNode;
            }

            var containers = [].slice.call(parent.querySelectorAll('.nativendo-truncate-container')),
                images     = [].slice.call(parent.querySelectorAll('img'));

            containers.forEach(function(container) {
                var text = container.querySelector('.nativendo-truncate-text');

                self.ellipsis.truncateOnLoad(container, text, images);
            });
        } catch (e) {}
    },

    scrollToPlaceholder: function() {
        var self = this;

        if (self.xpathInspector) {
            var currentXPath = self.xpathInspector.get('value').trim();

            if (currentXPath) {
                var nodes = self.getElementByXPath(currentXPath, self.iFrameDoc);

                if (nodes.length > 0) {
                    var pos = nodes[0].getBoundingClientRect();

                    self.iframe.contentWindow.scrollTo(pos.left, pos.top + self.iframe.contentWindow.pageYOffset - 150);
                }
            }
        }
    },

    selectPlaceholder: function(el, replaceXPath, attachBtn) {
        var self  = this,
            xpath = self.getXPath(el);

        if (typeof replaceXPath == 'undefined') {
            var replaceXPath = true;
        }

        if (typeof attachBtn === 'undefined') {
            attachBtn = false;
        }

        if (self.element != null) {
            for (key in self.inspectorStyles) {
                if (!self.inspectorStyles.hasOwnProperty(key)) {
                    continue;
                }

                try {
                    self.element.style[key] = el.getAttribute('data-nat-style-' + key);
                } catch (ex) {}
            }

            if (!attachBtn && self.element === el) {
                self.element = null;
                return false;
            }
        }

        self.element = el;

        if (replaceXPath) {
            self.xpathInspector.set('value', xpath);
        }

        for (key in self.selectedStyles) {
            if (!self.selectedStyles.hasOwnProperty(key)) {
                continue;
            }

            try {
                el.style[key] = self.selectedStyles[key];
            } catch (ex) {}
        }
    },

    setIframeDimension: function() {
        var self         = this,
            dim          = ['100%', '0px'],
            widthMapping = {
                'desktop'              : '100%',
                'tablet-landscape'     : '1024px',
                'tablet-portrait'      : '768px',
                'smartphone-landscape' : '480px',
                'smartphone-portrait'  : '360px'
            };

        if (self.iframe) {
            if (self.widthSelect) {
                var width = self.widthSelect.get('value');

                if (width) {
                    dim[0] = widthMapping[width];
                }
            }

            dim[1] = (document.documentElement.clientHeight - self.iframe.getPosition().y - 20) + 'px';

            self.iframe.setStyle('display', 'block');
            self.iframe.setStyle('width', dim[0]);
            self.iframe.setStyle('height', dim[1]);
        }

        return dim;
    },

    setIframeSource: function(source) {
        var self = this;

        if (self.iframe.src == source) {
            self.iframe.contentDocument.location.reload(true);
        } else {
            self.iframe.src = source;
        }
    },

    setStatus: function(message, type, options) {
        var self = this;

        if (!self.form) {
            return;
        }

        app.get('xhrForm').setStatus(self.form, message, type, options);
        app.get('xhrForm').unsetLoader(self.form);
    },

    setTemplateError: function() {
        var self = this;

        if (!self.templateSelect || !self.templateButton) {
            return;
        }

        self.setStatus(app.get('i18n').translate('teaser.template.load.error'), 'danger');
        self.templateSelect.set('value', '');
        self.templateButton.removeClass('blocked');
    },

    unsetStatus: function() {
        var self = this;

        if (!self.form) {
            return;
        }

        app.get('xhrForm').unsetStatus(self.form, true);
        app.get('xhrForm').unsetLoader(self.form);
    }
};


var AlertMessage = function() {};

AlertMessage.prototype = {
	_prepareElement : function(formAlert, content, type, options) {
	    var defaultType    = 'info',
	        defaultOptions = {
	            'content'     : content,
	            'icon'        : null,
	            'color'       : 'white',
	            'textColor'   : 'black',
	            'lighten'     : 3,
	            'darken'      : false,
	            'textLighten' : false,
	            'textDarken'  : false,
	            'class'       : '',
	            'cardType'    : 'row',
	            'style'       : '',
	            'id'          : '',
	            'dismiss'     : false
	        };

	    if (typeof options != 'object') {
	        options = {};
	    }

	    var defaultSettings = {
	        'success' : {'icon' : 'check_circle_outline', 'color' : 'green'},
	        'warning' : {'icon' : 'error_outline', 'color' : 'yellow'},
	        'danger'  : {'icon' : 'highlight_off', 'color' : 'red'},
	        'info'    : {'icon' : 'info_outline', 'color'  : 'grey'}
	    };

	    var settings = {};

	    if (type !== false) {
	        settings = (type in defaultSettings) ? defaultSettings[type] : defaultSettings[defaultType];
	    }

	    options = Object.merge(settings, options);
	    options = Object.merge(defaultOptions, options);

	    var clsParts = {
	        'classes'     : 'card-panel card-alert card-type-' + options['cardType'],
	        'color'       : (options['color'] !== false) ? options['color'] : '',
	        'textColor'   : (options['textColor'] !== false) ? options['textColor'] + '-text' : '',
	        'lighten'     : (options['lighten'] !== false) ? 'lighten-' + options['lighten'] : '',
	        'darken'      : (options['darken'] !== false) ? 'darken-' + options['darken'] : '',
	        'textLighten' : (options['textLighten'] !== false) ? 'text-lighten-' + options['textLighten'] : '',
	        'textDarken'  : (options['textDarken'] !== false) ? 'text-darken-' + options['textDarken'] : '',
            'icon'        : (options['icon']) ? 'card-alert-icon' : '',
            'dismiss'     : (options['dismiss']) ? 'card-alert-dismiss' : '',
	        'class'       : options['class']
	    };

	    options['classes'] = Object.values(clsParts).join(' ').replace(/\s+/g, ' ').trim();

    	formAlert.set({
	        'class' : options['classes'],
	        'style' : options['style'],
	        'html'  : ((options['dismiss']) ? '<i class="material-icons alert-dismiss">' + options['dismiss'] + '</i>' : '')
	                  + ((options['icon']) ? '<i class="material-icons alert-icon">' + options['icon'] + '</i>' : '')
	                  + '<span class="alert-message">' + content + '</span>'
        });

        if (options["data"]) {
        	Object.each(options["data"], function(dataValue, dataKey) {
        		formAlert.set('data-' + dataKey, dataValue);
        	});
        }

        return formAlert;
	},

	update : function(formAlert, content, type, options) {
		return this._prepareElement(formAlert, content, type, options);
	},

	add : function(content, type, options) {
		return this._prepareElement(new Element('div'), content, type, options);
   }
}

var CharLengthCheck = function(container) {
	var self = this;

	this.updateCounter = function() {
		window.setTimeout(function() {
		    var value = this.get('value');

		    if (this.get('data-resolve-user-placeholders')) {
		        value = value.replace(/\{user\..+?(?:\s*\|\s*(.*?))?\}/gi, '$1');
		    }

			var length   = value.length;
			var counter  = this.retrieve('length-check-counter');
			var maxChars = this.get('data-max-chars');

			if (length > maxChars) {
				counter.removeClass('grey-text').addClass('red-text');
			} else {
				counter.addClass('grey-text').removeClass('red-text');
			}

			counter.getElement('span').set('html', length);
		}.bind(this), 100);
	};

	this.initCounter = function(el) {
		// prepare elements
		var label    = container.getElement('label[for="' + el.get('id') + '"]');
		var maxChars = el.get('data-max-chars');

		var counter = new Element('span', {
			'class' : 'right grey-text',
			'html'  : '(<span></span> / ' + maxChars + ' ' + app.get('i18n').translate((maxChars == 1) ? 'character' : 'characters') + ')'
		}).inject(label, 'bottom');

		el.store('length-check-counter', counter);

		el.addEvents({
			'keyup'       : self.updateCounter,
			'paste'       : self.updateCounter,
			'change'      : self.updateCounter,
            'contextmenu' : self.updateCounter
		});

		el.fireEvent('keyup');
	};

	this.init = function(container) {
		container.getElements('[data-max-chars]').each(function(charLengthEl) {
			if (['textarea', 'input'].indexOf(charLengthEl.get('tag')) === -1) {
				return;
			}

			var maxChars = charLengthEl.get('data-max-chars').toInt();

			if (isNaN(maxChars)) {
				maxChars = 0;
			}

			if (maxChars === 0) {
				return;
			}

			self.initCounter(charLengthEl);
		});
	}

	this.init(container);
}

var Chart = function(container) {
	var self = this;

    if (typeof AmCharts === 'undefined') {
        return;
    }

    var i18n             = app.get('i18n'),
        language         = app.get('i18n').getLanguage(),
        translateOptions = {transform: 'ucfirst'};

    // Set translations for AmCharts
    if (typeof AmCharts.translations[language] === 'undefined') {
        AmCharts.translations[language] = {
            monthNames: [
                i18n.translate('january', translateOptions),
                i18n.translate('february', translateOptions),
                i18n.translate('march', translateOptions),
                i18n.translate('april', translateOptions),
                i18n.translate('may', translateOptions),
                i18n.translate('june', translateOptions),
                i18n.translate('july', translateOptions),
                i18n.translate('august', translateOptions),
                i18n.translate('september', translateOptions),
                i18n.translate('october', translateOptions),
                i18n.translate('november', translateOptions),
                i18n.translate('december', translateOptions)
            ],
            shortMonthNames:[
                i18n.translate('january.short', translateOptions),
                i18n.translate('february.short', translateOptions),
                i18n.translate('march.short', translateOptions),
                i18n.translate('april.short', translateOptions),
                i18n.translate('may.short', translateOptions),
                i18n.translate('june.short', translateOptions),
                i18n.translate('july.short', translateOptions),
                i18n.translate('august.short', translateOptions),
                i18n.translate('september.short', translateOptions),
                i18n.translate('october.short', translateOptions),
                i18n.translate('november.short', translateOptions),
                i18n.translate('december.short', translateOptions)
            ],
            dayNames:[
                i18n.translate('sunday', translateOptions),
                i18n.translate('monday', translateOptions),
                i18n.translate('tuesday', translateOptions),
                i18n.translate('wednesday', translateOptions),
                i18n.translate('thursday', translateOptions),
                i18n.translate('friday', translateOptions),
                i18n.translate('saturday', translateOptions)
            ],
            shortDayNames:[
                i18n.translate('sunday.short', translateOptions),
                i18n.translate('monday.short', translateOptions),
                i18n.translate('tuesday.short', translateOptions),
                i18n.translate('wednesday.short', translateOptions),
                i18n.translate('thursday.short', translateOptions),
                i18n.translate('friday.short', translateOptions),
                i18n.translate('saturday.short', translateOptions)
            ],
            zoomOutText: i18n.translate('show.all', translateOptions)
        };
    }

	this.container = container;

	this.prepare = function(chartContainers) {
		if (typeof chartContainers === 'undefined') {
			chartContainers = container.getElements('.mt-chart');
		}

		chartContainers.each(function(chartContainer) {
			self.prepareContainer(chartContainer);

			self.count += 1;
		});
	};

	this.prepareContainer = function(chartContainer) {
        if (!chartContainer.get('id')) {
            chartContainer.set('id', 'amc-' + String.uniqueID());
        }

        self.prepareConfig(chartContainer.get('id'), chartContainer);

		if (this.charts[chartContainer.get('id')]['autoload']) {
			self.refresh(chartContainer.get('id'));
		}
	};

	this.getDataFromUrlByChartId = function(id, callback) {
		if (typeof self.charts[id]["config"]["data_from_url"] !== 'undefined' && !self.charts[id]["config"]["data_from_url"]) {
			callback(self.charts[id]["config"]["dataProvider"]);

			return;
		}

		var postData = {};

		Object.each(self.charts[id]['params'], function(val, key) {
			postData[key] = val;

			if (typeof val === 'object' && ('length' in val) && !val.length) {
				postData[key] = '';
			}
		});

		Object.each(self.charts[id]['filters'], function(val, key) {
			postData[key] = val;
		});

		var ChartUrl = (typeof self.charts[id]["config"]["url"] === 'undefined') ? app.get('chart_url') : self.charts[id]["config"]["url"];

        new XmlHttpRequest.JSON({
        	headers 	: app.get('api_headers'),
        	logoutCheck : false,
        	url     	: ChartUrl,
        	data    	: postData,
        	method  	: 'post',

        	onFailure : function() {
        		self.error(id);
        	},

        	onError : function() {
        		self.error(id);
        	},

            onSuccess : function(rsp) {
            	if (self.charts[id].config.store_response || app.get('store_chart_rsp')) {
            		self.charts[id]['rsp'] = JSON.stringify(rsp);
            	}

            	callback(rsp);
            }
        }).send();
	}

	this.refresh = function(id, refreshCb) {
		var config = self.getConfig(id);

        config = self.handleCallback(id, 'prepare_refresh_config', [config]);

		var dateType = (self.charts[id]['params']['date_type']) ? self.charts[id]['params']['date_type'] : self.charts[id]['filters']['date_type'];

        switch (dateType) {
            case 'hourly':
                config.categoryAxis.minPeriod = 'hh';
                config.chartCursor.categoryBalloonDateFormat = "DD.MM.YYYY JJ:NN";
                break;

            case 'yearly':
                config.categoryAxis.minPeriod = 'YYYY';
                config.chartCursor.categoryBalloonDateFormat = "YYYY";
                break;

            case 'monthly':
                config.categoryAxis.minPeriod = 'MM';
                config.chartCursor.categoryBalloonDateFormat = "MM/YYYY";
                break;

            case 'weekly':
                config.categoryAxis.minPeriod = '7DD';
                config.chartCursor.categoryBalloonDateFormat = "W - DD.MM.YYYY";
                break;

            default:
                config.categoryAxis.minPeriod = 'DD';
                config.chartCursor.categoryBalloonDateFormat = "DD.MM.YYYY";
                break;
        }

		// add loader
        self.charts[id]['container'].set('html', app.get('loader').add(null, true));

        this.getDataFromUrlByChartId(id, function(rsp) {
        	self.build(id, rsp);

        	if (typeof refreshCb === 'function') {
        		refreshCb(id, rsp);
        	}
        });
	};

	this.error = function(id) {
		var chartContainer = document.id(id);

		if (!chartContainer) {
			// @todo JH 16.04.2018: logging unknown error!
			return;
		}

		var type = 'line';

		switch (true) {
			case (this.charts[id] && this.charts[id]['config'] && this.charts[id]['config']['type'] == 'pie'):
				type = this.charts[id]['config']['type'];
				break;

			case (this.charts[id] && this.charts[id]['config'] && this.charts[id]['config']['stackType'] == 'regular'):
				type = 'column';
				break;

			default:
				type = 'line';
		}

		window.setTimeout(function() {
			chartContainer.set('html', '');

	        var imageUrl = app.get('webhost') + 'theme/nativendo/asset/image/chart-no-data/' + type + '.jpg';

	        var msg = new Element('div', {
	            'class' : 'chart-alert',
	            'html'  : app.get('i18n').translate('no.data.available')
	        }).inject(chartContainer, 'bottom');

	        chartContainer.setStyles({
	        	'background' : 'url(' + imageUrl + ') center center / 100% no-repeat'
	        });

	        switch (type) {
	            case 'line':
	                msg.setStyle('left', (chartContainer.getSize().x/2) - (msg.getSize().x/2));
	            break;
	        }

			if (this.charts[id]['amchart']) {
	        	this.charts[id]['amchart']['export']['enabled'] = false;
	        }
		}.bind(this), 250);
	};

	this.build = function(id, rsp) {
		var config = this.getConfig(id);

		if (document.id(id)) {
			document.id(id).setStyle('background-image', '');
		}

        if (String(JSON.encode(rsp)) === '{}') {
        	this.error(id);

            self.handleCallback(id, 'error');

            return;
        }

        var dataProvider = [];
        var timePoints   = 0;

		var aggregated = (rsp && rsp.data && rsp.data.aggregated) ? rsp.data.aggregated : {};

   		rsp = self.handleCallback(id, 'rsp_rework', [rsp, aggregated]);

        if (rsp === false) {
        	// no build available
        	return;
        }

		var aggregatedData = {};

        if (rsp.data && ('aggregated' in rsp.data)) {
			aggregatedData = rsp.data.aggregated;

			self.charts[id]['aggregated_data'] = rsp.data.aggregated;

			delete rsp.data.aggregated;
        }

		if (rsp.data) {
	        Object.values(rsp.data).each(function(row) {
	            if (row.ts) {
	                var ts = parseInt(row.ts) * 1000;
	                ts -= app.get('i18n').getTimeZoneDiff(ts);
	                row.ts = new Date(ts);
	            }

	            dataProvider.push(row);

	            timePoints++;
	        });
      } else {
      	dataProvider = rsp;
      }

	    dataProvider = self.handleCallback(id, 'rework', [dataProvider, aggregatedData]);

        if (timePoints > 40) {
            Object.each(config.graphs, function(graph) {
               if (graph.id == 'graph_markers') {
                   graph.bulletSize = 2;
                   return;
               }

               graph.bullet         = 'none';
               graph.lineThickness  = 1;
            });
        } else {
            Object.each(config.graphs, function(graph) {
               if (graph.defaultValues) {
                   Object.each(graph.defaultValues, function(val, key) {
                       graph[key] = val;
                   });
               }
            });
        }

        config.dataProvider = dataProvider;

        if (config.export && config.export.enabled) {
            config.export.menu[0].title = app.get('i18n').translate('save.chart.as.graphic');
        }

		config = self.handleCallback(id, 'config', [config]);

        if ('dataProvider' in config && config.dataProvider.length === 0) {
            config.legend.enabled = false;
        }

        var amChart = null;
        try {
            amChart = AmCharts.makeChart(id, config);
        } catch (err) {
            console.warn(err);
            console.log(config);

            this.error(id); // @todo better error handling?!
        }

        this.charts[id]['amchart'] = amChart;

        this.handleAggregateData(id, aggregatedData);

        if (amChart && amChart.dataProvider.length === 0) {
        	this.error(id);
        }
	};

	this.handleAggregateData = function(id, aggregated) {
        if (!aggregated) {
            return;
        }

        var container = this.charts[id]['container'].getParent('.mt-chart-container');
        var sumEl     = (container) ? this.charts[id]['container'].getParent('.mt-chart-container').getElement('.mt-label') : null;

        if (!sumEl) {
        	self.handleCallback(id, 'aggregate', [aggregated, this.charts[id]['config']['dataProvider'], null, this.charts[id]['config'], this.charts[id]]);

            return;
        }

        var labels = self.handleCallback(id, 'aggregate', [aggregated, this.charts[id]['config']['dataProvider'], sumEl, this.charts[id]['config'], this.charts[id]], []);

        if (typeof labels === 'string' && labels === 'loader') {
	        var loaderHTML = app.get('loader').add(null, true, 'micro');

	        loaderHTML = loaderHTML.replace('preloader-micro"', 'preloader-micro" style="display: inline-block;width: 15px;margin-right: 6px;"');

            labels = loaderHTML;
        }

        if (labels !== false && !(labels instanceof Array)) {
            labels = [labels];
        }

        if (labels !== false && labels.length === 0) {
            Object.each(aggregated, function(typeValues, type) {
                Object.each(typeValues, function(typeValue) {
                    labels.push(app.get('i18n').formatNumber(typeValue));
                });
            })
        }

        if (typeof labels !== 'string' && labels.length > 0) {
        	if (!sumEl.get('data-use-brackets') || sumEl.get('data-use-brackets') == '1') {
        		sumEl.set('html', '(' + labels.join(' / ') + ')');
        	} else {
        		sumEl.set('html', labels.join(' / '));
        	}
        }
    };

	this.handleCallback = function(id, callbackName, params, defaultRet) {
		if (typeof params === 'undefined') {
			params = [];
		}

        if (typeof self.callback[id][callbackName] == 'function') {
        	return self.callback[id][callbackName].apply({id: id}, params);
        }

		if (typeof defaultRet !== 'undefined') {
			return defaultRet;
		}

        return params[0];
	};

	this.initGraphs = function(id, config) {
		if (config.graphs.length === 0 && self.charts[id]['params']['metric']) {
			var metrics = self.charts[id]['params']['metric'];

			if (typeof metrics === 'string') {
				metrics = [metrics];
			}

			metrics.each(function(metric) {
				config.graphs.push({
					valueField : metric.replace(/\:/g, '_')
				});
			});
		}

		var showLabelInBalloon = (config.graphs.length > 0);

	    if (config.showMarkers) {
	        config.graphs.push({
	            id              : 'graph_markers',
	            valueField      : 'marker',
	            balloonText     : '[[markerText]]',
	            bulletSize      : 8,
	            bullet          : 'round',
	            useLineColorForBulletBorder : true,
	            bulletBorderAlpha : 1,
	            bulletAlpha     : 1,
	            title           : app.get('i18n').translate('global.events'),
	            lineAlpha       : 1,
	            connect         : false,
	            visibleInLegend : false,
	            useBalloonFunctionCb : false
	        });

	        self.charts[id]['params']['show_markers'] = '1';
	    }

        var graphLen      = config.graphs.length,
            colorStepSize = Math.floor(app.get('color-count') / graphLen);

        config.graphs.each(function(graph, i) {
            var colorKey             = 'theme-color-' + ((i * colorStepSize) + 1);
            var useBalloonFunctionCb = ('useBalloonFunctionCb' in graph) ? graph.useBalloonFunctionCb : true;

            if (graph.graphColor) {
                graph.fillColors = graph.graphColor;
                graph.lineColor  = graph.graphColor;
            } else {
                graph.fillColors = app.get(colorKey);
                graph.lineColor  = app.get(colorKey);
            }

            graph.valueField = graph.valueField || graph.field;
            graph.type       = graph.type || "line";

            graph.lineThickness = 2;

            if (graph.id != 'graph_markers' && typeof self.charts[id]['params'] !== 'undefined' && (typeof self.charts[id]['params']['type'] === 'undefined' || self.charts[id]['params']['type'] === 'line')) {
                graph.bulletSize        = graph.bulletSize || 6;
                graph.bullet            = graph.bullet || "round";
                graph.bulletBorderAlpha = graph.bulletBorderAlpha || 1;
                graph.bulletColor       = graph.bulletColor || "#FFFFFF";
                graph.useLineColorForBulletBorder = graph.useLineColorForBulletBorder || true;
            }

            if (!graph.defaultValues) {
                graph.defaultValues = {
                    'lineThickness' : graph.lineThickness,
                    'bullet'        : graph.bullet
                };
            }

            // fill alphas if not line or smoothedLine graph
            if (!graph.type.toLowerCase().contains('line')) {
                graph.fillAlphas = 1;
            }

            config.area && (graph.fillAlphas = 0.7);

	        if (useBalloonFunctionCb && !graph.balloonFunction && !graph.numberFormatter && showLabelInBalloon) {
	        	self.addFormatterCb(config, graph, 'balloonFunction', 'graph');
	        }

            if (graph.benchmark) {
                config.valueAxes[0].guides = [{
                    value         :  graph.benchmark,
                    fillColor     : '#FFFFFF',
                    fillAlpha     : 0.6,
                    lineColor     : '#FF0000',
                    lineThickness : 1,
                    lineAlpha  : 0.8,
                    position   : "right",
                    dashLength : 2,
                    tickLength : 0,
                    above      : true
                }];
            }
        });

        return config.graphs;
	}

	this.prepareConfig = function(id, chartContainer) {
		var config = this.getConfig(id, chartContainer);

        if ('params' in config) {
            self.charts[id]['params'] = self.handleCallback(id, 'params', [config.params, self]);

            delete config.params;
        }

        config.startDuration 			= 0;
        config.chartCursor.cursorColor  = app.get('theme-color-1');

        if (config.graphs) {
        	config.graphs = this.initGraphs(id, config);
        }

        // init ballon
        if (!config.balloon) {
            config.balloon = {};
        }

        config.balloon['adjustBorderColor'] = false;
        config.balloon['fillColor'] = "#fff";// use color form line
        config.balloon['color']     = "#fff"; // use color form line

        // enable legend
        config.legend.enabled = (config.enable_legend);

        if (!config.legend.valueFunction) {
        	this.addFormatterCb(config, config.legend, 'valueFunction', 'legend');
        }

        config.valueAxes[0].unit            = config.unit || '';
        config.valueAxes[0].unitPosition    = config.unitPosition || '';
        config.valueAxes[0].stackType       = config.stackType || 'none';
        config.valueAxes[0].integersOnly    = config.integersOnly || false;

        if (!config.valueAxes[0].labelFunction) {
        	this.addFormatterCb(config, config.valueAxes[0], 'labelFunction', 'valueAxes');
        }

        if (!self.charts[id]['params']['aggregate'] && self.charts[id]['params']['metric']) {
        	var aggregate = {
        		'sum' : []
        	};

			if (typeof self.charts[id]['params']['metric'] === 'string') {
				aggregate.sum.push(self.charts[id]['params']['metric']);
			} else {
				self.charts[id]['params']['metric'].each(function(metric) {
					aggregate.sum.push(metric);
				});
			}

			self.charts[id]['params']['aggregate'] = aggregate;
		}
	};

	this.addFormatterCb = function(config, configObj, cbName, configName) {
    	var formatType = (typeof config.numberFormat === 'string' || typeof config.numberFormat === 'undefined') ? config.numberFormat : config.numberFormat.name;
    	var options    = false;

    	if (typeof config.numberFormat === 'object' && config.numberFormat[configName]) {
    		options = config.numberFormat[configName];
    	}

    	var cb = function() {};

    	switch (formatType) {
    		case 'currency':
    			cb = function(value) {
    				return app.get('i18n').formatCurrency(value, (options !== false) ? options :  {'precision' : (cbName === 'labelFunction' && config.integersOnly) ? 0 : 2});
    			};

    			break;

    		case 'percent':
    			cb = function(value) {
    			    if (options === false) {
    			        options = {};
    			    }

    			    options.multiplier = 1;

    			    if (configName == 'valueAxes') {
    			        options.fixed = false;
    			    }

    				return app.get('i18n').formatPercent(value, options);
    			};
    			break;

    		default:
    			cb = function(value) {
    				if (!options) {
    					options = {};
    				}

    				if (config.integersOnly && typeof options.precision == 'undefined') {
    					options['precision'] = 0;
    				}

    				return app.get('i18n').formatNumber(value, (options !== false) ? options : {});
    			};
    			break;
    	}

    	switch (cbName) {
    		case 'balloonFunction':
		    	configObj[cbName] = function(dataObj, label, c) {
					var graphLenCheck = (config.showMarkers) ? 2 : 1;
		    		var ballonLabel   = (config.graphs.length > graphLenCheck && configObj.title) ? configObj.title + ': ' : '';

					if (!dataObj.dataContext[dataObj.graph.valueField]) {
						ballonLabel += cb(0);
					} else {
						ballonLabel += cb(dataObj.dataContext[dataObj.graph.valueField]);
					}

					return ballonLabel
				}
    			break;

    		case 'valueFunction':
		    	configObj[cbName] = function(dataObj, label) {
		    		if (!dataObj.graph) {
		    			return '';
		    		}

		    		return cb(dataObj['dataContext'][dataObj.graph.valueField]);
		    	}
    		break;

    		default:
		    	configObj[cbName] = function(value, label) {
		    		return cb(value);
		    	}
		    	break;
    	}
	}

	this.getApiUrl = function(id) {
		if (!self.charts[id]) {
			return '';
		}

		return app.get('chart_url') + '?' + (new Hash(self.charts[id]['params'])).toQueryString() + '&' + (new Hash(self.charts[id]['filters'])).toQueryString();
	};

	this.getConfig = function(id, chartContainer) {
        if (self.charts[id]) {
            return self.charts[id]['config'];
        }

        var chartConfig = JSON.decode(chartContainer.get('text').trim(), false);

        chartContainer.set('html', '');

        if (typeof chartContainer.retrieve('chart-config') === 'string') {
            chartConfig = JSON.decode(chartContainer.retrieve('chart-config'), false);
        }

        var AMChartConf = JSON.parse(JSON.stringify(self.AMConfig));

        AMChartConf.language = app.get('i18n').getLanguage(app.get('i18n').getLocale('date_time'));

        var config = Object.assign({}, AMChartConf, chartConfig);

        // set the callbacks
        self.callback[id] = typeof config['callback'] === 'undefined' ? {} : config['callback'];

        config = self.handleCallback(id, 'prepare_config', [config]);

        if (config.filter) {
        	filterForm = config.filter;
        	delete config.filter;
        } else {
        	filterForm = this.filter
        }

        var autoload = false;

        if (config.autoload) {
        	autoload = config.autoload;
        	delete config.filter;
        }

        self.charts[id] = {
        	config     : config,
        	amchart    : null,
        	container  : chartContainer,
        	filters    : {},
        	filterForm : filterForm,
        	autoload   : autoload
        };

        return self.charts[id]['config'];
	};

	this.setFilters = function(id, filters) {
		if (!this.charts[id]) {
			throw "Chart with id " + id + " is unknown ";
		}

		this.charts[id][filters] = filters;
	}

	this.prepare();
};

Chart.prototype = {
	count    : 0,
	charts   : {},
	callback : {},

	filter : '.mt-chart-filter',

	AMConfig : {
		"hideCredits": true,
		"type": "serial",
		"language":"de",
		"categoryField": "ts",
		"dataDateFormat": "YYYY-MM-DD",
		"precision": 2,
		"decimalSeparator": ",",
		"thousandsSeparator": ".",
		"autoResize": true,
		"autoDisplay": true,
		"autoTransform": false,
		"colors": [
			"#e9626b",
			"#bc1a24",
			"#43090d",
		],
		"categoryAxis": {
			"parseDates": true,
			"minPeriod": "DD",
			"dateFormats": [
				{"period": 'fff', "format":'JJ:NN:SS'},
				{"period":'ss', "format":'JJ:NN:SS'},
				{"period":'hh', "format":'JJ:NN'},
				{"period": "mm", "format": "DD. MMM JJ:NN"},
				{"period": "DD", "format": "DD. MMM"},
				{"period": "MM", "format": "MMM"},
				{"period": "YYYY", "format": "YYYY"}
			]
		},
		"chartCursor": {
			"enabled": true,
			"categoryBalloonDateFormat": "YYYY"
		},
		"chartScrollbar": {
			"enabled": false
		},
		"trendLines": [],
		"graphs": [],
		"guides": [],
		"valueAxes": [{
			"id": "value-axis"
		}],
		"allLabels": [],
		"balloon": {},
		"legend": {
			"enabled": false,
			"useGraphSettings": true,
			"equalWidths": false
		},
		"titles": [],
		"dataProvider": [],

		"numberFormatter": {
			"precision": 0,
			"decimalSeparator": ",",
			"thousandsSeparator": "."
		},

	  "export": {
	    "enabled": true,
	    "libs"  : {
	    	"resources" : [
		    	"fabric.js/fabric.min.js",
				"FileSaver.js/FileSaver.min.js"
	    	]
	    },
	    "formats" : {
	    	"PNG" : {
	    		"mimeType"  : "image/png",
	    		"extension" : "png",
	    		"capture"   : true
	    	}
	    },
	    "fileName":"export",
	        "backgroundColor"     : 'transparent',
	      "menu": [{
	        "backgroundColor"     : 'transparent',
	        "format"    : "PNG",
	        "fileName"  :"export",
	        "label"     : "<i class='material-icons'>file_download</i>",
	        "title"     : "Export chart to PNG"
	     }]
	  }
	},
};

var ChartFilter = function(container) {
	var self = this;

	this._prepareFilters = function(filterForm, filterObj) {
		Object.each(filterObj, function(filterValue, filterKey) {
			// special case pid networkid
			if (filterKey === 'pid') {
				if (typeof filterValue === 'string') {
					filterValue 		 = [filterValue];
					filterObj[filterKey] = filterValue;
				}

				filterValue.each(function(filterVal, filterValKey) {
					var otherId = filterVal.match(/([^0-9]+)/);

					if (otherId) {
						otherId = otherId[1] + 'id';

						if (!filterObj[otherId]) {
							filterObj[otherId] = [];
						}

						filterObj[otherId].push(filterVal.replace(/[^0-9]+/, ''));

						filterObj[filterKey][filterValKey] = null;
					}
				});

				filterObj[filterKey] = filterObj[filterKey].clean();

				if (!filterObj[filterKey] || filterObj[filterKey].length === 0) {
					delete filterObj[filterKey];
				}
			}
		});
	}

	this.initEvents = function() {
		var events = {},
		    form   = document.getElement(self.filterForm);

		events['submit:relay(' + self.filterForm + ')'] = function(e, target) {
			e && e.stop();

			self.refreshCharts(this);

			var restoreBtn = target.getElement('.mt-restore-charts-filter');

			if (restoreBtn) {
				restoreBtn.removeClass('hide');
			}
        };

		// export actions
		events['click:relay(' + self.filterForm + ' .mt-stats-export)'] = function(e, target) {
			e && e.stop();

			if (target.hasClass('mt-lock') || target.hasClass('disabled')) {
				return;
			}

			if (!target.retrieve('label')) {
				target.store('label', target.get('html'));
			}

			target.addClass('mt-lock');

			var filters = self.getFilterValues(form);

	        var errorCb = function() {
	            target.removeClass('mt-lock');
	            target.set('html', target.retrieve('label'));
	            target.setStyle('padding-right', '');

	            alert(app.get('i18n').translate('unknown.error.occurred'));
	        };

	        var successCb = function() {
                target.removeClass('mt-lock');
                target.set('html', target.retrieve('label'));
                target.setStyle('padding-right', '');
	        }

	        //target.set('html', app.get('i18n').translate('please.wait'));

	        var loader = app.get('loader').add(this, false, 'micro');

	        loader.setStyles({
	           'display'       : 'inline-block',
	           'position'      : 'absolute',
	           'top'           : '4px',
	           'right'         : '0px',
	           'padding-right' : '10px'
	        });

	        target.setStyle('padding-right', '35px');

	        if (target.get('data-type') === 'pdf') {
	        	if (!target.retrieve('iframe')) {
	        		target.store('iframe', new Element('iframe', {
			            styles : {
			                visibility : "hidden",
			                height     : "1px",
			                width      : "1px"
			            }
		        	}));

		        	target.retrieve('iframe').inject(document.body);
	        	}

	        	var filters = Object.toQueryString(filters).replace(/([^&]+)=/g, function(found) {
					return found.replace(/^([^\[&=]+)/, function(match) {
						return 'filters[' + match + ']';
					});
	        	});

	        	var targetHref = target.get('href');

	        	if (!targetHref.match(/\&$/)) {
	        		targetHref += '?';
	        	}

		        target.retrieve('iframe').set('src', targetHref + 'type=iframe&' + filters);

		        window.setTimeout(function() {
		        	successCb();
		        }, 7000);
		        return;
	        }

			new XmlHttpRequest.JSON({
				url  : target.get('href'),

				data : {
					filters : filters
				},

				method : 'post',

				onError : function() {
					errorCb();
				},

				onComplete : function(rsp) {
					successCb();

					if (rsp && rsp.file) {
			        	filters = Object.toQueryString(filters).replace(/([^&]+)=/g, function(found) {
							return found.replace(/^([^\[&=]+)/, function(match) {
								return 'filters[' + match + ']';
							});
			        	});

						location.href = target.get('href') + '?file=' + rsp.file + '&' + filters;
						return;
					}

					errorCb();
				}
			}).send();
        };

		// filter selections
		events['change:relay(' + self.filterForm + ' .mt-fixed-filters)'] = function(e, target) {
			e && e.stop();

			var option = target.getElement('option:selected');

			if (option.get('value') === '') {
			    return;
			}

			var dateTypeEl = container.getElement(self.filterForm + ' [name="date_type"]');
			var fromEl     = container.getElement(self.filterForm + ' #filter-from');
			var toEl       = container.getElement(self.filterForm + ' #filter-to');
			var dateType   = option.get('data-date_type') || "daily";

			if (dateTypeEl) {
				dateTypeEl.set('value', dateType);
				app.get('picker.date').initGroupSelector(dateTypeEl);
			}

            fromEl.set('value', option.get('data-from'));
            var ts = option.get('data-from').toInt() * 1000;
            ts -= app.get('i18n').getTimeZoneDiff(ts);
            fromEl.retrieve('picker.date').select(new Date(ts));

            toEl.set('value', option.get('data-to'));
            var ts = option.get('data-to').toInt() * 1000;
            ts -= app.get('i18n').getTimeZoneDiff(ts);
            toEl.retrieve('picker.date').select(new Date(ts));

            target.set('value', '');

			self.refreshCharts(target.getParent('form'));
        };

        // restore filters
		events['click:relay(' + self.filterForm + ' .mt-restore-charts-filter)'] = function(e) {
			e && e.stop();

	        // Set URL
	        var tab = app.get('router').getParam('tab');
			var url = self.urlModifier.reset(self.url, ['id']);

	        url = self.urlModifier.setParams(url, []);

	        if (tab) {
	            url += '/tab/' + tab;
	        }

	        location.href = url;
        };

        events['change:relay(' + self.filterForm + ' [id="filter-from"])'] = function(e) {
            filterForm.getElement('[id="filter-to"]').retrieve('picker.date').options.minDate = (this.retrieve('picker.date').date) ? this.retrieve('picker.date').date : null;
        };

        container.addEvents(events);

        if (form) {
            form.getElement('#filter-from') && form.getElement('#filter-from').addEvent('change', function(e) {
                form.getElement('[id="filter-to"]').retrieve('picker.date').options.minDate = (this.retrieve('picker.date').date) ? this.retrieve('picker.date').date : null;
            }).fireEvent('change');

            form.getElement('#filter-to') && form.getElement('#filter-to').addEvent('change', function(e) {
                form.getElement('[id="filter-from"]').retrieve('picker.date').options.maxDate = (this.retrieve('picker.date').date) ? this.retrieve('picker.date').date : null;
            }).fireEvent('change');

            var topNav          = document.getElement('.top-nav');
            var containerHeight = container.getCoordinates().height;
            var filterBarTop    = container.getCoordinates().top;
            var topNavHeight    = topNav.getCoordinates().height;
            var marginBuffer    = 10;

            window.addEvent('scroll', function(e) {
            	if (document.body.clientHeight <= window.innerHeight) {
            		return;
            	}

            	if (this.scrollY > filterBarTop - topNavHeight - marginBuffer) {
					container.addClass('filter-container-fixed');
					container.setStyle('height', containerHeight);
            	} else {
            		container.removeClass('filter-container-fixed').setStyle('height', '');
            	}
            }).fireEvent('scroll');
        }
	};

	this.setCallbacks = function(type, cb) {
		this.cbs[type] = cb;
	}

	this.callbacks = function(type, params) {
		if (!this.cbs[type]) {
			return;
		}

		if (typeof params === 'undefined') {
			params = [];
		}

		this.cbs[type].apply(null, params);
	};

	this.initXhrChosen = function() {
		app.get('chosenXhr').init(container);
	}

	this.afterRefresh = function(id, rsp) {
		self.currentLoaded++;

		if (self.currentLoaded === app.get('chart').count) {
			// fully loaded!

			var allowReport = false;
			Object.each(app.get('chart').charts, function(chartData) {
				if (!chartData['aggregated_data']) {
					return;
				}

				Object.each(chartData['aggregated_data']['sum'], function(val) {
					if (val != 0) {
						allowReport = true;
					}
				});
			});

			self.currentFilterForm.getElements('.mt-stats-export').each(function(exportBtn) {
				if (allowReport) {
					exportBtn.removeClass('tooltip').removeClass('disabled');
					exportBtn.getElement('[rel="tooltip"]').addClass('hide');
				} else {
					exportBtn.addClass('tooltip disabled');
					exportBtn.getElement('[rel="tooltip"]').removeClass('hide');
				}
			});
		}

		var filters = self.getFilterValues(self.currentFilterForm);

		var creativeExport = document.getElement('.mt-stats-export[data-name="creative_export"]');

		if (creativeExport) {
			if (filters["mid"] && allowReport) {
				creativeExport.removeClass('tooltip').removeClass('disabled');
				creativeExport.getElement('[rel="tooltip"]').addClass('hide');
			} else {
				creativeExport.addClass('tooltip disabled');
				creativeExport.getElement('[rel="tooltip"]').removeClass('hide');
			}
		}
	}

	this.getFilterValues = function(form) {
		var filters = form.toQueryString().parseQueryString();

		self._prepareFilters(form, filters);

		return filters;
	}

	this.refreshCharts = function(filterForm) {
		if (!filterForm || !app.get('chart').charts) {
			return;
		}

		var filters = this.getFilterValues(filterForm);

		self.currentLoaded = 0;
		self.currentFilterForm = filterForm;

		Object.each(app.get('chart').charts, function(chartData, chartId) {
			if (document.getElement(chartData.filterForm) !== filterForm) {
				return;
			}

			chartData.filters = {};

			Object.each(filters, function(fValue, fKey) {
				chartData.filters[fKey] = fValue;
			});

			app.get('chart').refresh(chartId, self.afterRefresh);
		});

		self.callbacks('submit', [filters]);

        // Set URL
        var url    = this.urlModifier.reset(this.url, ['id']),
            params = filters,
            tab    = app.get('router').getParam('tab');

		// clean params
		var newParams = [];

		Object.each(params, function(paramValue, paramKey) {
			var newParams = [];

			if (typeof paramValue === 'string') {
				return;
			}

			paramValue.each(function(paramVal) {
				if (paramVal.indexOf(',') !== -1) {
					paramVal.split(',').each(function(splitVal) {
						newParams.push(splitVal);
					});

					return;
				}

				newParams.push(paramVal);
			});

			params[paramKey] = newParams.unique();
		});

        url = this.urlModifier.setParams(url, params);

        if (tab) {
            url += '/tab/' + tab;
        }

        this.history.set(url);
	};

	this.checkCharts = function(onlyUrl) {
		self.refreshCharts(container.getElement(self.filterForm));
	};

	this.url = location.href.replace(/\/tab\/[^\/]+/, '');

	this.url = this.url.replace(/\/$/, '');

	this.history = new History();

	this.urlModifier = new UrlModifier();

	this.initEvents();

	this.checkCharts();

	this.initXhrChosen();
};

ChartFilter.prototype = {
	currentFilterForm : null,
	cbs : {},
	currentLoaded : 0,
	chartCount : 0,
	filterForm : '.mt-chart-filter'
}

var Chosen = function(container) {
	var self = this;

    this.createMultiLabel = function(select, dummySelect, list) {
        var currSelected       = list ? list.getElements('.selected') : select.getElements('option:selected');
        var totalSelectionsLen = select.getElementsByTagName('option').length - 1;

        dummySelect = dummySelect || select;

        select.value = false;
        currSelected.each(function(selLiElement) {
            select.getElement('[value="' + selLiElement.getAttribute('value') + '"]').selected = true;
        });

        select.fireEvent('change', {target:select});

        var cstConfig   = select.retrieve('natiselect.config');
        var placeholder = select.options[0].text;

        if (currSelected.length > 0) {
            placeholder = currSelected.get('text').map(function(item) { return String(item).trim(); }).join(', ');
        }

        if (!self.labelWidthDiv) {
            self.labelWidthDiv = new Element('div', {
                styles : {
                    visibility : 'hidden'
                }
            }).inject(document.body, 'bottom');
        }

        self.labelWidthDiv
            .set('html', placeholder)
            .setStyle('display', 'inline-block');

        var dummySelectWidth = dummySelect.getCoordinates().width;

        if (currSelected.length > 0 && dummySelectWidth > 0 && self.labelWidthDiv.getCoordinates().width > dummySelectWidth) {
            var selectedLabel = app.get('i18n').translate('selected');

            if (cstConfig && cstConfig["labels"] && cstConfig["labels"]["selected"]) {
                selectedLabel = cstConfig["labels"]["selected"];
            }

            placeholder = currSelected.length + ' ' + selectedLabel;
        }

        if ((select.get('data-all-selected-label') === null || select.get('data-all-selected-label') != 0) && totalSelectionsLen > 0 && totalSelectionsLen <= currSelected.length) {
            placeholder = app.get('i18n').translate('all.selected', {'transform' : 'ucfirst'});

            if (cstConfig && cstConfig["labels"] && cstConfig["labels"]["all.selected"]) {
                placeholder = cstConfig["labels"]["all.selected"];

            	if (String.prototype.toUpperCaseFirst) {
            		placeholder = placeholder.toUpperCaseFirst();
            	}
            }
        }

        dummySelect.options[0].text = placeholder;

        self.labelWidthDiv.setStyle('display', 'none');
    }

    this.initSelects = function() {
        container.getElements('.chosen').each(function(natiSelect) {
            if (natiSelect.get('data-nati-select')) {
                return;
            }

            if (natiSelect.get('multiple')) {
                var dummySel = new Element('select', {
                    'html' : '<option value="">' + natiSelect.options[0].text + '</option>'
                });

                var atts = natiSelect.attributes;

                for (var i = 0; i < atts.length; i++) {
                    if (atts[i].nodeName.match(/^(multiple|id|name)$/)) {
                        continue;
                    }

                    dummySel.setAttribute(atts[i].nodeName, atts[i].nodeValue);
                }

                dummySel.store('org-select', natiSelect);

                dummySel.inject(natiSelect, 'after');

                self.createMultiLabel(natiSelect, dummySel);

                natiSelect.setStyle('display', 'none');

                natiSelect.removeClass('.chosen');

                natiSelect.store('dummy-select', dummySel);
            }

            natiSelect.set('data-nati-select', '1');
        });
    }

    this.setCloseLock = function(list, timeout) {
        timeout = timeout || 200;

        list.setAttribute('data-close-lock', '1');

        if (this.closeLockId) {
            window.clearTimeout(this.closeLockId);
        }

        this.closeLockId = window.setTimeout(function() {
            list.removeAttribute('data-close-lock');
        }, timeout);
    };

    this.closeNatiSelect = function(timeout, lists, target) {
       timeout = timeout || 100;
       lists   = lists || container.getElements('.nati-select-list');
       target  = target || null;

       window.setTimeout(function() {
           lists.each(function(el) {
              if (el.getAttribute('data-close-lock') || el.className.indexOf('hide') !== -1 || target === el) {
                  return;
              }

              el.addClass('hide');
              el.getElement('ul').addClass('hide');

              if (self.overlayBg && !self.overlayBg.get('data-close-lock')) {
                  self.overlayBg.addClass('hide');
                  self.overlayBg.retrieve('close-btn').addClass('hide');
              }
           });
       }.bind(this), timeout);
    }

    this.initHideSelects = function() {
        document.addEvent('mousedown', function(e) {
            var target = null;

            if (e && e.target && e.target.hasClass('chosen') && e.target.retrieve('list')) {
                target = e.target.retrieve('list');
            }


            self.closeNatiSelect(null, null, target);
        });
    }

    this.initResizeEvents = function() {
        var touchDevice = ('ontouchstart' in document.documentElement);

        window.addEvent('resize', function() {
            if (touchDevice) {
                return;
            }

            self.closeNatiSelect(0);
        });
    }

    this.initOpenSelects = function() {
        container.addEvent('mousedown:relay(.chosen)', function(e, select) {
            // stop open native events!
            e.preventDefault();
            this.blur();

            if (this.retrieve('list') && !this.retrieve('list').hasClass('hide')) {
                this.retrieve('list').addClass('hide');
                return;
            }

            if (select.retrieve('org-select')) {
                select = select.retrieve('org-select');
            }

			var currentSelectValue = select.get('value');

            // create list
            if (!this.retrieve('list')) {
                var content = '';

               if (this.get('data-select-search') == null || this.get('data-select-search') == '1') {
                   content += '<input type="text" value="" class="md-field" placeholder="' + app.get('i18n').translate('search') + '" />';

                   if (select.get('multiple')) {
                   	content += '<i class="material-icons" title="' + app.get('i18n').translate('show.only.selected.ones') + '">list</i>';
                   }
               }

                var styles = {
                    position : 'absolute'
                };

                if (this.get('data-z-index')) {
                    styles['z-index'] = this.get('data-z-index');
                }

               var list = new Element('div', {
                   'class'     : 'nati-select-list chzn-container',
                   'html'      : content,
                   'data-type' : select.get('multiple') ? 'multiple' : 'single',
                   'styles'    : styles
               })
               .store('select', select)
               .inject(document.body);

               if (select.get('data-group-select')) {
                   list.addClass('group-select');
               }

               this.store('list', list);

               if (select.get('multiple')) {
                   list.store('dummy-select', e.target);

                   select.store('list', list);
               }

               list.addEvent('mouseover', function(e) {
               		if (e.target && e.target.tagName === 'LI' && !e.target.get('title')) {
		            	e.target.set('title', e.target.get('text').trim());
		            }
               });
            }

            var coords = this.getCoordinates(),
                top    = coords.top + coords.height - 1,
                left   = coords.left,
                width  = coords.width,
                grid   = app.get('grid').getGrid(select);

            if (grid) {
                var browserName = grid.get('data-browser-name');

                if (browserName == 'Chrome') {
                    var table = grid.getElement('table'),
                        zoom  = parseFloat(table.getStyle('zoom'));

                    if (!isNaN(zoom)) {
                        top   *= zoom;
                        left  *= zoom;
                        width *= zoom;
                    }
                }
            }

            coords.top    = top;
            coords.left   = left;
            coords.width  = width;
            coords.height = 'auto';
            coords.bottom = 'auto';

            var currentWidth = coords.width;

            this.retrieve('list')
                .setStyles(coords)
                .removeClass('hide');


            if (window.innerWidth < self.modalThreshold) {
                this.retrieve('list').setStyles({
                    'left'    : (document.getWidth() / 2) - (this.retrieve('list').getCoordinates().width / 2) + 'px',
                    'z-index' : '10001'
                });
            }

            if (this.retrieve('list').retrieve('loader')) {
                this.retrieve('list').retrieve('loader').removeClass('hide');
            }

            if (!this.retrieve('list').getElement('ul')) {
               var content  = select.innerHTML;
               var optGroup = false;

               if (content.indexOf('</optgroup>') !== -1) {
                   content = content.replace(/<\/optgroup>/g, '');

                   content = content.replace(/<(optgroup.*?)>/gi, function (p) {
                       var label = p.match(/label="(.+?)"/);

                       if (label && label[1]) {
                           label = label[1];
                       } else {
                           label = '';
                       }

                       var cssClassMatch = p.match(/class="(.+?)"/);
                       cssClass = (cssClassMatch && cssClassMatch[1] !== '') ? ' ' + cssClassMatch[1] : '';

                       return p.replace(/optgroup/i, 'li class="group-result' + cssClass + '"') + label + '</li>';
                   });

                   optGroup = true;
               }

               content = content.replace(/\s*<\/?(option).*?>\s*/gi, function (p) {
                   p = p.trim();

                   var val = p.match(/value="(.+?)"|value=""/);
                   var cl  = '';

                   if (val && !select.get('multiple') && val[0].indexOf('value=""') !== -1) {
                       val[1] = 'dummy';
                   }

                   if (p.indexOf('disabled') !== -1) {
                       return p.replace(/option/, 'li class="hidden"');
                   }

                   if (!p.match(/^<\//) && val && val[1]) {
                        if (!val[1]) {
                            cl += ' group-result';
                        } else if (optGroup) {
                            cl += ' group-option';
                        }
                   }

                   if (p.indexOf('selected="') !== -1 || (val && currentSelectValue && val[1] == currentSelectValue)) {
                       cl += ' selected';
                   }

                   if (!select.get('multiple') && (p.indexOf('selected="') !== -1 || ((val && currentSelectValue && val[1] == currentSelectValue)))) {
                       cl += ' nati-selected';
                   }

	               if (this.get('data-chosen-hide-empty') && (!val || val[1] === 'dummy')) {
	               		cl += ' hide';
	               }

                   cl = cl.trim();

                   if (cl !== '' && p !== '</option>') {
                       p = p.replace(/>/, ' class="' + cl + '">');
                   }

                   return p.replace(/option/, 'li');
               }.bind(this));

               if (select.get('multiple')) {
                   content = content.replace(/<li[^>]+?value[^>]+?>/g, function (p) {
                       if (p.indexOf('group-result') !== -1) {
                           // is optgroup!
                           return p;
                       }

                       var checkbox = (p.indexOf('value=""') === -1) ? '<input type="checkbox" /> ' : '';

                       if (p.indexOf('selected="true"') !== -1 || p.indexOf('selected="selected"') !== -1) {
                            checkbox = checkbox.replace('/>', 'checked="true" />');
                       }

		               if (this.get('data-chosen-hide-empty') && checkbox === '') {
		               		p = p.replace(/>/, 'style="display:none">');
		               }

                       return p + checkbox;
                   }.bind(this));
               }

               content = '<ul class="chzn-results hide">' + content + '</ul>';

               this.retrieve('list').innerHTML = this.retrieve('list').innerHTML + content;

               this.fireEvent('open');

               this.retrieve('visibleItems', this.retrieve('list').getElements('li[class!="group-result"]').length);

               this.retrieve('list').store('loader', app.get('loader').add(this.retrieve('list'), false, 'micro'));

               this.retrieve('list').retrieve('loader').inject(this.retrieve('list'), 'bottom');

               if (self.xhr && select.retrieve('chosen-lazyload-callback')) {
               		var listHeight = 0;

	               this.retrieve('list').getElement('ul').addEventListener("scroll", function(e) {
		               	if (!listHeight) {
		               		listHeight = e.target.getCoordinates().height;
		               	}

		               	if (self.searchIsRunning) {
		               		return;
		               	}

		               	if (self.xhrItemThreshold > this.retrieve('visibleItems')) {
		               		return;
		               	}

		               	if (e.target.scrollTop + self.xhrThreshold > e.target.scrollHeight - listHeight) {
		               		select.retrieve('chosen-lazyload-callback').bind(this)();
		               	}
	               }.bind(this));
               }
            } else {
            	if (!select.get('multiple')) {
            		this.retrieve('list').getElement('ul').getElements('.selected').removeClass('selected').removeClass('nati-selected');

            		var currentListEl = this.retrieve('list').getElement('ul').getElement('[value="' + currentSelectValue + '"]');

					if (currentListEl) {
						currentListEl.addClass('nati-selected selected');
					}
            	}
            }

            select.fireEvent('nati-chzn-open', {});

            self.setCloseLock(this.retrieve('list'));

            if (this.get('data-select-search') == null || this.get('data-select-search') == '1') {
                window.setTimeout(function() {
                    if (window.innerWidth > self.modalThreshold) {
                        this.retrieve('list').getElement('[type="text"]').focus();
                    }
                }.bind(this), 150);
            }

            window.setTimeout(function() {
				this.retrieve('list').getElement('ul').removeClass('hide');

				if (currentWidth < 300) {
					this.retrieve('list').setStyle('width', 'auto');
				}

				this.retrieve('list').getElement('ul').setStyle('display', 'inline-block');

				// get listwidth with small buffer
				var listWidth = this.retrieve('list').getElement('ul').getCoordinates().width + 5;

				if (listWidth < currentWidth) {
					listWidth = currentWidth;
				}

				if (listWidth > 300 && currentWidth < 300) {
					listWidth = 300;
				}

				this.retrieve('list').getElement('ul').setStyle('display', '');

				if (listWidth >= 300 && listWidth !== currentWidth) {
					this.retrieve('list').setStyles({
						'width'		: 'auto',
						'min-width' : '300px',
						'max-width' : '500px',
						'right'		: 'auto'
					});
				} else {
					this.retrieve('list').setStyle('width', listWidth);
				}

                this.retrieve('list').retrieve('loader').addClass('hide');

                var coords  = this.retrieve('list').getCoordinates();
                var listTop = (coords.height + coords.top);

                if (listTop > (window.innerHeight + window.getScroll().y)) {
                    window.scrollTo(window.getScroll().x, listTop - window.innerHeight + 10);
                }

                var currentSelectLis = this.retrieve('list').getElementsByClassName('selected');

                if (currentSelectLis.length > 0) {
                	this.retrieve('list').getElement('ul').scrollTop = 0;

                	var containerCoords = this.retrieve('list').getElement('ul').getCoordinates();

                	this.retrieve('list').getElement('ul').scrollTop = currentSelectLis[0].getCoordinates().top - containerCoords.top - containerCoords.height / 2;
                }

                if (window.innerWidth < self.modalThreshold) {
                    if (!self.overlayBg) {
                        self.overlayBg = new Element('div', {
                            styles : {
                                position : 'fixed',
                                top      : '50px',
                                opacity  : '0.4',
                                left     : '0px',
                                'background-color' : '#000',
                                'z-index'          : '10000'
                            }
                        }).inject(document.body, 'bottom');

                        self.overlayBg.store('close-btn', new Element('a', {
                            html : '<i class="material-icons">close</i>',
                            'class' : 'btn btn-small',

                            styles : {
                                'border-radius' : '5px',
                                position : 'absolute',
                                'z-index' : '10002'
                            },

                            events : {
                                'click' : function(e) {
                                    e && e.stop();

                                    self.closeNatiSelect(0);
                                }
                            }
                        }).inject(document.body));
                    }

                    self.overlayBg.retrieve('close-btn').setStyles({
                        top   : (coords.top - 10) + 'px',
                        left  : (coords.left + coords.width - 15) + 'px'
                    }).removeClass('hide');

                    self.overlayBg.setStyles({
                        width  : document.getScrollWidth(),
                        height : document.getScrollHeight(),
                    }).removeClass('hide');

                    self.overlayBg.set('data-close-lock', '1');

                    window.setTimeout(function() {
                        self.overlayBg.removeAttribute('data-close-lock');
                    }, 150);
                }
            }.bind(this), 10);
        });
    }

    this.destroy = function(select) {
        if (!select) {
            return;
        }

        if (select.retrieve('list')) {
            select.retrieve('list').destroy();
            select.store('list', null);
        }

        if (select.retrieve('dummy-select')) {
            select.retrieve('dummy-select').store('list', null);
            self.createMultiLabel(select, select.retrieve('dummy-select'));
        }
    };

    this.update = function(select) {
        if (select.retrieve('list')) {
            select.retrieve('list').getElements('li').each(function(li) {
                var chkBox = li.getElement('input[type="checkbox"]');

                if (chkBox) {
                    if (chkBox.checked) {
                        li.addClass('selected');
                        chkBox.setAttribute('checked', 'true');

                        select.getElement('[value=' + li.getAttribute('value') + ']').checked = true;
                        select.getElement('[value=' + li.getAttribute('value') + ']').selected = true;
                    } else {
                        li.removeClass('selected');
                        chkBox.removeAttribute('checked');

                        select.getElement('[value=' + li.getAttribute('value') + ']').checked = false;
                        select.getElement('[value=' + li.getAttribute('value') + ']').selected = false;
                    }
                }
            });

            if (select.retrieve('dummy-select')) {
                self.createMultiLabel(select, select.retrieve('dummy-select'));
            }
        }
    }

    this.reset = function(select) {
        select.set('value', '');

        if (select.retrieve('list').retrieve('dummy-select')) {
            select.retrieve('list').getElements('.selected').each(function(opt) {
                var chkBox = opt.getElement('input[type="checkbox"]');

                chkBox.removeAttribute('checked');
                chkBox.checked = false;

                opt.removeClass('selected');
            });

            self.createMultiLabel(select, select.retrieve('list').retrieve('dummy-select'));
        }
    }

    this.initCheckOption = function() {
        container.addEvent('mousedown:relay(.nati-select-list)', function(e, target) {
            self.setCloseLock(target);
        });

        container.addEvent('click:relay(.nati-select-list)', function(e, target) {
            if (!e.target) {
                return;
            }

            var checkbox = false;
            if (e.target.hasClass('material-icons')) {
	    		if (!this.retrieve('no-entries-message')) {
	    			this.store('no-entries-message', new Element('li', {
						'class' : 'group-option hide',
						'text'  : app.get('i18n').translate('no.entries.selected')
					}).inject(this.getElement('ul'), 'bottom'));
				}

            	e.target.toggleClass('show-selected');

            	var showSelected = e.target.hasClass('show-selected');
            	var lis          = this.getElementsByTagName('li');
				var groups       = {};
				var groupI       = 0;
				var selEl        = null;

            	for (var i = 0; i < lis.length; i++) {
            		if (lis[i].getAttribute('value') == '' || lis[i].className.indexOf('no-results') !== -1) {
            			continue;
            		}

            		if (lis[i].className.indexOf('group-result') !== -1) {
            			groups[i] = 0;
            			groupI    = i;
            		}

            		if (!showSelected) {
            			lis[i].removeClass('hide');

            			if (!selEl && lis[i].className.indexOf('selected') !== -1) {
            				selEl = lis[i];
            			}
            			continue;
            		}

            		if (lis[i].className.indexOf('selected') === -1) {
            			lis[i].addClass('hide');
            			continue;
            		}

					if (lis[i].style.display === '') {
            			groups[groupI]++;
            		}

            		if (!selEl) {
            			selEl = lis[i];
            		}

                    if (!lis[i].style.length) {
                        lis[i].removeAttribute('style');
                    }
            	}

            	if (showSelected) {
            		var overallCount = 0;
            		Object.each(groups, function(count, grpKey) {
            			if (count === 0) {
            				return;
            			}

            			overallCount += count;

            			lis[grpKey].removeClass('hide');
            		});

            		if (overallCount === 0) {
            			this.retrieve('no-entries-message').removeClass('hide');
            		} else {
            			this.retrieve('no-entries-message').addClass('hide');
            		}
            	} else {
            		this.retrieve('no-entries-message').addClass('hide');
            	}

            	if (!selEl) {
            		selEl = lis[0];
            	}

				if (this.retrieve('list')) {
	            	this.retrieve('list').getElement('ul').scrollTop = 0;

	            	var containerCoords = this.retrieve('list').getElement('ul').getCoordinates();

	            	this.retrieve('list').getElement('ul').scrollTop = selEl.getCoordinates().top - containerCoords.top - containerCoords.height / 2;
				}

            	return;
            }

            if (e.target.hasClass('group-result')) {
            	// group select
                if (target.retrieve('select') && target.retrieve('select').get('data-group-select')) {
                    var sel = e.target.toggleClass('group-select');
                    var tmp = e.target.getNext();

                    sel = sel.hasClass('group-select');

                    do {
                        checkbox = tmp.getElement('[type="checkbox"]');

                        if (tmp.getStyle('display') == 'none' && sel) {
                        	checkbox = null;
                        }

                        if (checkbox) {
                            if (sel) {
                                checkbox.setAttribute('checked', true);
                                checkbox.checked = true;
                                tmp.addClass('selected');
                            } else {
                                checkbox.removeAttribute('checked');
                                checkbox.checked = false;
                                tmp.removeClass('selected');
                            }
                        }

                        tmp = tmp.getNext();
                    } while (tmp && !tmp.hasClass('group-result'));

                    self.createMultiLabel(target.retrieve('select'), target.retrieve('dummy-select'), target);
                }

                return;
            }

            if (e.target.tagName === 'LI' || e.target.tagName === 'EM') {
                e.target = (e.target.tagName === 'LI') ? e.target : e.target.parentNode;

                if (target.get('data-type') === 'single' && e.target.getAttribute('value') !== null) {
                    target.retrieve('select').set('value', e.target.getAttribute('value'));
                    target.addClass('hide');

                    target.getElements('.selected').removeClass('selected');
                    target.getElements('.nati-selected').removeClass('nati-selected');

                    e.target.addClass('selected');
                    e.target.addClass('nati-selected');

                    target.retrieve('select').fireEvent('change', {target:target.retrieve('select')});
                }

                if (target.get('data-type') === 'multiple') {
                    checkbox = e.target.getElement('[type="checkbox"]');
                }
            }

            if (checkbox || (e.target.tagName === 'INPUT' && e.target.get('type') === 'checkbox')) {
                var checked = !checkbox ? (!e.target.get('checked')) : checkbox.get('checked');

                e.target = !checkbox ? e.target.parentNode : e.target;
                checkbox = checkbox || e.target;

                if (checked) {
                    checkbox.removeAttribute('checked');
                    checkbox.checked = false;
                    e.target.removeClass('selected');
                } else {
                    checkbox.setAttribute('checked', true);
                    checkbox.checked = true;
                    e.target.addClass('selected');
                }

                self.createMultiLabel(target.retrieve('select'), target.retrieve('dummy-select'), target);
            }
        });
    }

    this.removeElements = function(select, ids) {
    	var selectedValue = select.get('value');

    	ids.each(function(id) {
    		this.removeElement(select, id);
    	}.bind(this));

    	if (selectedValue !== select.get('value')) {
    		select.fireEvent('change');
    	}
    }

    this.removeElement = function(select, id) {
    	if (select.retrieve('list').getElement('[value="' + id + '"]')) {
			select.retrieve('list').getElement('[value="' + id + '"]').destroy();
		}

		if (select.getElement('option[value="' + id + '"]')) {
			select.getElement('option[value="' + id + '"]').destroy();
		}
    }

    this.removeGroup = function(select, groupId) {
    	if (select.getElement('[data-id="' + groupId + '"]')) {
    		select.getElement('[data-id="' + groupId + '"]').destroy();
    	}

    	if (select.retrieve('list')) {
    		var groupElement = select.retrieve('list').getElement('.group-result[data-id="' + groupId + '"]');
    		var tmp = null;

    		do {
    			tmp = groupElement;

    			if (!groupElement) {
    				break;
    			}

    			groupElement = groupElement.getNext();

				if (tmp) {
    				tmp.destroy();
    			}

    			if (!groupElement || groupElement.hasClass('group-result')) {
    				break;
    			}
    		} while (groupElement);
    	}
    }

    this.createGroup = function(select, groupData) {
    	if (select.getElement('optgroup[data-id="' + groupData.id + '"]')) {
    		return;
    	}

    	var optGroup = new Element('optgroup', {
    		label     : groupData.label,
    		'data-id' : groupData.id,
    		'class'   : (groupData.hide_group) ? 'hide' : ''
    	}).inject(select, 'bottom');

    	if (!groupData.values || groupData.values.length === 0) {
    		return;
    	}

    	groupData.values.each(function(value) {
    		new Element('option', {
    			'value' : value.id,
    			'text'  : value.name
    		}).inject(optGroup);
    	});

		if (select.retrieve('dummy-select')) {
    		this.createMultiLabel(select, select.retrieve('dummy-select'));
   		}
    }

    this.createElement = function(select, newSelectValue, injectEl, rg) {
    	if (select.getElement('[value="' + newSelectValue.id + '"]')) {
    		return;
    	}

	    new Element('option', {
	        text  : newSelectValue.label,
	        value : newSelectValue.id
	    }).inject(select, 'bottom');

	    injectEl = (typeof injectEl === 'undefined' || !injectEl) ? select.retrieve('list').getElement('ul') : injectEl;

	    if (select.retrieve('list').getElement('[data-type="search-results"]')) {
	    	injectEl = select.retrieve('list').getElement('[data-type="search-results"]');
	    }

    	if (rg) {
			newSelectValue.label = newSelectValue.label.replace(rg, function (f) {
	            return (f !== '') ? '<em>' + f + '</em>' : '';
	        });
    	}

    	newSelectValue.label = newSelectValue.label.trim();

	    var liEl = new Element('li', {
	        'class' : (select.get('multiple') && injectEl.hasClass('group-result')) ? 'group-option' : 'result',
	        'html'  : (select.get('multiple')) ? '<input type="checkbox" /> ' + newSelectValue.label : newSelectValue.label
	    }).inject(injectEl, 'after');

	    liEl.setAttribute('value', newSelectValue.id);
    };

    this.useSearch = function(e, target) {
	    if (target.retrieve('nati-search') && target.retrieve('nati-search') === target.get('value').trim()) {
	        return;
	    }

	    self.searchIsRunning = true;

	    if (target.nsTID) {
	        window.clearTimeout(target.nsTID);
	    }

	    target.store('nati-search', target.get('value').trim());

	    var container  = target.getParent();
	    var list       = container.getElement('ul');
	    var searchStr  = target.get('value').trim().replace(/e/ig, '(?:e|è|é|ê|ë)');
	    var rg         = new RegExp(searchStr, 'i');
	    var p          = 0;
	    var lis        = list.getElementsByTagName('li');
	    var length     = lis.length;
	    var multi      = container.get('data-type') === 'multiple';
	    var searchSpeed = [1, 600];

	    if (length < 500) {
	        searchSpeed[0] = 0;
	        searchSpeed[1] = 100;
	    } else {
	        container.retrieve('loader').removeClass('hide');
	        list.addClass('hide');
	    }

	    var selIcon = target.getNext();

	    if (selIcon && selIcon.hasClass('material-icons')) {
	    	selIcon.removeClass('show-selected');
	    }

	    var searchCallback = function(afterSearchCb) {
	    	lis     = list.getElementsByTagName('li');
	    	length  = lis.length;

	        target.nsTID = window.setTimeout(function() {
	            var index   = 0;
	            var matches = 0;
	            var chkbox  = null;
	            var groups  = {};
	            var gIndex  = 0;

	            var search = function() {
	                for (; index < length; index++) {
	                	if (!lis[index]) {
	                		continue;
	                	}

	                	if (lis[index].get('data-chosen-highlight') == null) {
	                        if (lis[index].className.indexOf('group-result') === -1 && lis[index].className.indexOf('no-results') === -1) {
	                            iH = lis[index].textContent.replace(/<\/?em>/g, '');

	                            lis[index].style.display = 'none';

	                            if (iH.trim().match(rg)) {
	                                if (multi) {
	                                    chkbox = lis[index].innerHTML.match(/(<input.+?>)/);

	                                    if (chkbox && chkbox[1]) {
	                                        iH = iH.replace(chkbox[1], '');
	                                    } else {
	                                        chkbox = null;
	                                    }
	                                }

	                                iH = iH.replace(rg, function (f) {
	                                    return (f !== '') ? '<em>' + f + '</em>' : '';
	                                });

	                                if (chkbox) {
	                                    iH = chkbox[1] + ' ' + iH.trim();
	                                }

	                                lis[index].innerHTML = iH.trim();

	                                lis[index].style.display = '';

	                                matches++;

	                                if (gIndex in groups) {
	                                    groups[gIndex] += 1;
	                                }
	                            }
	                        } else {
	                            if (lis[index].className.indexOf('no-results') === -1) {
	                                groups[index] = 0;
	                                gIndex = index;
	                            }
	                        }
	                    }

	                    if (index + 1 === length) {
	                        container.retrieve('loader').addClass('hide');
	                        list.removeClass('hide');

	                        Object.each(groups, function(gMatch, gInd) {
	                            lis[gInd].style.display = (gMatch === 0) ? 'none' : '';

	                            lis[gInd].removeClass('group-select');
	                        });

	                        if (matches === 0) {
	                            if (!list.retrieve('no-result')) {
	                                list.store('no-result', new Element('li', {
	                                'class' : 'no-results'
	                                }).inject(list, 'top'));
	                            }

	                            list.retrieve('no-result')
	                                .set('html', '"' + target.get('value').trim() + '"')
	                                .removeClass('hide');
	                        } else {
	                            list.retrieve('no-result') && list.retrieve('no-result').addClass('hide');
	                        }

	                        if (typeof afterSearchCb === 'function') {
	                        	afterSearchCb();
	                        }
	                    }

	                    if (index + 1 < length && index % 100 == 0) {
	                        setTimeout(search, searchSpeed[0]);
	                    } else {
	                    	if (container.retrieve('select').retrieve('dummy-select')) {
								container.retrieve('select').retrieve('dummy-select').store('visibleItems', matches);
							}

	                    	self.searchIsRunning = false;
	                    }

	                    if (!lis[index].style.length) {
	                        lis[index].removeAttribute('style');
	                    }
	                }
	            };

	            search();
	        }, searchSpeed[1]);
	    }.bind(this);

	    if (container.retrieve('select') && container.retrieve('select').retrieve('chosen-search-callback')) {
	    	container.retrieve('select').retrieve('chosen-search-callback').bind(self)(target.get('value').trim(), container.retrieve('select'), list, container, searchCallback);
	    } else {
	    	searchCallback();
	    }
    };

    this.initSearch = function() {
    	var self = this;

        document.addEvent('keyup:relay(.nati-select-list input[type="text"])', function(e, target) {
        	self.useSearch(e, target);
        });
    }

    this.initSelects();

	if (!app.get('chosen-events-set')) {
	    this.initCheckOption();
	    this.initOpenSelects();
	    this.initHideSelects();
	    this.initSearch();
	    this.initResizeEvents();

        app.set('chosen-events-set', true);
    }
};


Chosen.prototype = {
	xhr       : true,
    self      : this,
    overlayBg : null,
    showEntries : false,
    xhrThreshold : 1000,
    xhrItemThreshold : 200,
    searchIsRunning : false,

    modalThreshold : 800,
    labelWidthDiv  : null
};

var ChosenTagging = function(container) {
	var self = this;

	this.init = function() {
		var clearResults = function(searchWrapper, select) {
	    	var nextResult = searchWrapper.getNext();
			var remove     = [];

	    	while (nextResult) {
	    		if (!select.get('multiple')) {
	    			if (select.get('value') == nextResult.get('value')) {
	    				nextResult = nextResult.getNext();
	    				continue;
	    			}

	    			if (nextResult.get('value') > 0) {
	    				remove.push(nextResult.get('value'));

	    				nextResult = nextResult.getNext();
	    			} else {
	    				break;
	    			}

	    			continue;
	    		}

	    		if (!nextResult.getElement('input[type="checkbox"]')) {
	    			nextResult = nextResult.getNext();
	    			continue;
	    		}

	    		if (!nextResult.getElement('input[type="checkbox"]').get('checked')) {
	    			remove.push(nextResult.getAttribute('value'));
	    		}

	     		nextResult = nextResult.getNext();

	    		if (!nextResult || nextResult.hasClass('group-result')) {
	    			break;
	    		}
	    	}

	    	app.get('chosen').removeElements(select, remove);
	    };

		container.getElements('select[data-tagging]').each(function(el) {
			if (!el.get('data-chosen-xhr-search')) {
				return;
			}

			el.set('data-all-selected-label', '0');

			new Element('optgroup', {
				'data-type' : 'search-results'
			}).inject(el, 'bottom');

			el.addClass('chosen');
		});

		app.get('chosen').initSelects();

		container.getElements('select[data-tagging]').each(function(el) {
			if (!el.get('data-chosen-xhr-search')) {
				return;
			}

			el.addEvent('open', function(e) {
				var searchWrapper = this.retrieve('list').getElement('[data-type="search-results"]');

				var select = this.retrieve('org-select') ? this.retrieve('org-select') : this;

				if (!select.retrieve('search-message')) {
					select.store('search-message', new Element('li', {
						'class' : (searchWrapper.hasClass('group-result')) ? 'group-option' : 'result',
						'text'  : app.get('i18n').translate('please.use.the.search')
					}).inject(searchWrapper.getParent(), 'bottom'));

					if (!searchWrapper.getNext().get('value')) {
						select.retrieve('search-message').removeClass('hide');
					} else {
						select.retrieve('search-message').addClass('hide');
					}
				}
			});

		    el.store('chosen-search-callback', function(search, select, list, container) {
                container.retrieve('loader').removeClass('hide');

                var searchWrapper = list;

                if (searchWrapper.getElement('[data-type="search-results"]')) {
                	searchWrapper = searchWrapper.getElement('[data-type="search-results"]');
                }

                container.retrieve('loader').removeClass('hide');

                var chosenObj = this;
                var url       = app.get('router').getWebhost() + '/api/search/tag/';

                if (this.tId) {
                	window.clearTimeout(this.tId);
                }

                if (search === '') {
                	if (this.request) {
                		this.request.cancel();
                	}

                	clearResults(searchWrapper, select);
                	container.retrieve('loader').addClass('hide');

        			if (!searchWrapper.getNext().getAttribute('value')) {
        				el.retrieve('search-message').removeClass('hide');
        			}

                	return;
                }

				this.tId = window.setTimeout(function() {
					this.request = new XmlHttpRequest.JSON({
						url : url,

						data : {
							search : search
						},

						onCancel : function() {
							clearResults(searchWrapper, select);
						},

						onComplete : function(rsp) {
							clearResults(searchWrapper, select);

							rsp.each(function(result) {
								chosenObj.createElement(select, {
									id    : result.id,
									label : result.name
								});
							});

                			if (!searchWrapper.getNext().getAttribute('value')) {
                				el.retrieve('search-message').removeClass('hide');
                			} else {
                				el.retrieve('search-message').addClass('hide');
                			}

							container.retrieve('loader').addClass('hide');
						}
					}).send();
				}.bind(this), 200);
		    });
		});
	}

	this.init();
};

var ChosenXhr = function() {
	var self = this;

	this.init = function(container) {
	    var clearResults = function(searchWrapper, select) {
	    	var nextResult = searchWrapper.getNext();
			var remove     = [];

	    	while (nextResult) {
	    		if (!select.get('multiple')) {

	    			if (select.get('value') == nextResult.getAttribute('value')) {
	    				nextResult = nextResult.getNext();
	    				continue;
	    			}

	    			if (nextResult.getAttribute('value') > 0 || (isNaN(parseInt(nextResult.getAttribute('value'))) && nextResult.getAttribute('value') !== "") ) {
	    				remove.push(nextResult.getAttribute('value'));

	    				nextResult = nextResult.getNext();
	    			} else {
	    				break;
	    			}

	    			continue;
	    		}

	    		if (!nextResult.getElement('input[type="checkbox"]')) {
	    			nextResult = nextResult.getNext();
	    			continue;
	    		}

	    		if (!nextResult.getElement('input[type="checkbox"]').get('checked')) {
	    			remove.push(nextResult.get('value'));
	    		}

	     		nextResult = nextResult.getNext();

	    		if (!nextResult || nextResult.hasClass('group-result')) {
	    			break;
	    		}
	    	}

	    	app.get('chosen').removeElements(select, remove);
	    };

		container.getElements('.chosen').each(function(el) {
			if (!el.get('data-chosen-xhr-search')) {
				return;
			}

			if (el.get('name') === 'mid') {
				el.addEvent('change', function() {
					var lineItemEl = container.getElement('[name="cid"]');
					var selected   = this.getElements('option:selected').get('value');

					if (!lineItemEl) {
						return;
					}

					lineItemEl && lineItemEl.getElements('optgroup').each(function(optGroup) {
						if (selected.indexOf(optGroup.get('data-id')) < 0) {
							app.get('chosen').removeGroup(lineItemEl, optGroup.get('data-id'));
						}
					});

					app.get('chosen').destroy(lineItemEl);

					if (selected.length === 0) {
						lineItemEl && lineItemEl.retrieve('dummy-select').addClass('hide');
						return;
					}

	                if (this.tId) {
	                	window.clearTimeout(this.tId);
	                }

	                var searchData = {
	                	mid : []
	                };

	                selected.each(function(selId) {
	                	// special case network-id
	                	if (selId.match(/^[0-9]/)) {
	                		searchData.mid.push(selId);
	                	} else {
	                		searchData.mid.push(selId.replace(/[^0-9]+/, ''));
	                	}
	                });

					this.tId = window.setTimeout(function() {
						this.request = new XmlHttpRequest.JSON({
							url : app.get('router').getWebhost() + '/api/search/line-item/',

							data : searchData,

							onCancel : function() {},

							onComplete : function(rsp) {
								rsp.each(function(result) {
									app.get('chosen').createGroup(lineItemEl, result);
								});

								lineItemEl && lineItemEl.retrieve('dummy-select').removeClass('hide');
							}
						}).send();
					}.bind(this), 200);
				});
			}

			if (el.get('name') === 'pid') {
				el.addEvent('change', function() {
					var adUnitEl = container.getElement('[name="aid"]');
					var selected = this.getElements('option[value!=""]:selected').get('value');

					if (!adUnitEl) {
						return;
					}

					adUnitEl && adUnitEl.getElements('optgroup').each(function(optGroup) {
						if (selected.indexOf(optGroup.get('data-id')) < 0) {
							app.get('chosen').removeGroup(adUnitEl, optGroup.get('data-id'));
						}
					});

					app.get('chosen').destroy(adUnitEl);

					if (selected.length === 0) {
						if (adUnitEl) {
							if (adUnitEl.retrieve('dummy-select')) {
								adUnitEl.retrieve('dummy-select').addClass('hide');
							}
						}

						return;
					}

	                if (this.tId) {
	                	window.clearTimeout(this.tId);
	                }

	                var searchData = {
	                	pid : [],
	                	nid : []
	                };

					var attrs    = this.attributes;

					for (var i = 0; i < attrs.length; i++) {
						if (!attrs[i] || !attrs[i].nodeName || attrs[i].nodeName.indexOf('data-chosen-xhr-search-') !== 0) {
							continue;
						}

						searchData[attrs[i].nodeName.replace(/^data-chosen-xhr-search-/, '')] = attrs[i].nodeValue;
					}

	                selected.each(function(selId) {
	                	// special case network-id
	                	if (selId.match(/^[0-9]/)) {
	                		searchData.pid.push(selId);
	                	} else {
	                		searchData.nid.push(selId.replace(/[^0-9]+/, ''));
	                	}
	                });

					this.tId = window.setTimeout(function() {
						this.request = new XmlHttpRequest.JSON({
							url : app.get('router').getWebhost() + '/api/search/ad-unit/',

							data : searchData,

							onCancel : function() {},

							onComplete : function(rsp) {
								rsp.each(function(result) {
									app.get('chosen').createGroup(adUnitEl, result);
								});

								if (adUnitEl) {
									if (adUnitEl.retrieve('dummy-select')) {
										adUnitEl.retrieve('dummy-select').removeClass('hide');
									}
								}
							}
						}).send();
					}.bind(this), 200);
				});
			}

			if (el.get('data-chosen-xhr-count') && el.get('data-chosen-xhr-count') < 50) {
				return;
			}

			var selCheck = el.retrieve('org-select') ? el.retrieve('org-select') : el;

			if ((!selCheck.get('multiple') && selCheck.getElements('option[value!=""]').length > 1) && selCheck.get('name') !== 'cid') {
				return;
			}

			el.addEvent('open', function(e) {
				var searchWrapper = this.retrieve('list').getElement('[data-type="search-results"]');

				var select = this.retrieve('org-select') ? this.retrieve('org-select') : this;

				if (!select.retrieve('search-message')) {
					select.store('search-message', new Element('li', {
						'data-chosen-highlight' : '0',
						'class' : (searchWrapper.hasClass('group-result')) ? 'group-option' : 'result',
						'text'  : app.get('i18n').translate('please.use.the.search')
					}).inject(searchWrapper.getParent(), 'bottom'));

					if (!searchWrapper.getNext().get('value')) {
						select.retrieve('search-message').removeClass('hide');
					} else {
						select.retrieve('search-message').addClass('hide');
					}
				}
			});

			var postData = {};
			var attrs    = el.attributes;

			for (var i = 0; i < attrs.length; i++) {
				if (!attrs[i] || !attrs[i].nodeName || attrs[i].nodeName.indexOf('data-chosen-xhr-search-') !== 0) {
					continue;
				}

				postData[attrs[i].nodeName.replace(/^data-chosen-xhr-search-/, '')] = attrs[i].nodeValue;
			}

		    el.store('chosen-search-callback', function(search, select, list, container, searchCb) {
	            container.retrieve('loader').removeClass('hide');

	            if (select.get('data-ignore-chosen-search-cb')) {
	            	searchCb = function() {};
	            }

	            var searchWrapper = list;

	            if (searchWrapper.getElement('[data-type="search-results"]')) {
	            	searchWrapper = searchWrapper.getElement('[data-type="search-results"]');
	            }

				var attrs    = searchWrapper.attributes;

				for (var i = 0; i < attrs.length; i++) {
					if (!attrs[i] || !attrs[i].nodeName || attrs[i].nodeName.indexOf('data-chosen-xhr-search-') !== 0) {
						continue;
					}

					postData[attrs[i].nodeName.replace(/^data-chosen-xhr-search-/, '')] = attrs[i].nodeValue;
				}

	            container.retrieve('loader').removeClass('hide');

	            var chosenObj = this,
	                url       = app.get('router').getWebhost() + '/api/search/';

	            if (select.get('data-url')) {
	                url = select.get('data-url');
	            } else {
                    switch (select.get('name')) {
                        case 'pid':
                            url += 'website/';
                            break;

                        case 'cid':
                        case 'campaign_id':
                        case 'mid':
                            url += 'campaign/';
                            break;

                        case 'account_id':
                        case 'account_ids[]':
                            url += 'account/';
                            break;

                        case 'account_approval[]':
                            if (app.get('router').getController() == 'dmp') {
                                url += 'dmp-account-approval/id/' + app.get('router').getParam('id');
                            }
                            break;
                    }
	            }

	            if (this.tId) {
	            	window.clearTimeout(this.tId);
	            }

	            if (search === '') {
	            	if (this.request) {
	            		this.request.cancel();
	            	}

	            	clearResults(searchWrapper, select);
	            	container.retrieve('loader').addClass('hide');

	    			if (!searchWrapper.getNext().get('value') || searchWrapper.getNext().get('value') == '0') {
	    				el.retrieve('search-message').removeClass('hide');
	    			}

	    			searchWrapper.getParent().removeClass('hide');

	            	searchCb(function() {
	    				if (el.retrieve('search-message').getPrevious()) {
	    					el.retrieve('search-message').getPrevious().setStyle('display', '');
	    				}
	            	});
	            	return;
	            }

				this.tId = window.setTimeout(function() {
					postData['search'] = search;

					this.request = new XmlHttpRequest.JSON({
						url : url,

						data : postData,

						onCancel : function() {
							clearResults(searchWrapper, select);
						},

						onComplete : function(rsp) {
							clearResults(searchWrapper, select);

            				var rg = new RegExp(search, 'i');

							rsp.reverse().each(function(result) {
								chosenObj.createElement(select, {
									id    : result.id,
									label : result.name
								}, null, rg);
							});

	            			if (el.retrieve('search-message') && search != '') {
	            				el.retrieve('search-message').addClass('hide');
	            			}

	            			searchCb();

							container.retrieve('loader').addClass('hide');
						}
					}).send();
				}.bind(this), 200);
		    });
		});
	};
};

var Draggable = function(element, options) {
	var self = this;

    this.init = function() {
        this.element         = element,
        this.options         = options || {},
        this.dragContainer   = element.getElement('.mt-drag-container'),
        this.drag            = this.dragContainer.getElement('.mt-drag'),
        this.dragDroppables  = this.dragContainer.getElements('.mt-drag-drop'),
        this.dragMove        = this.dragContainer.getElement('.mt-drag-move'),
        this.dragResize      = this.dragContainer.getElement('.mt-drag-resize'),
        this.dragSize        = this.dragContainer.getElement('.mt-drag-size'),
        this.dragEdgeLeft    = this.dragContainer.getElement('.mt-drag-edge-left'),
        this.dragEdgeRight   = this.dragContainer.getElement('.mt-drag-edge-right'),
        this.dragEdgeTop     = this.dragContainer.getElement('.mt-drag-edge-top'),
        this.dragEdgeBottom  = this.dragContainer.getElement('.mt-drag-edge-bottom'),
        this.aspectRatio     = (typeof this.options.aspectRatio != 'undefined') ? this.options.aspectRatio : false,
        this.left            = (typeof this.options.cropLeft != 'undefined') ? this.options.cropLeft : this.getPosition().x,
        this.top             = (typeof this.options.cropTop != 'undefined') ? this.options.cropTop : this.getPosition().y,
        this.width           = (typeof this.options.cropWidth != 'undefined') ? this.options.cropWidth : this.getSize().x,
        this.height          = (typeof this.options.cropHeight != 'undefined') ? this.options.cropHeight : this.getSize().y,
        this.containerWidth  = (typeof this.options.width != 'undefined') ? this.options.width : this.getContainerSize().x,
        this.containerHeight = (typeof this.options.height != 'undefined') ? this.options.height : this.getContainerSize().y;

        this.checkScale();
        this.createMovable();
        this.createResizable();

        window.addEvent('resize', function(e) {
            self.checkScale();
        });
    };

    this.getPosition = function() {
        return this.drag.getPosition(this.dragContainer);
    };

    this.getSize = function() {
        return this.drag.getSize();
    };

    this.getContainerSize = function() {
        return this.dragContainer.getSize();
    };

    this.setSizeInfo = function() {
        if (this.dragSize) {
            this.dragSize.set('html', this.width + 'x' + this.height);
        }
    };

    this.setLeft = function(left) {
        if (typeof left != 'undefined' && left !== null && left !== false) {
            this.left = left;
            this.drag.setStyle('left', this.left);
        }
    };

    this.setTop = function(top) {
        if (typeof top != 'undefined' && top !== null && top !== false) {
            this.top = top;
            this.drag.setStyle('top', this.top);
        }
    };

    this.setPosition = function(left, top) {
        this.setLeft(left);
        this.setTop(top);
    };

    this.setWidth = function(width) {
        if (typeof width != 'undefined' && width !== null && width !== false) {
            this.width = width;
            this.drag.setStyle('width', this.width);
            self.setSizeInfo();
        }
    };

    this.setHeight = function(height) {
        if (typeof height != 'undefined' && height !== null && height !== false) {
            this.height = height;
            this.drag.setStyle('height', this.height);
            self.setSizeInfo();
        }
    };

    this.setSize = function(width, height) {
        this.setWidth(width);
        this.setHeight(height);
    };

    this.checkScale = function() {
        var factor  = (this.containerWidth > 0) ? this.getContainerSize().x / this.containerWidth : 0,
            resizer = this.drag.retrieve('resizer');

        this.setPosition(this.left * factor, this.top * factor);
        this.setSize(this.width * factor, this.height * factor);

        this.containerWidth  = this.getContainerSize().x;
        this.containerHeight = this.getContainerSize().y;

        if (resizer) {
            resizer.setOptions({
                limit: {
                    x: [0, self.containerWidth - self.left],
                    y: [0, self.containerHeight - self.top]
                }
            });
        }

        this.checkSize();
    };

    this.checkSize = function() {
        var minWidth  = 30,
            minHeight = 30;

        if (this.aspectRatio) {
            minWidth  = minHeight * this.aspectRatio;
            minHeight = minWidth / this.aspectRatio;

            // check aspect ratio, adjust height
            this.setHeight(this.getSize().x / this.aspectRatio);

            // check max boundaries
            if (this.getPosition().y + this.getSize().y > this.getContainerSize().y) {
                this.setHeight(this.getContainerSize().y - this.getPosition().y);
                this.setWidth(this.getSize().y * this.aspectRatio);
            }

            if (this.getPosition().x + this.getSize().x > this.getContainerSize().x) {
                this.setWidth(this.getContainerSize().x - this.getPosition().x);
                this.setHeight(this.getSize().x / this.aspectRatio);
            }
        }

        // check min boundaries
        if (this.getSize().x < minWidth) {
            this.setWidth(minWidth);
        }

        if (this.getSize().y < minHeight) {
            this.setHeight(minHeight);
        }

        this.setSizeInfo();

        this.dragEdgeLeft.setStyles({
            right: this.getContainerSize().x - this.getPosition().x
        });

        this.dragEdgeRight.setStyles({
            left: this.getPosition().x + this.getSize().x
        });

        this.dragEdgeTop.setStyles({
            left:   this.getPosition().x,
            right:  this.getContainerSize().x - this.getPosition().x - this.getSize().x,
            bottom: this.getContainerSize().y - this.getPosition().y
        });

        this.dragEdgeBottom.setStyles({
            left:  this.getPosition().x,
            right: this.getContainerSize().x - this.getPosition().x - this.getSize().x,
            top:   this.getPosition().y + this.getSize().y
        });
    };

    this.createMovable = function() {
        this.drag.makeDraggable({
            container:  self.dragContainer,
            handle:     self.dragMove,
            droppables: self.dragDroppables,
            snap:       0,

            onDrag: function(element) {
                self.setPosition(self.getPosition().x, self.getPosition().y);
                self.checkSize();
            },

            onDrop: function(element, droppable) {
                self.drag.retrieve('resizer').setOptions({
                    limit: {
                        x: [0, self.getContainerSize().x - self.getPosition().x],
                        y: [0, self.getContainerSize().y - self.getPosition().y]
                    }
                });
            }
        });
    };

    this.createResizable = function() {
        this.drag.makeResizable({
            container: self.dragContainer,
            handle:    self.dragResize,
            snap:      0,

            onDrag: function(element) {
                self.setSize(self.getSize().x, self.getSize().y);
                self.checkSize();
            },

            limit: {
                x: [0, self.getContainerSize().x - self.getPosition().x],
                y: [0, self.getContainerSize().y - self.getPosition().y]
            }
        });
    };

    this.init();

    return this;
};

var Ellipsis = function() {
    var self = this;

    this.observer = new ResizeObserver(function(entries, observer) {
        entries.forEach(function(entry) {
            var container = entry.target.__nativendoContainer__,
                content   = entry.target.__nativendoContent__,
                breakWord = content.__nativendoBreakWord__;

            self.truncate(container, content, breakWord);
        });
    });
};

Ellipsis.prototype = {
    isTextOverflowing: function(element) {
        var currentStyle = {
            'overflow'   : element.style['overflow'],
            'overflow-y' : element.style['overflow-y'],
            'max-height' : element.style['max-height'],
            'height'     : element.style['height']
        };

        // Get scroll height because element.scrollHeight is buggy
        element.style.setProperty('overflow-y', 'visible', 'important');
        element.style.setProperty('max-height', 'none', 'important');
        element.style.setProperty('height', 'auto', 'important');

        var scrollHeight = element.clientHeight;

        element.style.setProperty('overflow-y', currentStyle['overflow-y']);
        element.style.setProperty('max-height', currentStyle['max-height']);
        element.style.setProperty('height', currentStyle['height']);

        // Check dimensions
        element.style.setProperty('overflow', 'hidden', 'important');

        var isOverflowing = /*element.clientWidth < element.scrollWidth ||*/ element.clientHeight < scrollHeight;

        element.style.setProperty('overflow', currentStyle['overflow']);

        return isOverflowing;
    },

    truncate: function(container, content, breakWord) {
        var self = this;

        if (!container) {
            return;
        }

        var content = content || container;

        if (content.__nativendoTruncateText__) {
            content.innerText = content.__nativendoTruncateText__;
        } else {
            content.__nativendoTruncateText__ = content.innerText;
        }

        var textLen          = content.innerText.length,
            breakWord        = breakWord || false,
            ellipsis         = " ...",
            wordDelimiter    = " ",
            maxCount         = 1000,
            ellipsisLen      = ellipsis.length,
            wordDelimiterLen = wordDelimiter.length;

        if (self.isTextOverflowing(container)) {
            var counter = 0;

            while (self.isTextOverflowing(container) && textLen > 0 && counter < maxCount) {
                counter++;
                textLen--;

                content.innerText = content.innerText.substring(0, textLen);
            }

            var text = content.innerText;

            if (!breakWord) {
                var maxLen           = textLen,
                    wordDelimiterPos = -1,
                    counter          = 0;

                do {
                    counter++;
                    wordDelimiterPos = text.lastIndexOf(wordDelimiter, textLen - wordDelimiterLen);

                    if (wordDelimiterPos > -1) {
                        text    = text.substring(0, wordDelimiterPos);
                        textLen = text.length;
                    }
                } while (wordDelimiterPos > -1 && wordDelimiterPos > maxLen - ellipsisLen && counter < maxCount);
            } else {
                text = text.substring(0, text.length - ellipsisLen);
            }

            if (text.length > 0) {
                text += ellipsis;
            }

            content.innerText = text;
        }
    },

    truncateOnLoad: function(container, content, images, breakWord) {
        var self = this;

        if (!container) {
            return;
        }

        var content = content || container;
            doc     = container.ownerDocument,
            win     = doc.defaultView || doc.parentWindow;

        content.__nativendoBreakWord__ = breakWord;
        content.__nativendoContainer__ = container;
        content.__nativendoContent__   = content;

        win.addEventListener('load', function() {
            self.truncate(container, content, breakWord);
        });

        win.addEventListener('resize', function() {
            self.truncate(container, content, breakWord);
        });

        images.forEach(function(image) {
            image.addEventListener('load', function() {
                self.truncate(container, content, breakWord);
            });

            if (!image.__nativendoObserveResize__) {
                image.__nativendoContainer__     = container;
                image.__nativendoContent__       = content;
                image.__nativendoObserveResize__ = true;

                self.observer.observe(image);
            }
        });

        if (!content.__nativendoObserveResize__) {
            content.__nativendoObserveResize__ = true;

            self.observer.observe(content);
        }

        if (!container.__nativendoObserveResize__) {
            container.__nativendoContainer__     = container;
            container.__nativendoContent__       = content;
            container.__nativendoObserveResize__ = true;

            self.observer.observe(container);
        }

        self.truncate(container, content, breakWord);
    }
};


var Grid = function() {};

Grid.prototype = {
	isLoading: false,
	currentFilterEl : false,
	order : {},
	page  : {},
    callbacks : {},

	initialize: function(selector) {
		var grids = $$(selector);

		this.addEventDelegation();

		grids.each(function(grid) {
			if (grid.get('data-lazy-load') == '1') {
				this.reload(null, grid);
			}
		}.bind(this));
	},

	addEventDelegation: function() {
		// reload event
		document.addEvent('click:relay(.mt-grid-table .mt-grid-refresh)', this.reload.bind(this));

		// reload event for change dataset count
		document.addEvent('change:relay(.mt-grid-table .datasets-per-page)', this.reload.bind(this));

		// remove filters
		document.addEvent('click:relay(.mt-grid-table a.remove-filters)', this.removeFilters.bind(this));

		// filterElement store
		document.addEvent('focus:relay(.mt-grid-table input, .mt-grid-table select)', this.storeFilterEl.bind(this));

		// reload event, sort action
		document.addEvent('click:relay(.mt-grid-table thead th[data-column])', this.sort.bind(this));

		// customize event
		document.addEvent('mousedown:relay(.mt-grid-table .mt-grid-customize)', this.customize.bind(this));

		// export event
		document.addEvent('click:relay(.mt-grid-table .mt-grid-export)', this.export.bind(this));

		// row action event
		document.addEvent('click:relay(.mt-grid-table .mt-row-actions a)', this.rowAction.bind(this));

		// pagination event
		document.addEvent('click:relay(.mt-grid-table .pagination a)', this.pagination.bind(this));

        // select all event
        document.addEvent('click:relay(.mt-grid-table .grid-select-all)', this.selectAll.bind(this));

        // select row event
        document.addEvent('click:relay(.mt-grid-table .grid-select-row)', this.selectRow.bind(this));

        // select xhr action select event
        document.addEvent('change:relay(.mt-grid-table .grid-xhr-action-select)', this.xhrActionSelect.bind(this));

        // select xhr action excution event
        document.addEvent('click:relay(.mt-grid-table .grid-xhr-action-execute)', this.xhrActionExecute.bind(this));

        // reload event for zoom change
        document.addEvent('change:relay(.mt-grid-table .grid-zoom)', this.reload.bind(this));
	},

	removeFilters : function(e, grid) {
		e && e.stop();

		if (!grid.hasClass('mt-grid-table')) {
			grid = grid.getParent('.mt-grid-table');
		}

		grid.getElements('[name^="filters"]').set('value', '');

		this.reload(null, grid);
	},

	storeFilterEl : function(e, target) {
		this.currentFilterEl = target;
	},

    getId : function(el) {
        return this.getValue(el, 'grid_id');
    },

    getRowCount : function(el) {
        return parseInt(this.getValue(el, 'grid_total_rows'));
    },

	getValue : function(el, key) {
	    var field = this.getGrid(el).getElement('[name="' + key + '"]');

	    return (field) ? field.get('value') : null;
	},

    getGrid : function(el) {
        // Get grid by id if string is given
        if (typeof el == 'string') {
            el = document.getElement('[name="grid_id"][value="' + el + '"]');
        }

        if (!el) {
            return null;
        }


        if (!el.hasClass('mt-grid-table')) {
            el = el.getParent('.mt-grid-table');
        }

        return el;
    },

    updateOrder : function(gridId, th) {
    	var grid = this.getGrid(th ? th : gridId);

    	if (!grid) {
    		return;
    	}

    	if (!th) {
    		th = grid.getElement('thead th[data-order]');
    	}

    	this.order[this.getId(grid)] = (th && th.get('data-order')) ? '&order[' + th.get('data-column') + ']=' + th.get('data-order') : '';
    },

    updatePage : function(gridId, link) {
    	var grid = this.getGrid(link ? link : gridId);

    	if (!grid) {
    		return;
    	}

    	if (!link) {
    		link = grid.getElement('.pagination .active a');
    	}

		this.page[this.getId(grid)] = (link) ? '&page=' + link.get('href').replace(/.+?page|[^0-9]+/g, '') : '';
    },

	sort : function(e, th) {
		th.set('data-order', (!th.get('data-order') || th.get('data-order') === 'DESC' ? 'ASC' : 'DESC'));

		this.updateOrder(null, th);

		this.reload(null, th);
	},

	pagination : function(e, link) {
		e && e.stop();

		if (!link.get('href')) {
			return;
		}

		this.updatePage(null, link);

		this.reload(null, link);
	},

    rowAction : function(e, target) {
        var confirmText = app.get('i18n').translate('are.you.sure.row.action'),
            conf        = target.get('data-confirm'),
            self        = this,
            grid        = self.getGrid(target);

        if (conf) {
            if (conf != "1") {
                confirmText = conf;
            }
        }

        if (!conf || confirm(confirmText)) {
            if (target.hasClass('mt-xhr')) {
                e && e.stop();

		        self.isLoading = true;

		        var loader = app.get('loader').add(grid);

                new XmlHttpRequest.JSON({
                    'url' : target.get('href'),

                    'onError' : function() {
                    	self.isLoading = false;

                    	loader.destroy();
                    },

                    'onSuccess': function(response) {
                    	self.isLoading = false;

                    	loader.destroy();

		                var callbacks = self.getCallbacks(self.getId(target), 'xhr-action');

						Object.each(callbacks, function(callback, identifier) {
						    (callback.bind(self.getGrid(target)))(response);
						});

                        if (response && response.status == 'success') {
                            self.reload(null, target);
                        } else {
                            //@todo : show error
                        }
                    }
                }).send();
            }
        } else {
            e && e.stop();
        }
    },

    selectAll : function(e, target) {
        var self      = this,
            grid      = self.getGrid(target),
            selectAll = grid.getElements('.grid-select-all'),
            selectRow = grid.getElements('.grid-select-row'),
            checked   = target.get('checked');

            selectAll.set('checked', checked);
            selectRow.set('checked', checked);
    },

    selectRow : function(e, target) {
        var self      = this,
            grid      = self.getGrid(target),
            selectAll = grid.getElements('.grid-select-all'),
            checked   = target.get('checked');

            if (!checked) {
                selectAll.set('checked', checked);
            }
    },

    xhrActionSelect : function(e, target) {
        var self             = this,
            grid             = self.getGrid(target),
            xhrActionSelect  = grid.getElements('.grid-xhr-action-select'),
            xhrActionExecute = grid.getElements('.grid-xhr-action-execute'),
            value            = target.get('value');

            xhrActionSelect.set('value', value);

            target.getSelected('option').each(function(option) {
                var href    = option.get('data-href'),
                    target  = option.get('data-target');

                xhrActionExecute.set('href', (href) ? href : '#');
                xhrActionExecute.set('target', (target) ? target : null);
                xhrActionExecute.set('data-select', option.get('data-select'));
                xhrActionExecute.set('data-xhr', option.get('data-xhr'));
                xhrActionExecute.set('value', option.get('data-confirm'));
            });
    },

    initDatasetEditModal : function(target, href, rsp) {
		target.set('data-modal-prepare-content', '1');

		app.get('modal').open(target);

		app.get('modal').init(null, rsp, '', href);

		var modal = app.get('modal').getCurrent();

		modal.set('destroy-on-close', '1');

		var modalForm         = modal.getElement('form');
		var defaultFormAction = modalForm.get('action');
		var modalEditIds      = modalForm.getElement('[name="ids"]').get('value').split(',');

        if (modalForm.hasClass('grid-dataset-edit')) {
    		modalForm.getElement('.modal-content').getElements('textarea, input, select').set('disabled', true);

    		modalForm.getElements('.flex-wrapper').each(function(flexWrapper) {
    			var leftAddon = flexWrapper.getElement('[data-addon-field]');

    			if (!leftAddon) {
    				return;
    			}

    			leftAddon.set('html', '');

    			var editElements = flexWrapper.getElements('input, textarea, select');
    			var chkBoxId     = editElements.get('id').join('-') + '-activate';

    			var activateCheckbox = new Element('div', {
    				'class' : 'md-checkbox',
    				'html'  : '<input type="checkbox" id="' + chkBoxId + '" class="md-checkbox-input" /><label for="' + chkBoxId + '" class="md-checkbox-label" />'
    			});

    			activateCheckbox.getElement('input').addEvent('change', function() {
    				if (this.get('checked')) {
    					editElements.removeProperty('disabled');
    				} else {
    					editElements.set('disabled', 'true');
    				}
    			});

    			activateCheckbox.inject(leftAddon);
    		});
        }

		var totalDatasets = modalEditIds.length;

		var changeFormAction = function() {
			modalForm.set('action', modalForm.get('action').replace(/[0-9]+$/, modalEditIds[0]));

			delete modalEditIds[0];

			modalEditIds = modalEditIds.clean();
		}

		changeFormAction();

		modalForm.store('before_send_callback', function() {
			var alertMessage = modalForm.getElement('.alert-message');

			if (!alertMessage.retrieve('wait-msg')) {
				alertMessage.store('wait-msg', alertMessage.get('html'));
			}

			alertMessage.set('html', alertMessage.retrieve('wait-msg')  + ' (' + app.get('i18n').translate('x.processed.datasets', [], [(totalDatasets - modalEditIds.length) + ' / ' + totalDatasets]) + ')');
		});

		modalForm.store('xhr-form-progress', true);

		modalForm.store('success_callback', function(rsp) {
			if (modalEditIds.length > 0) {
				if (modalEditIds.length == 1) {
					modalForm.store('xhr-form-progress', false);
				}

				modalForm.removeClass('mt-lock');

				changeFormAction();
				modalForm.getElement('[type="submit"]').click();
				return;
			}

            app.get('xhrForm').setStatus(modalForm, app.get('i18n').translate('the.datasets.was.saved.edit'), 'success');

	    	var grid = modal.retrieve('modal.trigger').getParent('.mt-grid-table');

	    	grid && app.get('grid').reload(null, grid);

	        (function() {
	            app.get('xhrForm').unsetLoader(modalForm);
	            app.get('modal').close(modal);
	        }).delay(1500);
		});
    },

    xhrActionExecute : function(e, target) {
        var self         = this,
            grid         = self.getGrid(target),
            href         = target.get('href'),
            select       = target.get('data-select'),
            confirmation = target.get('data-confirm'),
            xhr          = target.get('data-xhr'),
            selected     = grid.getElements('.grid-select-row:checked'),
            data         = {};

        if (self.isLoading || !href || href == '#') {
            e && e.stop();
            return;
        }

        if (select && !selected.length) {
            e && e.stop();
            alert(app.get('i18n').translate('please.select.at.least.one.data.set'));
            return;
        } else {
            data.ids = selected.get('value');
        }

        if (confirmation && !confirm(confirmation)) {
            e && e.stop();
            return;
        }

        if (!xhr) {
            return;
        }

        e && e.stop();

        self.isLoading = true;

        var loader = app.get('loader').add(grid);

        new XmlHttpRequest({
            url    : href,
            method : 'post',
            data   : data,

            onError : function() {
                alert(app.get('i18n').translate('unknown.error.occurred'));
                self.isLoading = false;
                loader.destroy();
            },

            onTimeout : function() {
                alert(app.get('i18n').translate('unknown.error.occurred'));
                self.isLoading = false;
                loader.destroy();
            },

            onFailure : function() {
                alert(app.get('i18n').translate('unknown.error.occurred'));
                self.isLoading = false;
                loader.destroy();
            },

            onSuccess : function(rsp) {
            	var json = null;

            	try {
            		json = JSON.decode(rsp);
            	} catch (err) {
            		json = null;
            	}

                self.isLoading = false;
                loader.destroy();

            	if (!json) {
            		self.initDatasetEditModal(target, href, rsp);
					return;
            	}

                var callbacks = self.getCallbacks(self.getId(target), 'xhr-action-select');

				Object.each(callbacks, function(callback, identifier) {
				    (callback.bind(grid))(json);
				});

                if (!json.status || json.status != 'success') {
                    alert(app.get('i18n').translate((json.message) ? json.message : 'unknown.error.occurred'));
                    return;
                }

                self.reload(null, grid);
            }
        }).send();
    },

	export : function(e, target) {
		var self = this;

		e && e.stop();

		if (target.getStyle('color') === 'transparent') {
			return;
		}

		target.setStyle('color', 'transparent');

        var loader = app.get('loader').add(target, false, 'micro');

        loader.setStyles({
           'display'       : 'inline-block',
           'position'      : 'absolute',
           'top'           : '4px',
           'right'         : '0px',
           'padding-right' : '10px'
        });

		var grid = target;

		if (!grid.hasClass('mt-grid-table')) {
			grid = grid.getParent('.mt-grid-table');
		}

		var exportUrl = location.href.split('#')[0];
		var gridId    = self.getId(grid);

		exportUrl += ((exportUrl.indexOf('?') === -1) ? '?' : '&') + 'export=excel&' + self.prepareData(grid, true, false);

		//check filters
		var params    = String.parseQueryString(self.prepareData(grid, true, false));
		var useFilter = false;

		Object.each(params, function(paramValue, paramKey) {
			if (paramKey.match(/^filters/) && !useFilter && paramValue != '') {
				useFilter = true;
			}
		});

		if (useFilter) {
			alert(app.get('i18n').translate('please.notice.filtered.dataset.are.exported'));
		}

        new XmlHttpRequest.JSON({
			url  : exportUrl,

			onError : function() {
				loader.destroy();
				target.setStyle('color', '');
			},

			onComplete : function(rsp) {
				location.href = exportUrl + '&file=' + rsp.file;

				loader.destroy();
				target.setStyle('color', '');
			}
        }).send();
	},

	prepareData: function(grid, addOrder, addPage) {
		var self   = this;
		var form   = grid.getElement('form');
		var gridId = self.getId(grid);

		var formData = form.toQueryString();

		if (typeof addOrder === 'undefined' || addOrder) {
			if (!self.order[gridId]) {
				self.updateOrder(gridId);
			}

			formData += self.order[gridId];
		}

		if (typeof addPage === 'undefined' || addPage) {
			if (!self.page[gridId]) {
				self.updatePage(gridId);
			}

			formData += self.page[gridId];
		}

		return formData;
	},

	reload: function(e, target) {
		var self = this;

		e && e.stop();

		if (self.isLoading) {
			return false;
		}

		var grid = target;

		if (!grid.hasClass('mt-grid-table')) {
			grid = grid.getParent('.mt-grid-table');
		}

		if (!grid) {
			return false;
		}

		var loader = app.get('loader').add(grid),
		    form        = grid.getElement('form'),
		    gridId      = self.getId(grid),
		    refreshBtns = form.getElements('.mt-grid-refresh');

		if (target && (target.hasClass('mt-grid-refresh') || target.hasClass('datasets-per-page'))) {
			self.page[gridId] = '&page=1';
		}

		var cursorPosition = self.currentFilterEl ? self.currentFilterEl.selectionStart : 0;
		var gridUrl        = location.href;

		if (String(form.get('action')) != '') {
			gridUrl = form.get('action');
		}

		new XmlHttpRequest.HTML({
			url  : gridUrl,
			data : self.prepareData(grid),

			onRequest: function() {
				self.isLoading = true;
				refreshBtns.getElement('i').addClass('spin');
			},

			onComplete: function(html, b, c, d) {
			    loader.destroy();
				self.isLoading = false;
				refreshBtns.getElement('i').removeClass('spin');

				var container = grid.getParent();

				html[0].replaces(grid);
				grid = self.getGrid(gridId);

                new Chosen(container);
                new PickerDate(container);

				if (self.currentFilterEl) {
					var newFilterEl = container.getElement('[name="' + self.currentFilterEl.get('name') + '"]');

					if (newFilterEl && newFilterEl.setSelectionRange) {
						newFilterEl.focus();
						newFilterEl.setSelectionRange(cursorPosition, cursorPosition);
					}
				}

                var callbacks = self.getCallbacks(gridId, 'reload');

				Object.each(callbacks, function(callback, identifier) {
				    (callback.bind(grid))(target);
				});
			},

			onFailure: function() {
			    loader.destroy();
				self.isLoading = false;
				refreshBtns.getElement('i').removeClass('spin');
			}
		}).send();

		return false;
	},

	customize : function(e, target) {
		var url  = target.get('href').replace(/.+?customize-grid/, '');
		var self = this;
		var grid = target.getParent('.mt-grid-table');

		if (app.get('modal').callbacks[url]) {
			return;
		}

		e && e.stop();

		app.get('modal').addCallback(url, function() {
		    var modal = app.get('modal').getCurrent();
		    var table = modal.getElement('table');
		    var colSelect = modal.getElement('select');
		    var sortableTable = null;

		    var labels = {};
		    var cols   = modal.retrieve('cols');

		    var newTableCol = function(colName, label, injectPos) {
		        var tr = new Element('tr');

		        new Element('td', {
		           'width' : 10,
		           'html' : '<input type="hidden" name="cols[]" value="' + colName + '" /><span class="btn btn-small mt-handle"><i class="material-icons">import_export</i></span>'
		        }).inject(tr, 'bottom');

		        new Element('td', {
		           'html' : label
		        }).inject(tr, 'bottom');

		        new Element('td', {
		           'width' : 10,
		           'html' : (!cols[colName]['lock']) ? '<span class="btn btn-small mt-delete-row"><i class="material-icons">delete</i></span>' : ''
		        }).inject(tr, 'bottom');

		        if (typeof injectPos === 'undefined') {
		            injectPos = 'top';
		        }

		        tr.inject(table.getElement('tbody'), injectPos);

		        sortableTable.addLists(table.getElement('tbody'));
		    }

		    var sortSelect = function() {
		        var sortable = [];

		        colSelect.getElements('option').each(function(opt) {
		            sortable.push([opt.get('value'), opt.get('text')]);
		        });

		        sortable.sort(function(a, b) {
		            return a[1].localeCompare(b[1]);
		        });

		        colSelect.getElements('option[value!=""]').destroy();

		        sortable.each(function(sortData) {
		            if (sortData[0] === '') {
		                return;
		            }

		            new Element('option', {
		                'value' : sortData[0],
		                'text'  : sortData[1]
		            }).inject(colSelect, 'bottom');
		        });

				if (!labels['new_column']) {
					labels['new_column'] = colSelect.getElement('option').get('text');
				}

				if (!labels['no_column']) {
					labels['no_column'] = colSelect.get('data-no-dataset');
				}

		        if (sortable.length > 1) {
		            colSelect.erase('disabled');
		            colSelect.getElement('option').set('text', labels['new_column']);
		        } else {
		            colSelect.set('disabled', true);
		            colSelect.getElement('option').set('text', labels['no_column']);
		        }
		    }

		    modal.getElement('form').addEvent('click:relay(.mt-delete-row)', function(e, target) {
		        var row       = target.getParent('tr');
		        var colName   = row.getElement('input').get('value');
		        var colConfig = cols[colName];

		        if (colConfig['lock']) {
		            return;
		        }

		        new Element('option', {
		            'value' : colName,
		            'text'  : colConfig['label']
		        }).inject(colSelect, 'bottom');

		        row.destroy();

		        sortSelect();

				// remove all Filters
				var currentFilterEl = grid.getElements('[name^="filters[' + colName + ']"]');

				if (currentFilterEl) {
					currentFilterEl.set('value', '');
				}
		    });

		  	modal.getElement('#mt-set-default-config').addEvent('click', function(e) {
		        e && e.stop();

		        if (!confirm(app.get('i18n').translate('really.want.to.load.default.config'))) {
		            return false;
		        }

		        colSelect.getElements('option[value!=""]').destroy();

		        table.getElement('tbody').set('html', '');

				var defaultCols = [];

		        Object.each(cols, function(colConfig, colName) {
		        	defaultCols[colConfig.order] = colConfig;
		        });

		        defaultCols.each(function(colConfig) {
		            if (colConfig['customize_hidden']) {
		                new Element('option', {
		                    'value' : colConfig.name,
		                    'text'  : colConfig.label
		                }).inject(colSelect, 'bottom');

		                return;
		            }

		             newTableCol(colConfig.name, colConfig.label, 'bottom');
		        });

		        sortSelect();
		    });

		    colSelect.addEvent('change', function(e) {
		        var opt = this.getElement('option[value="' + this.get('value') + '"]');

		        newTableCol(opt.get('value'), opt.get('text'), 'bottom');

		        opt.destroy();

		        this.selectedIndex = 0;

		        sortSelect();
		    });

		    sortableTable = new Sortables('.mt-user-grid-table tbody',{
		        handle: '.mt-handle',

		        onStart: function(element, clone) {
		            if (element.get('tag') === 'tr' && element.getElements('td').length === 1) {
		                this.drag.cancel();
		                clone.destroy();
		                element.erase('style');
		                return;
		            }
		        },

		        onComplete: function(element) {

		        },

		        clone: false,

		        opacity: 0.5
		    });

		    sortSelect();
		});
	},

    addCallback : function(grid, callbackType, identifier, callback) {
        var self = this;

        if (typeof grid !== 'string') {
            grid = self.getId(grid);
        }

        if (typeof self.callbacks[grid] == 'undefined') {
            self.callbacks[grid] = {};
        }

        if (typeof self.callbacks[grid][callbackType] == 'undefined') {
            self.callbacks[grid][callbackType] = {};
        }

        self.callbacks[grid][callbackType][identifier] = callback;
    },

    removeCallback : function(grid, callbackType, identifier) {
        var self = this;

        if (typeof grid !== 'string') {
            grid = self.getId(grid);
        }

        delete self.callbacks[grid][callbackType][identifier];
    },

    getCallbacks : function(grid, callbackType) {
        var self = this;

        if (typeof grid !== 'string') {
            grid = self.getId(grid);
        }

        if (typeof self.callbacks[grid] == 'undefined') {
            return {};
        }

        if (typeof callbackType == 'undefined') {
            return self.callbacks[grid];
        }

        if (typeof self.callbacks[grid][callbackType] == 'undefined') {
            return {};
        }

        return self.callbacks[grid][callbackType];
    }
};


var History = function() {
    this.urlModifier = new UrlModifier();
};

History.prototype = {
    setParam: function(key, value) {
        var self = this,
            url  = self.urlModifier.setParam(location.href, key, value);

        history.replaceState(null, null, url);
    },

    setParams: function(params) {
        var self = this,
            url  = self.urlModifier.setParams(location.href, params);

        history.replaceState(null, null, url);
    },

    unsetParam: function(key) {
        var self = this,
            url  = self.urlModifier.unsetParam(location.href, key);

        history.replaceState(null, null, url);
    },

    unsetParams: function(params) {
        var self = this,
            url  = self.urlModifier.unsetParams(location.href, params);

        history.replaceState(null, null, url);
    },

    reset: function(keepParams) {
        var self = this,
            url  = self.urlModifier.reset(location.href, keepParams);

        history.replaceState(null, null, url);
    },

    set: function(url) {
        history.replaceState(null, null, url);
    }
};





var Loader = function() {};

Loader.prototype = {
	add : function(wrapper, getHtml, size, injectType) {
	    if (typeof size === 'undefined' || !size) {
	        size = '';
	    } else {
	        size = 'preloader-' + size;
	    }

	    if (getHtml) {
	        var loaderHTML = document.id('mt-loader-template').outerHTML;

	        if (size) {
	        	loaderHTML = loaderHTML.replace(/loader-wrapper/, 'loader-wrapper ' + size);
	        }

	        loaderHTML = loaderHTML.replace('id="mt-loader-template"', '');
	        loaderHTML = loaderHTML.replace(' hide"', '"');

	        return loaderHTML;
	    }

	    if (wrapper && ('outerHTML' in wrapper)) {
	        wrapper = [wrapper];
	    }

	    if (typeof injectType === 'undefined') {
	        injectType = 'bottom';
	    }

	    var loaderClone = null;

	    if (!wrapper) {
	        return loaderClone;
	    }

	    wrapper.each(function(wrap) {
	        loaderClone = document.id('mt-loader-template').clone(true, false);

	        if (size !== '') {
	            loaderClone.addClass(size);
	        }

	        loaderClone.removeClass('hide');

	        if (loaderClone && wrap) {
	            loaderClone.inject(wrap, injectType);
	        }
	    });

	    return (wrapper.length === 1) ? loaderClone : null;
    }
}

var Modal = function(container) {
	this.container = container;

	this.initEvents();
};

Modal.prototype = {
	callbacks : {},

	addCallback : function(url, callback) {
		if (!url) {
			url = '';
		}

		if (!this.callbacks[url]) {
			this.callbacks[url] = [];
		}

		this.callbacks[url].push(callback);
	},

	exists : function() {
		return (document.id('modal-overlay') && !document.id('modal-overlay').hasClass('hide'));
	},

	getCurrent : function() {
		return $$('.modal.is-opened').getLast();
	},

    close : function(modal) {
        if (!modal.hasClass('modal')) {
            modal = modal.getParent('.modal');
        }

        if (!modal) {
            return;
        }

        var modalOverlay = modal.retrieve('modal.overlay'),
            modalXhr     = modal.retrieve('modal.xhr'),
            modalRequest = modal.retrieve('modal.request');

        if (modalRequest && modalRequest.isRunning()) {
            modalRequest.cancel();
        }

        var destroyModal = (modalXhr || modal.get('destroy-on-close'));

        if (destroyModal) {
            // check for calendar elements
            modal.getElements('.date').each(function(dateEl) {
            	var pickerObj = dateEl.retrieve('picker.date');

				pickerObj && pickerObj.destroy();
            });

            modal.destroy();
        } else {
            modal.removeClass('is-opened');
        }

        if (modalOverlay) {
            modalOverlay.addClass('hide');
        }
    },

    getUrl : function(modal) {
        return modal.get('modal.url');
    },

    error : function(modal, error) {
        if (typeof error === 'undefined') {
            error = app.get('i18n').translate('unknown.error.occurred');
        }

        this.close(modal);

        alert(error);
    },

    init : function(modal, content, responseJavaScript, url) {
    	if (!modal) {
    		modal = this.getCurrent();
    	}

	    modal.set('html', content);

	    app.get('chosen').initSelects();

	    var zIndex = modal.getStyle('z-index');

	    modal.getElements('.chosen').addEvent('open', function() {
			this.retrieve('list').setStyle('z-index', zIndex + 1);
	    });

		// init chosen xhr
	    modal.getElements('[data-chosen-xhr-search]').each(function(chosenXhrEl) {
	        var pleaseSelOpt = chosenXhrEl.getElement('option[value=""]');

	        if (pleaseSelOpt) {
	            pleaseSelOpt.set('data-type', 'search-results');
	        }

	        app.get('chosenXhr').init(chosenXhrEl.getParent());
	    });

	    // init char length check
	    app.get('charLengthCheck').init(modal);

	    // init datepicker
	    app.get('picker.date').initSelects(modal.getElements('input.date:not(.disabled):not(.date-added)'));

		if (responseJavaScript) {
	    	Browser.exec(responseJavaScript);
	    }

	    if (modal.getElement('.modal-content') && modal.getElement('.modal-content').get('data-modal-size')) {
	    	modal.setStyle('width', modal.getElement('.modal-content').get('data-modal-size'));
	    }

	    if (modal.getElement('.mt-login-form')) {
	        location.reload();
	    } else {
	        modal.removeClass('hide');

	        if (this.callbacks && url) {
	        	Object.each(this.callbacks, function(cbs, cbUrl) {
	        		if (url.indexOf(cbUrl) === -1) {
	        			return;
	        		}

	        		cbs.each(function(cb) {
	        			cb(modal);
	        		});
	        	});
	        }
	    }
    },

    open : function(target) {
	    var modalId = 'modal-' + ((target.get('data-modal')) ? target.get('data-modal') : 'default'),
	        modal   = document.id(modalId);

	    if (!modal) {
	        return;
	    }

	    modal.setStyle('margin-top', window.getScroll().y);
	    modal.setStyle('margin-bottom', '500px');

	    var modalXhr     = (target.get('data-modal-xhr')) ? target.get('data-modal-xhr') : ((target.hasClass('mt-modal-xhr')) ? true : false),
	        modalOverlay = document.id('modal-overlay');

	    modal.store('modal.request', null);

	    var xhrModal = modalXhr && modalXhr != '0' && modalXhr != 'false';

	    if (xhrModal || target.get('data-modal-prepare-content')) {
	    	modal.addClass('hide');
	        modal = modal.clone(true, false).inject(document.body, 'bottom');

	        app.get('loader').add(modal.getElement('.modal-content'));
	    }

	    if (xhrModal) {
	        var url = target.get('href');

	        if (!url || url === '#') {
	            url = modalXhr;
	        }

	        modalRequest = new XmlHttpRequest.HTML({
	            url:         url,
	            method:      'GET',
	            evalScripts: false,
	            async:       true,
	            onSuccess:   function(responseTree, responseElements, responseHTML, responseJavaScript) {
	            	this.init(modal, responseHTML, responseJavaScript, url);
	            }.bind(this),
	            onError:     function() {
	                this.error(modal);
	            }.bind(this),
	            onFailure:   function() {
	                this.error(modal);
	            }.bind(this),
	            onException: function() {
	                this.error(modal);
	            }.bind(this),
	            onTimeout:   function() {
	                this.error(modal);
	            }.bind(this)
	        });

	        modalRequest.send();
	        modal.store('modal.request', modalRequest);
	        modal.store('modal.url', url);
	    }

	    modal.addClass('is-opened');

	    if (modalOverlay) {
	        modalOverlay.removeClass('hide');
	    }

	    modal.store('modal.trigger', target);
	    modal.store('modal.overlay', modalOverlay);
	    modal.store('modal.xhr', modalXhr);
    },

    initEvents : function() {
        var self = this;

        this.container.addEvents({
            'keydown' : function(e) {
                if (!e || !e.key || e.key !== 'esc') {
                    return;
                }

                var openModal = self.container.getElements('.modal').getLast();

                if (openModal && openModal.hasClass('is-opened')) {
                    self.close(openModal);
                }
            },

            'click:relay(.mt-modal, [data-modal])': function(e, target) {
                if (e) {
                    e.stop();
                }

                self.open(target);
            }.bind(this),

            'click:relay(.modal .modal-close)': function(e, target) {
                if (e) {
                    e.stop();
                }

                self.close(target.getParent('.modal'));
            }
        });
    }
};


var PickerDate = function(container) {
	var self = this;

	this.getDay = function(d, dayNum) {
		d = new Date(d);

		var day = d.getDay();

		if (day === dayNum) {
			return d;
		}

		return new Date(d.setDate(d.getDate() - day + dayNum));
	}

	this.init = function(target) {
	    if (target.hasClass('date-added')) {
	        return;
	    }

        var minDate = target.get('data-minDate');
        var maxDate = target.get('data-maxDate');

        if (minDate) {
            var parts = minDate.split('-');
            minDate = new Date(parts[2], (parseInt(parts[1]) - 1), parts[0]);
        }

        if (maxDate) {
            var parts = maxDate.split('-');
            maxDate = new Date(parts[2], (parseInt(parts[1]) - 1), parts[0]);
        }

        var format = Locale.get('Date.shortDate');

        if (target.get('data-use-time') && target.get('data-use-time') === '1') {
            var patterns  = app.get('i18n').getPattern('date_time', i18n.getLocale()),
                separator = ', ';

            if (patterns && typeof patterns['date_picker'] !== 'undefined' && typeof patterns['date_picker']['separator'] !== 'undefined') {
                separator = patterns['date_picker']['separator'];
            }

        	format += separator + Locale.get('Date.shortTime');
        }

        if (app.get('dateFormat')) {
            format = app.get('dateFormat');
        }

        var inputId   = target.get('id'),
            inputName = target.get('name'),
            inputTs   = target.clone(false, false).removeClass('date date-added').addClass('hide').set('value', '').inject(target, 'after');

        if (inputName) {
            inputTs.set('id', 'date-' + inputName);
        }

        var picker  = new Picker.Date(target, {
            timePicker: target.get('data-use-time') ? true : false,

            days_title : function(date) {
                return Locale.get('Date.months')[date.getMonth()] + ' ' + date.format('%Y');
            },

            minDate : minDate,
            maxDate : maxDate,

            format : format,

            blockKeydown   : false,
            positionOffset : {x: 5, y: 0},
            pickerClass    : 'datepicker_bootstrap',
            useFadeInOut   : false // !Browser.ie
        });

        picker.input   = target;
        picker.inputTs = inputTs;

        picker.addEvent('onOpen', function() {
            var input = this.input,
                grid  = app.get('grid').getGrid(this.input);

            if (!input) {
                return;
            }

            var inputCoords = this.input.getCoordinates(),
                top         = inputCoords.top + inputCoords.height,
                left        = inputCoords.left;

            if (grid) {
                var browserName = grid.get('data-browser-name');

                if (browserName == 'Chrome') {
                    var table = grid.getElement('table'),
                        zoom  = parseFloat(table.getStyle('zoom'));

                    if (!isNaN(zoom)) {
                        top  *= zoom;
                        left *= zoom;
                    }
                }
            }

            var checkWidth = left + this.picker.getCoordinates().width;

            if (checkWidth > window.innerWidth) {
                left = left - (checkWidth - window.innerWidth) - 50;
            }

            this.picker.setStyle('top', top);
            this.picker.setStyle('left', left);
        });

        picker.addEvent('onSelect', function() {
        	var wrap  = this.inputs[0].getParent();
			var group = wrap.getElement('[name="date_type"]');

			if (group && group.get('value') === 'weekly') {
				var input = this.inputs[0];

				if (input.hasClass('sel-event')) {
					input.removeClass('sel-event');
					return;
				}

				input.addClass('sel-event');

                var pickDate = (input.get('id').indexOf('to') !== -1) ? self.getDay(input.retrieve('picker.date').date, 7) : self.getDay(input.retrieve('picker.date').date, 1);

				if (!isNaN(pickDate.getTime())) {
					input.retrieve('picker.date').select(pickDate);
				}
			}
        });

        // init weeknumber picker!
        picker.picker.addEvent('click:relay(.weeknumber)', function(e, target) {
            if (!target || !target.getNext()) {
                return;
            }

            target.getNext().click();
        });

        var modal = document.getElements('.modal').getLast();

        if (modal && modal.hasClass('is-opened')) {
            picker.picker.setStyle('z-index', modal.getStyle('z-index').toInt() + 1);
        }

        target.store('picker.date', picker).addClass('date-added').removeAttribute('name');

        target.addEvent('change', function(e) {
            var picker = this.retrieve('picker.date');

            if (picker) {
                if (this.get('value') === '') {
                    picker.date = undefined;
                    picker.inputTs.set('value', '');
                } else {
                    if (picker.date) {
                    	self.updateTsFromDate(picker);
                    } else {
                    	self.updateDateFromInputTs(this);
                    }
                }
            }
        }).fireEvent('change');

		target.addEvent('paste', function(e) {
			var pasteEvent    = e.event;
		    var clipboardData = pasteEvent.clipboardData || window.clipboardData;
			var pastedData    = clipboardData.getData('Text');

			if (typeof pastedData !== 'string') {
				return;
			}

			// get default date by locale settings
			var defaultDate       = new Date();

			defaultDate.setHours(0);
			defaultDate.setMinutes(0);
			defaultDate.setSeconds(0);

			var defaultDateString = defaultDate.format(picker.options.format);
			pastedData = pastedData.substr(0, defaultDateString.length);

			// fill pasted data with default data
			pastedData = pastedData + defaultDateString.substring(pastedData.length, defaultDateString.length);

			var dateObj = picker.getDateByFormatDate(pastedData, true);

			if ((dateObj == 'Invalid Date') || (dateObj.getFullYear() === 1970 && dateObj.getMonth() === 0 && dateObj.getDay() === 0)) {
				return;
			}

            picker.select(dateObj);
		});
	};

	this.updateTsFromDate = function(picker) {
	    if (!picker.options.timePicker && !picker.options.timePickerOnly) {
	        picker.date.setHours(0, 0, 0, 0);
	    }

	    picker.date.setMilliseconds(0);

	    var pickerTs = picker.date.getTime();

	    picker.inputTs.set('value', (pickerTs + app.get('i18n').getTimeZoneDiff(pickerTs)) / 1000);
	}

	this.updateDateFromInputTs = function(target) {
		var picker = target.retrieve('picker.date'),
	        ts     = parseInt(target.get('value'));

	    if (!isNaN(ts)) {
	    	ts -= app.get('i18n').getTimeZoneDiff(ts * 1000) / 1000;

		    var date = new Date(ts * 1000);

		    if (!picker.options.timePicker && !picker.options.timePickerOnly) {
		        date.setHours(0, 0, 0, 0);
		    }

		    date.setMilliseconds(0);

			picker.select(date);
	    } else {
		    target.retrieve('picker.date').date = undefined;
		    target.set('value', '');

            picker.inputTs.set('value', '');
	    }
	};

	this.addEvents = function() {
	    container.addEvent('click:relay(input.date:not(.disabled))', function(e, target) {
	        if (this.hasClass('date-added') || target.get('disabled') || target.get('readonly')) {
	            return false;
	        }

	        window.setTimeout(function() {
	            if ('hide' in e && e.hide) {
	                return;
	            }

	            target.fireEvent('focus', {target:target});
	        }, 5);

	        self.init(target);
	    });

        container.addEvent('click:relay(.date-clear[data-date-clear])', function(e, target) {
            e && e.stop();

            var dateFieldId = this.get('data-date-clear'),
                dateField   = (dateFieldId) ? document.id(dateFieldId) : null;

            if (dateField) {
                dateField.retrieve('picker.date').date = undefined;
                dateField.set('value', '').fireEvent('change');
            }
        });

        container.addEvent('change:relay([name="date_type"])', function(e, target) {
            e && e.stop();

            self.initGroupSelector(target);
        });
	};

	this.initGroupSelector = function(target) {
	    var options = {};
	    var wrapper = target.getParent();
	    var dateEls = wrapper.getElements('.date-added');

	    if (dateEls.length === 0 || !wrapper.hasClass('filter-elements')) {
	    	return;
	    }

	    switch (target.get('value')) {
	        case 'yearly':
	            options['startView']   = 'years';
	            options['pickOnly']    = 'years';
	            options['weeknumbers'] = false;
                options['format']    = '%Y';
	        break;

	        case 'monthly':
	            var currentFormat = Locale.get('Date.shortDate');
				var formatMatch   = currentFormat.match(/([^a-z]{0,1})(%d)([^a-z]{0,1})/);

	            if (formatMatch) {
	            	var newRg = '';

	            	if (formatMatch[1] != '') {
	            		newRg = new RegExp(formatMatch[1] + formatMatch[2]);
	            	} else if (formatMatch[3] != '') {
	            		newRg = new RegExp(formatMatch[2] + formatMatch[3]);
	            	}

					currentFormat = currentFormat.replace(newRg, '');
	            }

				options['format']      = currentFormat;
	            options['startView']   = 'months';
	            options['pickOnly']    = 'months';
	            options['weeknumbers'] = false;
	        break;

	        case 'weekly':
	            options['startView']   = 'days';
	            options['pickOnly']    = 'days';
	            options['weeknumbers'] = true;
	            options['format']      = Locale.get('Date.shortDate');

	            dateEls.each(function(dateEl) {
	                if (!dateEl.hasClass('date-added')) {
	                    wrapper.fireEvent('click', {target:dateEl, hide : true});
	                }

	                var pickDate = (dateEl.get('id').indexOf('to') !== -1) ? self.getDay(dateEl.retrieve('picker.date').date, 7) : self.getDay(dateEl.retrieve('picker.date').date, 1);

	                if (!isNaN(pickDate.getTime())) {
	                    dateEl.retrieve('picker.date').select(pickDate);
	                }
	            });
	        break;

	        default:
	            options['weeknumbers'] = false;
	            options['startView']   = 'days';
	            options['pickOnly']    = 'days';
	            options['format']      = Locale.get('Date.shortDate');
	        break;
	    }

	    dateEls.each(function(filterEl) {
	        var currentDate = filterEl.retrieve('picker.date').date;

	        Object.each(options, function(val, key) {
	            filterEl.retrieve('picker.date').options[key] = val;
	        });

	        filterEl.retrieve('picker.date').select(currentDate);
	    });
	};

	this.initSelects = function(dateFields) {
		dateFields.each(function(df) {
			self.init(df);
		});
	}

	this.addEvents();

	this.initSelects(container.getElements('input.date:not(.disabled):not(.date-added)'));

    container.getElements('[name="date_type"]').each(function(dateTypeEl) {
    	self.initGroupSelector(dateTypeEl);
    });
}

var Search = function() {
	this.searchField   = document.id('global-search-field');
	this.searchWrapper = document.getElement('.search-wrapper');
    this.searchResult  = document.id('global-search-result');
	this.navTitle      = document.getElement('.nav-title');

    this.timeout;
    this.request;
	this.searchTerm = '';

	this.initEvents();

	if (this.searchField != '') {
		this.send();
	}
};

Search.prototype = {
    initEvents: function() {
        var self = this;

        if (this.searchField) {
        	this.searchField.addEvent('focus', function() {
        		self.searchWrapper.addClass('open');
        	});

            this.searchField.addEvent('keyup', function(e) {
            	if (!String(e.key).match(/^[a-z0-9]$/i) && e.code !== 13 && this.searchTerm == this.get('value')) {
            		return;
            	}

                window.clearTimeout(self.timeout);

                if (self.searchWrapper.getElement('.further-results')) {
                	self.searchWrapper.getElement('.further-results').destroy();
                }

                if (self.request) {
                	self.request.cancel();
                }

                if (self.searchField.get('value')) {
                	this.searchTerm = this.get('value');

                	if (!self.searchResult.getElement('.loader')) {
                    	self.searchResult.set('html', app.get('loader').add(null, true, 'small'));
                    }

                    self.timeout = window.setTimeout(self.send.bind(self), 350);
                } else {
                	self.searchResult.set('html', self.searchResult.get('data-default-message'));
                }
            });

            document.addEvent('mousedown:relay(*)', function(e, target) {
            	if (!self.searchWrapper.hasClass('open')) {
            		return;
            	}

                if (!target.getParent('.search-wrapper')) {
                    self.searchWrapper.removeClass('open');
                }
            });
        }
    },

    send: function() {
    	var self         = this,
        	searchField  = document.getElement('#global-search-field'),
            searchResult = document.getElement('#global-search-result');

        if (searchField) {
            if (searchField.get('value')) {
                searchResult.addClass('is-visible');

                self.request = new XmlHttpRequest.JSON({
                    url: searchField.get('data-url'),

                    data: {
                        term: searchField.get('value')
                    },

                    onSuccess: function(result) {
                        searchResult.set('html', result.html);

                        var furtherResults = searchResult.getElement('.further-results');

                        if (furtherResults) {
                        	furtherResults.inject(searchResult, 'after');
                        }
                    },

                    onFailure: function() {
                        searchResult.set('html', '');
                    }
                }).send();
            }
        }
    }
}


var Tab = function() {}

Tab.prototype = {
	contentContainer : {},
	currentTab       : '',
	callback         : {
		'tab_change' : {}
	},

	init : function(linkContainer) {
		this.initLinks(linkContainer);
	},

	initLinks : function(linkContainer) {
		linkContainer.addEvent('click:relay([data-tab])', this.changeTab.bind(this));

		this.initElements();
	},

	openTabs : function(checkHash, tabContents) {
		var self = this;

		if (checkHash && location.hash) {
			var currentHash = location.hash.replace('#', '');

			currentHash.split('/').each(function(hashPart) {
				this.changeTab(null, $$('[data-tab="' + hashPart + '"]').getLast());
			}.bind(this));
		}

		if (this.currentTab === '' && $$('[data-tab]').length > 0) {
			tabContents = $$('.mt-tab-contents');
		}

		if (tabContents) {
			tabContents.each(function(tabContent) {
				var linksContainer = document.id(tabContent.get('data-tab-links'));

				if (tabContent.getChildren('.is-active').length > 0) {
					self.changeTab(null, linksContainer.getElement('.is-active'));
					return;
				}

				// check visibility
				if (linksContainer.getSize().y === 0) {
					return;
				}

				if (!linksContainer.getElement('[data-tab]')) {
					return;
				}

				self.changeTab(null, linksContainer.getElement('[data-tab]'));

				lastContent = linksContainer.getElement('[data-tab]');
			});
		}
	},

	initElements : function() {
		$$('[data-tab-contents]').each(function(container) {
			if (!container.get('id')) {
				container.set('id', 'tab-' + String.uniqueID());
			}

			if (!this.contentContainer[container.get('id')]) {
				this.contentContainer[container.get('id')] = document.getElement(container.get('data-tab-contents'));

				if (this.contentContainer[container.get('id')]) {
					this.contentContainer[container.get('id')].set('data-tab-links', container.get('id'));
				}
			}
		}.bind(this));
	},

	changeTab : function(e, target) {
		if (!target) {
			return;
		}

		e && e.stop();

		var container = target.getParent('[data-tab-contents]');
		var tabIndex  = 0;
		var tabName   = '';

		container.getElements('[data-tab]').each(function(tab, tabInd) {
			if (tab === target) {
				tabName  = tab.get('data-tab');
				tabIndex = tabInd;

				tab.addClass('is-active');

				return;
			}

			tab.removeClass('is-active');
		});

		var tabContent = this.contentContainer[container.get('id')].getChildren('[data-tab="' + tabName + '"]')[0];

		if (!tabContent) {
			tabContent = this.contentContainer[container.get('id')].getChildren()[tabIndex];
		}

		this.contentContainer[container.get('id')].getChildren().addClass('hide').removeClass('is-active');

		tabContent.removeClass('hide').addClass('is-active');

		location.hash   = this.getTabHash(tabContent, tabName);
		this.currentTab = tabName;

		if (this.callback['tab_change'][container.get('id')]) {
			this.callback['tab_change'][container.get('id')].each(function(callbackFunc) {
				if (typeof callbackFunc === 'function') {
					callbackFunc(tabContent);
				}
			});
		}

		this.openTabs(false, tabContent.getElements('.mt-tab-contents'));
	},

	getTabHash : function(tabContent) {
		var hashChain = [];

		tabContent.getParents('[data-tab-links]').each(function(tContent) {
			if (!tContent.get('data-tab-links')) {
				return;
			}

			hashChain.push(document.id(tContent.get('data-tab-links')).getElement('.is-active').get('data-tab'));
		});

		return hashChain.reverse().join('/');
	},

	getCurrentTab : function() {
		return this.currentTab;
	},

	afterTabChange : function(id, func) {
		if (!this.callback['tab_change'][id]) {
			this.callback['tab_change'][id] = [];
		}

		this.callback['tab_change'][id].push(func);
	}
}

var TargetingSelect = function(container) {
    this.selects = document.getElements('.targeting-select');

    this.init();
};

TargetingSelect.prototype = {
    init : function() {
        var self = this;
        this.initEvents();

        this.selects && this.selects.each(function(select) {
            var data = select.getParent('form').getElement('[name=targeting]');

            // Select first group
            self.selectGroup({}, select.getElement('.targeting-select-groups li'));

            self.buildSelected(select);

            // set Error Callback

            app.get('xhrForm').addCallback(select, 'before_request', function(el) {
                select.getElements('li.error').removeClass('error');
            });

            app.get('xhrForm').addCallback(select, 'error_callback', function(response, el, e) {
                if (response.errors && response.errors.targeting) {
                    if (el.getElement('#element-targeting')) {
                        var groups = select.getElements('.targeting-group'),
                            groupSelect = select.getElement('.targeting-select-groups'),
                            errorGroups = {};

                        response.error_values.targeting.each(function(key) {
                            var content     = select.getElement('.targeting-group .list-content[data-key=' + key + ']')
                                           || select.getElements('.targeting-group .list-content[data-key^=' + key + '---]');

                            if (content && content.getPrevious('.list-heading')) {
                                content.getPrevious('.list-heading').addClass('error');

                                errorGroups[content.getParent('ul').get('data-groupkey')] = true;
                            }
                        });

                        Object.each(errorGroups, function(bool, key) {
                            var group = groupSelect.getElement('li[data-groupkey=' + key + ']');

                            if (group) {
                                group.addClass('error');
                            }
                        });
                    }
                }
            });
        })

    },

    initEvents : function() {
        var self = this;

        this.selects.getParent('.targeting-select-wrapper').addEvents({
            'click:relay(.targeting-select-all)': function(event, target) {
                var select = target.getParent('.targeting-select-wrapper').getElement('.targeting-select');

                self.selectItems(select, select.getElements('.targeting-select-source .targeting-parent:not(.freeform)'));
            },

            /**
             * Open/Close groups
             */
            'click:relay(.targeting-select-groups li)': self.selectGroup,

            /**
             * Open/Close Key Group
             */
            'click:relay(.targeting-select-source .list-heading)': function(event, head) {
                if (event.target.hasClass('tools') || event.target.getParent('.tools')) {
                    return false;
                }

                var onlyClose = head.hasClass('open');

                self.closeSourceGroups(head.getParent('ul'));

                if (!onlyClose) {
                    self.openSourceGroup(head);
                }

            },

            /**
             * Select/Deselect single item
             */
            'click:relay(.targeting-select-source .list-content li)': function(event, item) {
                if (item.hasClass('freeform')) {
                    return;
                }

                self.selectItems(item.getParent('.targeting-select'), [item]);
            },

            'click:relay(.select-all)': function(event, icon) {
                var items = icon.getParent('li').getNext('.list-content').getElements('li:not(.hide)');

                self.selectItems(icon.getParent('.targeting-select'), items);
            },

            /**
             * Freeform input
             */
            'keydown:relay(.targeting-select-source .freeform input)': function(event, input) {
                if (event.code == 13) {
                    event.stop();

                    var value = input.get('value').trim();

                    if (value && !input.getParent('li').getElement('[data-key=' + value + ']')) {
                        new Element('input', {
                            'type'       : 'hidden',
                            'data-key'   : value,
                            'class'      : 'selected input-field'
                        }).inject(input.getParent('li'));

                        input.set('value', '');
                        self.buildSelected(input.getParent('.targeting-select'));
                    }
                }
            },

            /**
             * Search in Group
             */
            'keyup:relay(.list-search input)': function(event, input) {
                if (event.code == 13) {
                    event.stop();
                }

                var items = input.getParent('li').getNext().getElements('li'),
                    search = input.get('value').trim().toLowerCase();

                items.each(function(li) {
                    if (search === "" || li.get('text').trim().toLowerCase().indexOf(search) != -1) {
                        li.removeClass('hide');
                    } else {
                        li.addClass('hide');
                    }
                });
            },

            /**
             * Remove selected item
             */
            'click:relay(.targeting-groups-selected .remove-item)' : function(event, element) {
                var source  = element.getParent('.targeting-select').getElement('.targeting-select-source'),    // selection wrapper
                    group   = source.getElement('.list-content[data-key="' + element.get('data-group') + '"]'), // selection group of element to be deselected
                    li      = element.getParent('li');                                                          // li of selected entry

                if (group) {
                    var selected = group.getElement('[data-key="' + element.get('data-key') + '"]');

                    if (selected) {
                        // deselect in selection container
                        selected.removeClass('selected');

                        // remove Element if freeform input
                        if (selected.hasClass('input-field')) {
                            selected.remove();
                        }

                        // check if last element in selected group, then remove whole group, otherwise just the element
                        if (li.getParent('ul').getChildren().length <= 1) {
                            var list = element.getParent('.list-content');

                            list.getPrevious().remove();
                            list.remove();
                        } else {
                            li.remove();
                        }
                    }
                }
            }
        });
    },

    /**
     * Select and open specified Group
     */
    selectGroup : function(event, group) {
        if (group) {
            var ul       = group.getParent('ul'),
                groupkey = group.get('data-groupkey'),
                source   = ul.getParent('.targeting-select').getElements('.targeting-select-source');

            ul.getElements('li').removeClass('selected');
            group.addClass('selected');

            source.getElements('.targeting-group').each(function(element) {
                element.addClass('hide');
            });

            source.getElement('.targeting-group[data-groupkey=' + groupkey + ']').removeClass('hide');
        }
    },

    /**
     * Close all Source groups
     *
     * @param Element groupUl
     */
    closeSourceGroups : function(groupUl) {
        groupUl.getElements('.list-heading').removeClass('open');
        groupUl.getElements('li.list-search, li.list-content').addClass('hide');
        //groupUl.getElements('.tools').addClass('hide');
        groupUl.getElements('.folder-icon').set('text', 'folder');
    },

    /**
     * Open specified Source Group
     *
     * @param Element head
     */
    openSourceGroup : function(head) {
        var search, freeform,
            tools   = head.getElement('.tools'),
            content = head.getNext();

        if (content.hasClass('list-search')) {
            search  = content;
            content = content.getNext();
        }

        freeform = content.getElement('.freeform');

        //tools.removeClass('hide');
        content.removeClass('hide');
        head.addClass('open');
        head.getElement('.folder-icon').set('text', 'folder_open');

        if (search) {
            search.removeClass('hide');
            search.getElement('input').focus();
        }

        if (freeform) {
            freeform.getElement('input').focus();
        }
    },

    selectItems : function(select, items) {
        if (this.isSelectAll(select, items)) {
            items.each(function(item) {
                item.addClass('selected');
            });
        } else {
            items.each(function(item) {
                item.removeClass('selected');
            });
        }

        this.buildSelected(select);
    },

    isSelectAll : function(select, items) {
        var ret = false;

        items.each(function(li) {
            if (!li.hasClass('selected')) {
                ret = true;
                return;
            }
        });

        return ret;
    },

    /**
     * Set Selection
     *
     * @param Element select
     * @param Object selection
     */
    setSelection : function(select, selection) {
        var sourceUl = select.getElement('.targeting-select-source');

        this.buildSelected(select);
    },

    /**
     * Build selected items of specified select
     */
    buildSelected : function(select) {
        var targetUl      = select.getElement('.targeting-groups-selected'),
            selectedItems = this.getSelectedItems(select),
            selectAllBtn  = select.getParent('.targeting-select-wrapper').getElement('.targeting-select-all'),
            readonly      = select.getParent('.targeting-select-wrapper').hasClass('targeting-readonly');

        targetUl.set('html', '');

        var html = '';

        select.getElement('.targeting-empty').removeClass('hide');

        Object.each(selectedItems, function(group, groupKey) {
            group.values.each(function(items) {
                select.getElement('.targeting-empty').addClass('hide');

                html = html + '<li class="list-heading ' + ((items.hide) ? 'hide' : '') + '" data-key="' + items.key + '">' + items.name + '</li><li class="list-content ' + ((items.hide) ? 'hide' : '') + '"><ul>';

                Object.each(items.values, function(item) {
                    var deleteIcon = '';

                    if (!readonly) {
                        deleteIcon = '<i class="material-icons pull-right remove-item" data-group="' + items.key + '" data-key="' + item.key + '">delete</i>';
                    }

                    var template = '<li data-key="' + item.key + '">' + (item.label || item.key) + '<input type="hidden" name="targeting[' + items.key + '][]" value="' + item.key + '">' + deleteIcon + "</li>";

                    html = html + template;
                });

                html = html + '</ul></li>'
            });
        });

        targetUl.set('html', html);
    },

    /**
     * Get all currently selected items of specified select
     */
    getSelectedItems : function(select) {
        var selected = {};

        select.getElements('.targeting-group').each(function(group) {
            var groupKey   = group.get('data-groupkey'),
                groupItems = [];

            group.getElements('.list-content').each(function(list) {
                var targetingKey  = list.get('data-key'),
                    selectedItems = list.getElements('.selected');

                if (selectedItems.length) {
                    var i,items = [];

                    for (i = 0; i < selectedItems.length; i++) {
                        items.push({
                            'label': selectedItems[i].get('text'),
                            'key'  : selectedItems[i].get('data-key')
                        });
                    }

                    groupItems.push({
                        'key'   : targetingKey,
                        'name'  : list.getPrevious('.list-heading').getElement('.label').get('text').trim(),
                        'hide'  : (list.get('data-hide') == '1'),
                        'values': items
                    });
                }
            });

            if (Object.keys(groupItems).length) {
                selected[groupKey] = {
                    "label"  : group.get('text').trim(),
                    "values" : groupItems
                };
            }
        });

        return selected;
    }
}


var UrlModifier = function() {
    this.reservedParams = ['tab', 'page'];
};

UrlModifier.prototype = {
    escape: function(string) {
        return string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
    },

    setParam: function(url, key, value) {
        var self    = this,
            router  = app.get('router'),
            request = router.parseUrl(url),
            params  = request['parameters'],
            url     = router.getWebhost() + '/' + router.getModule() + '/' + router.getController() + '/' + router.getAction(),
            hash    = router.getHash();

        if (self.reservedParams.indexOf(key) === -1) {
            params[key] = value;
        }

        Object.each(params, function(v, k) {
            url += '/' + encodeURI(k) + '/' + encodeURI(v);
        });

        if (hash) {
            url += '#' + hash;
        }

        return url;
    },

    setParams: function(url, params) {
        var self = this;

        Object.each(params, function(value, key) {
            url = self.setParam(url, key, value);
        });

        return url;
    },

    unsetParam: function(url, key) {
        var self    = this,
            router  = app.get('router'),
            request = router.parseUrl(url),
            params  = request['parameters'],
            url     = router.getWebhost() + '/' + router.getModule() + '/' + router.getController() + '/' + router.getAction(),
            hash    = router.getHash();

        if (typeof params[key] !== 'undefined') {
            delete params[key];
        }

        Object.each(params, function(v, k) {
            url += '/' + encodeURI(k) + '/' + encodeURI(v);
        });

        if (hash) {
            url += '#' + hash;
        }

        return url;
    },

    unsetParams: function(url, params) {
        var self = this;

        Array.each(params, function(key) {
            url = self.unsetParam(url, key);
        });

        return url;
    },

    reset: function(url, keepParams) {
        var self    = this,
            router  = app.get('router'),
            request = router.parseUrl(url),
            params  = request['parameters'],
            url     = router.getWebhost() + '/' + router.getModule() + '/' + router.getController() + '/' + router.getAction(),
            hash    = router.getHash();

        if (!(keepParams instanceof Array)) {
            keepParams = [];
        }

        Object.each(params, function(value, key) {
            if (self.reservedParams.indexOf(key) !== -1 || keepParams.indexOf(key) !== -1) {
                url += '/' + encodeURI(key) + '/' + encodeURI(value);
            }
        });

        return url;
    }
};





var Visibility = function() {};

Visibility.prototype = {
    getHiddenProp: function() {
        if ('hidden' in document) {
            return 'hidden';
        }

        var prefixes = ['webkit','moz','ms','o'];

        for (var i = 0, l = prefixes.length; i < l; i++) {
            if (prefixes[i] + 'Hidden' in document) {
                return prefixes[i] + 'Hidden';
            }
        }

        return false;
    },

    isHidden: function(prop) {
        if (typeof prop == 'undefined') {
            prop = this.getHiddenProp();
        }

        if (!prop) {
            return false;
        }

        return document[prop];
    },

    every: function(ms, callback) {
        var self = this, count = 0, id;

        id = setInterval(function() {
            if (self.isHidden()) {
                return;
            }

            callback(++count * ms, id);
        }, ms);
    },

    on: function(state, callback) {
        var prop = visibilityTracker.getHiddenProp();

        if (!prop) {
            return false;
        }

        var getCurrentState = function() {
            return visibilityTracker.isHidden() ? 'hidden' : 'visible';
        };

        window.onbeforeunload = function() {
            if (state != 'leave') {
                return;
            }

            callback();
        };

        document.addEventListener(prop.replace(/[H|h]idden/,'') + 'visibilitychange', function() {
            if (getCurrentState() == state) {
                callback();
            }
        }, false);

        return true;
    },

    getCorrectElements: function(el) {
        var win = window, doc = document, isFrame = false;

        try {
            isFrame = !!window.frameElement;

            /**
             * top.document throws an exception if the parent frame is unaccessible.
             */
            if (window.frameElement && top.document) {
                /**
                 * Override the teaser node with the frame element that contains the teaser iframe.
                 */
                el  = window.frameElement;
                win = top.window;
                doc = top.document;
            }
        } catch(e) {}

        return {win: win, doc: doc, el: el, isFrame: isFrame};
    },

    isVisibleByStyle: function(el) {
        if (!el || !el.parentNode) {
            return false;
        }

        var visibility = window.getComputedStyle(el, null).getPropertyValue('visibility');

        if (visibility === 'hidden' || visibility === 'collapse') {
            return false;
        }

        return true;
    },

    isInViewport: function(el, distance) {
        var isInViewport, elClass,
            hasDisplayNone = false;

        if (!el) {
            return false;
        }

        var vis = this.getCorrectElements(el);

        if (distance && !vis.isFrame && window.getComputedStyle(vis.el).getPropertyValue("display") == 'none') {
            elClass          = vis.el.className;
            vis.el.className += ' nativendo-visibility-check';
            hasDisplayNone   = true;
        }

        var rect = vis.el.getBoundingClientRect();

        if (!distance && (rect.width <= 0 || rect.height <= 0)) {
            return false;
        }

        distance = distance || 0;

        isInViewport = rect.bottom > 0 &&
            rect.right > 0 &&
            rect.left < (vis.win.innerWidth || vis.doc.documentElement.clientWidth) &&
            (rect.top - distance) < (vis.win.innerHeight || vis.doc.documentElement.clientHeight);

        if (hasDisplayNone) {
            vis.el.className = elClass;
        }

        return isInViewport;
    },

    percentage: function(el) {
        if (!this.isInViewport(el) || !this.isVisibleByStyle(el)) {
            return 0;
        }

        var vis = this.getCorrectElements(el), rect = vis.el.getBoundingClientRect(), vh = 0, vw = 0;

        if (rect.top >= 0) {
            vh = Math.min(rect.height, vis.win.innerHeight - rect.top);
        } else if (rect.bottom > 0) {
            vh = Math.min(vis.win.innerHeight, rect.bottom);
        }

        if (rect.left >= 0) {
            vw = Math.min(rect.width, vis.win.innerWidth - rect.left);
        } else if (rect.right > 0) {
            vw = Math.min(vis.win.innerWidth, rect.right);
        }

        return (vh * vw) / (rect.height * rect.width);
    }
};


var W5gEditor = function() {
	var self = this;

	this.initResources = function(cb, afterEditorLoadedCb) {
		var ckeEditorScriptFile  = app.get('cdnhost') + 'asset/js/content/vendor/cke/vendorFiles/ckeditor/script.js?v=1';
	    window.CKEDITOR_BASEPATH = app.get('webhost') + 'theme/nativendo/asset/js/vendor/cke/';

		var newStript = document.createElement('script');
		newStript.src = ckeEditorScriptFile;

		newStript.onload = function() {
			if (typeof cb === 'function') {
				cb(afterEditorLoadedCb);
			}
		};

		document.body.appendChild(newStript);
	}

	this.initEditors = function(afterEditorLoadedCb) {
      window.CKEDITOR.timestamp = 10008; // Date.now(); // 100001

	  app.set('imageBrowserUrl', app.get('webhost') + 'ext/xhr/image-browser-list/id/' + app.get('router').getParam('id'));

		// add event markers
		var contextMenuItemCommand = {

		};

		window.CKEDITOR.on('instanceReady', function(ev) {
		contextMenuItemCommand = {
		   label   : CKEDITOR.lang[ev.editor.langCode].common.addEvent,
		   command : 'addContentEvent',
		   group   : 'image'
		};

		ev.editor.contextMenu.addListener( function( element, selection ) {
		   return {
		      contextMenuItemCommand : CKEDITOR.TRISTATE_OFF
		   };
		});

		ev.editor.addCommand("contextMenuItemCommand", new CKEDITOR.dialogCommand( 'abbrDialog' ));

		ev.editor.addMenuItems({
		   contextMenuItemCommand : {
		      label   : CKEDITOR.lang[ev.editor.langCode].common.addEvent,
		      command : 'contextMenuItemCommand',
				group   : 'image',
			          order   : 1
				}
		    });
		});


      var CKE_INTERVAL_ID = null;

		$$('.ckeditor').each(function(editor) {
	        editor.getParent('div').addClass('editor-wrapper');
	    });

	    window.setTimeout(function() {
	        var foundTry = 0;

	        CKE_INTERVAL_ID = window.setInterval(function() {
	            var found  = false;
	            foundTry++;

	            $$('.ckeditor').each(function(editor) {
	                var id = 'cke_' + editor.get('id');

	                if (document.id(id) === null) {
	                    return;
	                }

	                var eventBtn =  document.getElement('.cke_button__contentevent');

	                if (eventBtn) {
	                	/*
	                    <?php if ((bool)$this->config->app->is_adserver): ?>
	                        eventBtn.getParent('.cke_toolbar').destroy();
	                    <?php else: ?>
	                        eventBtn.setStyle('display', 'inline');
	                    <?php endif; ?>
	                    */
	                }

	                found = true;

	                editor.set('value', CKEDITOR.instances[editor.get('id')].getData().trim());

	                if (typeof editor.retrieve('setValueCb') === 'function') {
	                    editor.retrieve('setValueCb')(CKEDITOR.instances[editor.get('id')].getData().trim());
	                }
	            });

	            if (!found && foundTry > 50) {
	                window.clearInterval(CKE_INTERVAL_ID);
	            }
	        }, 200);

	        if (typeof afterEditorLoadedCb === 'function') {
	        	afterEditorLoadedCb();
	        }
	    }, 1000);
	}

	this.init = function(container, afterEditorLoadedCb) {
		if (!self.resourcesLoaded) {
			this.initResources(this.initEditors, afterEditorLoadedCb);
			return;
		}

		this.initEditors(afterEditorLoadedCb);
	}
};


W5gEditor.prototype = {
	resourcesLoaded : false
}

var Widget = function() {

	this.init = function(widgetContainer) {
		var widgetName = String(widgetContainer.get('data-widget'));

		widgetFunc = 'init' +  widgetName.replace(/(_[^ ]{1}|-[^ ]{1})/g, function(match) {
			return match.replace(/_|-/, '').toUpperCase()
		}).toUpperCaseFirst();

		if (this[widgetFunc]) {
			this[widgetFunc](widgetContainer);
		}
	}
};

Widget.prototype = {

	prepareStatsValues : function(container) {
        if (typeof container == 'undefined') {
            container = document.body;
        }

        if (!container) {
            return;
        }

        container.getElements('.mt-stats-value').set('html', '');
        app.get('loader').add(container.getElements('.mt-stats-value'), false, 'micro');
   },

	initDeviceChart : function(container) {
		var chartId = container.getElement('.mt-chart').get('id');

		container.getElement('.mt-stats-filter').addEvent('change', function() {
			var currentOption = this.getElement('option:selected');

			app.get('chart').charts[chartId].filters = {
				'from' : currentOption.get('data-from'),
				'to'   : currentOption.get('data-to')
			}

			app.get('chart').refresh(chartId, document.id(chartId));
		});

		container.getElement('.mt-stats-filter').fireEvent('change');
	},

	initStatsData : function(container) {
		var valueConfig = {};
		var metrics     = [];
		var formula     = {};
		var self        = this;

		container.getElements('.mt-stats-value').each(function(statsValueEl) {
			var id = 'wsd-' + String.uniqueID();

			valueConfig[id] = {
				'el' : statsValueEl
			};

			formula[id] = statsValueEl.get('data-metric');

			var allAtts = statsValueEl.attributes;

			for (var i = 0; i < allAtts.length; i++) {
				if (!allAtts[i].nodeName.match(/^data-/)) {
					continue;
				}

				var dataKey = allAtts[i].nodeName.replace(/^data-/, '');

				if (dataKey == 'metric') {
					metrics.append(allAtts[i].nodeValue.split(','));
					continue
				}

				if (dataKey == 'formula') {
					formula[id] = allAtts[i].nodeValue;
					continue
				}

				valueConfig[id][dataKey] = allAtts[i].nodeValue;
			}

			statsValueEl.set('id', id);
		});

		var chartId = container.getElement('.mt-chart').get('id');

		if (app.get('chart').charts[chartId]) {
			app.get('chart').charts[chartId].params['metric']  = metrics;
		}

		app.get('chart').charts[chartId].params["aggregate"] = {
			"sum" : metrics
		}

		app.get('chart').charts[chartId].config.callback.aggregate = function(sums) {
			Object.each(formula, function(formu, elementId) {
				formu = formu.replace(/([a-z_]+\:[a-z_]+)/g, function(formulaMatch) {
					return 'sums["sum"]["' + formulaMatch.replace(/\:/, '_') + '"]';
				});

				var sum = 0;

				try {
					eval("sum = " + formu + ';');
				} catch(err) {}

				if (isNaN(sum)) {
					sum = 0;
				}

				var prefix = (valueConfig[elementId]["prefix"]) ? valueConfig[elementId]["prefix"] : '';
				var suffix = (valueConfig[elementId]["suffix"]) ? valueConfig[elementId]["suffix"] : '';

				switch (valueConfig[elementId]["format"]) {
					case 'currency':
						sum = app.get('i18n').formatCurrency(sum);
						break;

					case 'percent':
                		sum = app.get('i18n').formatPercent(sum, {multiplier: 1});
						break;

					case 'dwell':
						sum = app.get('i18n').formatNumber(sum, {precision : 0});
						break;

					default:
						sum = app.get('i18n').formatNumber(sum, {precision : 2});
				}

				document.id(elementId).set('html', prefix + sum + suffix);
			});
		}

		container.getElement('.mt-stats-filter').addEvent('change', function() {
			var currentOption = this.getElement('option:selected');

			app.get('chart').charts[chartId].filters = {
				'from' : currentOption.get('data-from'),
				'to'   : currentOption.get('data-to')
			}

			self.prepareStatsValues(container);

			app.get('chart').refresh(chartId, document.id(chartId));
		});

		container.getElement('.mt-stats-filter').fireEvent('change');
	}
};


var Xhr = function() {};

Xhr.prototype = {

    getDspPriorities : function(e) {
        var self            = this,
            prioritySelect  = document.id('element-priority_id'),
            priorityTooltip = document.getElement('[for="element-priority_id"] [rel="tooltip"]'),
            module          = app.get('router').getModule(),
            controller      = app.get('router').getController(),
            action          = app.get('router').getAction();

        if (!prioritySelect) {
            return;
        }

        new XmlHttpRequest.JSON({
            url : app.get('webhost') + 'ext/xhr/get-dsp-priorities/id/' + self.get('value') + '/ht/1/mdl/' + module + '/ctrl/' + controller + '/act/' + action,

            onRequest : function() {},

            onError : function() {
                return alert(app.get('i18n').translate('unknown.error.occurred'));
            },

            onComplete : function(rsp) {
                if ('status' in rsp && rsp.status == 'success') {
                    var chosen = new Chosen(prioritySelect.getParent());
                    chosen.destroy(prioritySelect);

                    prioritySelect.getElements('option[value!=""]').destroy();

                    rsp.priorities.each(function(priority) {
                        var option = new Element('option', {
                            'value': priority.id
                        });

                        option.set('html', priority.name);
                        option.inject(prioritySelect, 'bottom');
                    });

                    if (priorityTooltip) {
                        var tooltip = null;

                        switch (controller) {
                            case 'campaign':
                                tooltip = 'helptext.dsp.campaign.alternative.data.priority';
                                break;
                            case 'line-item':
                                tooltip = 'helptext.dsp.line.item.data.priority';
                                break;
                        }

                        if (tooltip) {
                            priorityTooltip.set('html', app.get('i18n').translate(tooltip, [], [rsp.helptext]));
                        }
                    }
                } else {
                    alert(app.get('i18n').translate('unknown.error.occurred'));
                }
            }
        }).send();
    },

    getDspUnits : function(e) {
        var self       = this,
            unitSelect = document.id('element-unit'),
            module     = app.get('router').getModule(),
            controller = app.get('router').getController(),
            action     = app.get('router').getAction();

        if (!unitSelect) {
            return;
        }

        new XmlHttpRequest.JSON({
            url : app.get('webhost') + 'ext/xhr/get-dsp-units/id/' + self.get('value') + '/mdl/' + module + '/ctrl/' + controller + '/act/' + action,

            onRequest : function() {},

            onError : function() {
                return alert(app.get('i18n').translate('unknown.error.occurred'));
            },

            onComplete : function(rsp) {
                if ('status' in rsp && rsp.status == 'success') {
                    var chosen = new Chosen(unitSelect.getParent());
                    chosen.destroy(unitSelect);

                    unitSelect.getElements('option[value!=""]').destroy();

                    rsp.units.each(function(unit) {
                        var option = new Element('option', {
                            'value': unit.id
                        });

                        option.set('html', unit.name);
                        option.inject(unitSelect, 'bottom');
                    });
                } else {
                    alert(app.get('i18n').translate('unknown.error.occurred'));
                }
            }
        }).send();
    },

    getDspBiddingStrategies : function(e) {
        var self     = this,
            bsSelect = document.id('element-bidding_strategy');

        if (!bsSelect) {
            return;
        }

        new XmlHttpRequest.JSON({
            url : app.get('webhost') + 'ext/xhr/get-dsp-bidding-strategies/id/' + self.get('value'),

            onRequest : function() {},

            onError : function() {
                return alert(app.get('i18n').translate('unknown.error.occurred'));
            },

            onComplete : function(rsp) {
                if ('status' in rsp && rsp.status == 'success') {
                    var chosen = new Chosen(bsSelect.getParent());
                    chosen.destroy(bsSelect);

                    var currentValue      = bsSelect.get('value'),
                        resetCurrentValue = false;

                    bsSelect.getElements('option[value!=""]').destroy();

                    rsp.strategies.each(function(strategy) {
                        var option = new Element('option', {
                            'value': strategy.id
                        });

                        option.set('html', strategy.name);
                        option.inject(bsSelect, 'bottom');

                        if (strategy.id == currentValue) {
                            resetCurrentValue = true;
                        }
                    });

                    if (resetCurrentValue) {
                        bsSelect.set('value', currentValue);
                    }

                    bsSelect.fireEvent('change');
                } else {
                    alert(app.get('i18n').translate('unknown.error.occurred'));
                }
            }
        }).send();
    },

    getCreativeTemplates : function(e) {
        var self                   = this,
            creativeTemplateSelect = document.id('element-creative_template_id');

        if (!creativeTemplateSelect) {
            return;
        }

        new XmlHttpRequest.JSON({
            url : app.get('webhost') + 'ext/xhr/get-creative-templates/id/' + self.get('value'),

            onRequest : function() {},

            onError : function() {
                return alert(app.get('i18n').translate('unknown.error.occurred'));
            },

            onComplete : function(rsp) {
                if ('status' in rsp && rsp.status == 'success') {
                    var chosen = new Chosen(creativeTemplateSelect.getParent());
                    chosen.destroy(creativeTemplateSelect);

                    creativeTemplateSelect.getElements('option[value!=""]').destroy();

                    rsp.creative_templates.each(function(creativeTemplate) {
                        var option = new Element('option', {
                            'value': creativeTemplate.id
                        });

                        option.set('html', creativeTemplate.name);
                        option.inject(creativeTemplateSelect, 'bottom');
                    });
                } else {
                    alert(app.get('i18n').translate('unknown.error.occurred'));
                }
            }
        }).send();
    },

    getRoleSecurity : function(e) {
        var self        = this,
            roleSelect  = document.id('element-role_id');

        if (!roleSelect) {
            return;
        }

        var roleId = roleSelect.get('value');

        roleSelect.set('data-security-confirmed', '0');

        if (!roleId) {
            roleSelect.set('data-security', '0');

            return;
        }

        new XmlHttpRequest.JSON({
            url : app.get('webhost') + 'ext/xhr/get-role-security/id/' + roleId,

            onRequest : function() {},

            onError : function() {
                return alert(app.get('i18n').translate('unknown.error.occurred'));
            },

            onComplete : function(rsp) {
                if ('status' in rsp && rsp.status == 'success') {
                    roleSelect.set('data-security', rsp.security);
                } else {
                    alert(app.get('i18n').translate('unknown.error.occurred'));
                }
            }
        }).send();
    }
}


var XhrForm = function(container) {
	this.container     = container;
	this.navBarHeight  = document.getElement('.navbar-fixed-top') ? document.getElement('.navbar-fixed-top').getCoordinates().height : 0;
	this.topBuffer     = 15;

	this.initEvents();
};


XhrForm.prototype = {
	fixedBtnForm : null,
	fixedBtnWrapper : null,
	fixedBtnSubTabs : null,

    getForm : function(form) {
    	if (form.get('tag') !== 'form') {
    		form = form.getParent('form');
    	}

    	return form;
    },

    deleteMessage : function(form, formAlertId, removePersistent) {
    	removePersistent = (typeof removePersistent === 'undefined') ? false : removePersistent;

    	if (!form) {
    		document.getElements('form').each(function(tmpForm) {
    			if (form || tmpForm.retrieve('form-alerts') == null) {
    				return;
    			}

    			if (tmpForm.retrieve('form-alerts').get('alerts').get(formAlertId)) {
					form = tmpForm;
    			}
    		})
    	}

    	if (!form || !form.retrieve('form-alerts')) {
    		return;
    	}

    	var formAlert = form.retrieve('form-alerts').get('alerts').get(formAlertId)
    		wrapper   = form.retrieve('form-alerts').get('wrapper').get(formAlert.wrapper);

    	if (formAlert.options.persistent && !removePersistent) {
			return;
    	}

		$$(formAlert.elements).destroy();

		wrapper.element.setStyle('display', 'none');

		form.retrieve('form-alerts').get('alerts').erase(formAlertId);

		this.updateMessageWrapperSize(wrapper.element);
    },

    checkFixedMessages : function(form, force) {
		var self  = this,
			force = typeof force === 'undefined' ? false : force,
			modal = app.get("modal").exists();

		form.retrieve('form-alerts').get('alerts').each(function(formAlert) {
			var wrapper           = form.retrieve('form-alerts').get('wrapper').get(formAlert.wrapper);
				formAlertPosition = (wrapper.element.getCoordinates().top - self.topBuffer < document.getScroll().y + self.navBarHeight) ? "fixed" : "relative";

			if (!force && (wrapper.element.getCoordinates().height === 0 || formAlertPosition == wrapper.position)) {
				return;
			}

			wrapper.position = formAlertPosition;

			var fixedStyles = {
				"width"      : "",
				"visibility" : "",
				"top"		 : ""
			};

			var fixedWrapper = wrapper.element.getElement('.fixed-wrapper');

			if (formAlertPosition == 'fixed') {
		        fixedStyles   = {
		            width 		 : fixedWrapper.getCoordinates().width,
		            'visibility' : 'visible'
		        };

		        if (!modal) {
		            fixedStyles.top = document.body.getStyle('padding-top');
		        }

	            fixedWrapper.setStyles(fixedStyles).addClass('alert-fixed');
			} else {
	        	Object.each(fixedStyles, function(dummy, styleKey) {
	        		fixedWrapper.setStyle(styleKey, '').removeClass('alert-fixed');
	        	});
			}
		});
    },

    updateMessageWrapperSize : function(wrapper) {
		wrapper.setStyles({
			'height' : ''
		});

		var isFixedAlert = wrapper.getElement('.fixed-wrapper').hasClass('alert-fixed');

	    wrapper.getElement('.fixed-wrapper').removeClass('alert-fixed');

	    wrapper.setStyles({
	    	'height'        : wrapper.getCoordinates().height,
	    	'margin-bottom' : 14,
	    	'display'       : ''
	    });

	    if (isFixedAlert) {
	    	wrapper.getElement('.fixed-wrapper').addClass('alert-fixed');
	    }
    },

    addMessage : function(form, options) {
    	var defaultOptions = {
    		"class"      : "",
    		"persistent" : false
    	};

        if (typeof options != 'object') {
            options = {};
        }

	    options = Object.merge(defaultOptions, options);

	    if (!options["id"]) {
	    	options["id"] = 'msg-' + String.uniqueID();
	    }

		if (form.retrieve('form-alerts') === null) {
			form.store('form-alerts', new Hash({
				"alerts"  : new Hash({}),
				"wrapper" : new Hash({}),
			}));
		}

        options['class'] += ' mt-form-alert';

		var formStatus    = form.get('data-status'),
            statusWrapper = form.getElements('.form-status'),
		    formModal     = app.get('modal').exists(),
		    self          = this;

        if (formStatus && document.getElement(formStatus)) {
        	statusWrapper = [document.getElement(formStatus)];
        }

        if (statusWrapper.length === 0) {
			statusWrapper.push(new Element('div', {
				'class' : 'form-status'
			}).inject(formModal ? app.get('modal').getCurrent().getElement('.modal-content') : form, 'top'));
        }

        if (form.retrieve('form-alerts').get("alerts").getLength() > 0) {
        	var currentAlert = form.retrieve('form-alerts').get('alerts').get(options['id']);

        	if (!currentAlert) {
        		if (!options['persistent']) {
        			form.retrieve('form-alerts').get('alerts').each(function(formAlert) {
        				if (!currentAlert && !formAlert.options.persistent) {
							currentAlert = formAlert;
        				}
        			});
        		}
        	}

        	if (currentAlert) {
        		currentAlert.elements.each(function(element) {
					app.get('alert').update(element, options["text"], options["type"], options);
        		});

        		return currentAlert.elements;
        	}
        }

		form.retrieve('form-alerts').get('alerts').set(options['id'], {
			'elements' : [],
			'options'  : options
		});

        var defaultFormAlert = app.get('alert').add(options["text"], options["type"], options);

        statusWrapper.each(function(wrapper, wrapperKey) {
        	if (!wrapper.get('data-uid')) {
        		wrapper.set('data-uid', 'msgw-' + String.uniqueID());
        	}

        	var fixedWrapper = wrapper.getElement('.fixed-wrapper');

			if (!fixedWrapper) {
	        	fixedWrapper = new Element('div', {
	        		"class" : "fixed-wrapper"
	        	}).inject(wrapper, 'bottom');
        	}

        	var alertClone = defaultFormAlert
        	    .clone(true, false)
        	    .set('data-uid', options["id"])
            	.addClass('mt-form-alert')
            	.inject(fixedWrapper, 'bottom');

			if (form.retrieve('loader')) {
	            form.retrieve('loader').getElement('.loader').clone().inject(alertClone, 'top');
	            form.retrieve('loader').getElement('.loader').addClass('hide');
            }

            alertClone.store('statusWrapper', wrapper);

            form.retrieve('form-alerts').get("alerts").get(options["id"]).elements.push(alertClone);
            form.retrieve('form-alerts').get("alerts").get(options["id"]).wrapper = wrapper.get('data-uid');

            self.updateMessageWrapperSize(wrapper);

            form.retrieve('form-alerts').get('wrapper').set(wrapper.get('data-uid'), {
            	"position" : "relative",
            	"element"  : wrapper
            });
        });

        if (form.retrieve('form-alerts').getLength() > 0) {
            self.checkFixedMessages(form, true);
        }

        return form.retrieve('form-alerts').get("alerts").get(options["id"]).elements;
    },

    setStatus : function(form, status, type, options) {
    	form = this.getForm(form);

        if (!form || form.retrieve('current-status') == type) {
            return [];
        }

        if (typeof options != 'object') {
            options = {};
        }

        if (typeof options['class'] == 'undefined') {
            options['class'] = '';
        }

        if (type !== 'danger') {
	    	form.getElements('.form-group.error').removeClass('error');
	    	form.getElements('.error-message-el').destroy();
        }

        form.store('current-status', type);

		status = app.get('i18n').translate(status);

        options["text"]   = status;
        options["type"]   = type;

        return this.addMessage(form, options, type);
    },

    unsetStatus : function(form, success) {
		form = this.getForm(form);

        if (!form) {
            return;
        }

		var self = this;

        form.store('current-status', '');

        if (typeof success === 'undefined') {
        	success = false;
        }

        if (form.retrieve('form-alerts') !== null) {
            form.retrieve('form-alerts').get('alerts').each(function(formAlert, formAlertId) {
            	if (success && formAlert.elements[0].hasClass('red')) {
            		return;
            	}

            	self.deleteMessage(form, formAlertId);
            });
        }
    },

    addCallback : function(form, type, callback) {
        form = this.getForm(form);

        var currentCallback = form.retrieve(type)

        if (currentCallback) {
            callback = function() {
                currentCallBack.apply(this, arguments);
                callback.apply(this, arguments);
            }
        }

        form.store(type, callback);
    },

    setLoader : function(form) {
		form = this.getForm(form);

        if (!form || form.retrieve('loader')) {
            return;
        }

        form.addClass('mt-lock');

        var formModal = form.getParent('.modal'),
            loader    = null;

        if (formModal) {
            loader = app.get('loader').add(formModal);
        } else {
            loader = app.get('loader').add(form);
        }

        form.store('loader', loader);

        return loader;
    },

    unsetLoader : function(form, keepLocked) {
		form = this.getForm(form);

        if (!form) {
            return;
        }

        if (!keepLocked) {
            form.removeClass('mt-lock');
        }

        var formModal = form.getParent('.modal');

        if (formModal) {
            formModal.getElements('.loader-wrapper').destroy();
        } else {
            form.getElements('.loader-wrapper').destroy();
        }

        form.store('loader', null);
    },

    initFixedBtnBar : function(form, refresh) {
		var self = this;

		refresh = (typeof refresh === 'undefined') ? false : refresh;

		if (!form.get('id')) {
			form.set('id', 'xhr-form-' + String.uniqueID());
		}

		if (refresh) {
			self.fixedBtnWrapper && self.fixedBtnWrapper.destroy();

			if (self.fixedBtnForm) {
				self.fixedBtnForm.getElements('[type="submit"], .submit-btn').setStyle('visibility', 'visible');
			}

			self.fixedBtnWrapper = null;
			self.fixedBtnForm    = null;
		}

		if (self.fixedBtnForm || form.get('id') == 'mt-stats-event-control') {
			return;
		}

    	var mainEl     = $$('main')[0];
		var navToggler = $$('.side-nav-toggler').getLast();
		var subTabsWrapper 	= form.getParent('.mt-tab-contents');
		var subTabs 		= (subTabsWrapper && subTabsWrapper.getParent()) ? subTabsWrapper.getParent().getChildren('.md-tabs-sub') : null

		if (!mainEl) {
			return;
		}

		self.fixedBtnForm = form;

		self.fixedBtnWrapper = new Element('div', {
			styles : {
				'width'        : mainEl.getCoordinates().width
			},
			'class' : 'hide'
		}).addClass('fixed-buttons').inject(mainEl, 'bottom');

		form.getElements('[type="submit"], .submit-btn').each(function(btn) {
			var btnClone = btn.clone();

			btnClone.setStyle('margin-right', '5px').inject(self.fixedBtnWrapper, 'bottom');

			btn.setStyle('visibility', 'hidden');

			btnClone.addEvent('click', function() {
				btn.click();
			});
		});

        window.addEvent('resize', function(e) {
            window.setTimeout(function() {
                self.checkFixedButtons();
            }, 250);
        }).fireEvent('resize');

    	navToggler.addEvent('click', function() {
    		window.setTimeout(function() {
            	self.checkFixedButtons();
            }, 250);
    	});

    	if (subTabs && subTabs.length > 0) {
    		self.fixedBtnSubTabs = subTabs[0];

    		subTabs[0].getElements('.md-tab').addEvent('click', function() {
    			window.setTimeout(function() {
    				// subtop is not visible
    				if (self.fixedBtnForm.getCoordinates().width === 0) {
    					self.fixedBtnWrapper.addClass('hide');
						self.fixedBtnForm.getElements('[type="submit"], .submit-btn').setStyle('visibility', 'visible');
    				} else {
    					self.fixedBtnWrapper.removeClass('hide');
						self.fixedBtnForm.getElements('[type="submit"], .submit-btn').setStyle('visibility', 'hidden');
    				}
    			}, 50);
    		});
    	}

        self.checkFixedButtons();
    },

    checkFixedButtons : function() {
    	if (!this.fixedBtnForm) {
    		return;
    	}

    	var sideNavHidden = document.body.hasClass('sidenav-hidden');
		var mainEl        = document.getElement('main');
		var marginLeft    = (self.fixedBtnSubTabs && self.fixedBtnSubTabs.getCoordinates().width > 0) ? self.fixedBtnSubTabs.getCoordinates().width : 0;

		if (!mainEl) {
			return;
		}

    	this.fixedBtnWrapper.setStyles({
    		'margin-left'  : marginLeft,
    		'width'        : mainEl.getCoordinates().width - marginLeft
    	});

    	if (window.innerHeight < mainEl.getCoordinates().height + mainEl.getCoordinates().top + 20 && !(document.body.hasClass('page-ssp-ad-unit-details') && document.body.hasClass('tab-editor'))) {
    		document.body.addClass('fixed-actions');
    		this.fixedBtnWrapper.removeClass('hide');
			this.fixedBtnForm.getElements('[type="submit"], .submit-btn').setStyle('visibility', 'hidden');
    	} else {
    	    document.body.removeClass('fixed-actions');
    		this.fixedBtnWrapper.addClass('hide');
			this.fixedBtnForm.getElements('[type="submit"], .submit-btn').setStyle('visibility', 'visible');
    	}
    },

    initEvents : function() {
    	var forms = this.container.getElements('form');
        var self  = this;

    	forms.each(function(form, formKey) {
    		if (form.getElement('[name="grid_id"]') || form.hasClass('search-wrapper')) {
    			forms[formKey] = null;
    		}
    	});

    	var forms = forms.clean();

    	if (forms.length === 1 && forms[0].getElement('[type="submit"]')) {
    		this.initFixedBtnBar(forms[0]);
    	}

        setTimeout(function(container) {
            this.container.getElements('form[data-warn-on-leave]').each(function(form) {
                var warnSelector = form.get('data-warn-on-leave');

                if (warnSelector) {
                    form.store('originalFormData', form.toQueryString().parseQueryString());

                    if (warnSelector.match(/^\d+$/g)) {
                        warnSelector = 'a[href]:not([href^="#"])';
                    }

                    this.container.addEvent('click:relay(' + warnSelector + ')', function(e, target) {
                        var formData         = JSON.encode(this.toQueryString().parseQueryString()),
                            originalFormData = JSON.encode(this.retrieve('originalFormData'));

                    	if (form.get('data-strip-tags')) {
                    		formData         = formData.replace(/\<\/?p>|\\n/g, '');
                    		originalFormData = originalFormData.replace(/\<\/?p>|\\n/g, '');
                    	}

                        if (formData !== originalFormData && !confirm(app.get('i18n').translate('form.warn.on.leave'))) {
                            e && e.stop();
                        }
                    }.bind(form));
                }
            }.bind(this));
        }.bind(this), 10);

        /**
         * Add Messages are dependent on form Values
         */
        this.container.getElements('input, select').each(function(formEl) {
        	if (!formEl.get('data-warn-msg')) {
        		return;
        	}

        	if (!formEl.retrieve('warn-config')) {
				formEl.store('warn-config', JSON.decode(formEl.get('data-warn-msg')));
        	}

        	warnMsgConfig = formEl.retrieve('warn-config');

			formEl.addEvent('change', function() {
				if (warnMsgConfig["config"][this.get('value')]) {
					var messageElements = self.addMessage(this.getParent('form'), {
						'text' : warnMsgConfig["config"][this.get('value')],
						'icon' : 'warning',
						'type' : 'warning',
						'id'   : warnMsgConfig['id'],
						'persistent' : true,
						'dismiss': 'clear'
					});

					messageElements.each(function(messageElement) {
					    var dismiss = messageElement.getElement('.alert-dismiss').setProperties({
							'data-value' : formEl.get('value'),
							'data-uid'   : warnMsgConfig["id"]
						}).store('config', warnMsgConfig["config"]);
					})
				} else {
					self.deleteMessage(null, warnMsgConfig["id"], true);
				}
			});
        });

        this.container.addEvents({
        	'click:relay([data-uid].alert-dismiss)' : function(e, target) {
        		var hideMessage = function() {
					var alertMsg = target.getParent('.mt-form-alert');

					target.retrieve('config')[target.get('data-value')] = false;

					self.deleteMessage(null, alertMsg.get('data-uid'), true);
        		}

        		if (!app.get('router').getParam('id')) {
					hideMessage();
					return;
        		}

				new XmlHttpRequest({
					url : app.get('router').webhost + '/ext/xhr/hide-warn-message/id/' + target.get('data-uid'),

					onComplete : function() {
						hideMessage();
					}
				}).send();
        	},

            'submit:relay(form)': function(e, target) {
            	if (target.hasClass('no-xhr-form') || target.get('data-xhr') == '0') {
            		return;
            	}

                e && e.stop();
            },

            'click:relay(form input[type="submit"])': function(e, target) {
                var submit = target;

                target = target.getParent('form');

            	if (!target || target.hasClass('no-xhr-form') || target.get('data-xhr') == '0') {
            		return;
            	}

            	var self = this;

                if (e) {
                    e.stop();
                }

                var el = target;

                if (el.hasClass('mt-lock')) {
                    return false;
                }

                if (typeof el.retrieve('before_request') == 'function') {
                    el.retrieve('before_request')(el);
                }

                var action      = location.href,
                    reload      = el.get('data-reload')
                    keepMessage = el.get('data-keep-message');

                if (target.getParent('.modal')) {
                    action = target.getParent('.modal').retrieve('modal.url') || action;
                }

                if (el.get('action') != '') {
                    action = el.get('action');
                }

                if (el.retrieve('action') != null) {
                    action = el.retrieve('action');
                }

            	el.getElements('.form-group.error').removeClass('error');
            	el.getElements('.error-message-el').destroy();

            	el.setStyle('position', 'relative');

                self.setLoader(el);

                self.setStatus(el, app.get('i18n').translate('please.wait'), 'cached', {'icon' : 'cached'});

                var removeStatusLoaderCallback = function() {
                    self.unsetLoader(el);

		     		el.getElements('[type="file"]').each(function(fileElement) {
		     			fileElement.removeProperty('disabled');
		     		});
                }

                if (typeof el.retrieve('before_send_callback') == 'function') {
                    el.retrieve('before_send_callback').bind(this)(el);
                }

				// @todo rausnehmen? Callbacks haben in diesem Object eigentlich nichts verloren
                target.getElements('[data-callback]').each(function(element) {
                    var cb = element.get('data-callback');

                    if (self[cb]) {
                        self[cb](element);
                    }
                });

                var formData = el.toQueryString();

                if (submit.get('name')) {
                    formData += '&' + submit.get('name') + '=' + submit.get('value');
                }

                var request = new XmlHttpRequest.JSON({
                    data   : formData,
                    url    : action,
                    method : 'post',

                    onRequest : function() {},

                    onFailure : function() {
                    	self.setStatus(el, app.get('i18n').translate('unknown.error.occurred'), 'danger');

                        removeStatusLoaderCallback();

                        if (typeof el.retrieve('fail_callback') == 'function') {
                            el.retrieve('fail_callback')('', el, e, self, request);
                        }

                        return false;
                    },

                    onError : function() {
                    	self.setStatus(el, app.get('i18n').translate('unknown.error.occurred'), 'danger');

                        removeStatusLoaderCallback();

                        if (typeof el.retrieve('fail_callback') == 'function') {
                            el.retrieve('fail_callback')('', el, e, self, request);
                        }

                        return false;
                    },

                    onComplete : function(response) {
                        if (!response || (typeof response !== 'object') || !('status' in response) || ('trace' in response)) {
                            self.setStatus(el, app.get('i18n').translate('unknown.error.occurred'), 'danger');
                            self.unsetLoader(el);

                            if (typeof el.retrieve('fail_callback') == 'function') {
                                el.retrieve('fail_callback')(response, el, e, self, request);
                            }

                            return false;
                        }

                        switch (response.status) {
                        	case 'error':
	                        	var tmp     = new Element('div');
								var message = app.get('i18n').translate('check.your.input');

	                            if (!('errors' in response)) {
	                            	message = app.get('i18n').translate('unknown.error.occurred');
	                            } else {
		                        	if (typeof response.errors.length === 'undefined') {
			                            for (elemName in response.errors) {
			                                if (!el.getElement('[name^=' + elemName + ']')) {
			                                    continue;
			                                }

			                                var formElements = el.getElements('[name^=' + elemName + ']');
			                                var formElement  = formElements[0];
			                                var group        = formElement.getParent('.form-group');

			                                group.addClass('error');
			                                group.getElements('.help-inline').destroy();

			                                var tmpErrors = [];

			                                tmp.set('html', String(response.error_format).replace(/\{message\}/, response.errors[elemName]));

			                                tmp.getChildren().each(function(errorMsgEl) {
			                                	errorMsgEl.addClass('error-message-el').inject((group.getElement('.form-error')) ? group.getElement('.form-error') : group, 'bottom');
			                                });

			                                formElement.store('errors', tmpErrors);

											if (formElements.length > 1) {
												formElements.each(function(formEl) {
													if (formEl.get('data-old-value')) {
														formEl.set('value', formEl.get('data-old-value'));
														var formFileWrapper = group.getElement('.form-file-wrapper');

														if (formFileWrapper) {
															formFileWrapper.addClass('hide');
														}
													}
												});
											}
			                            }
		                            }
	                            }

	                            if (('message' in response) && response.message !== '') {
	                            	message = response.message;
	                            }

	                            self.setStatus(el, message, 'danger');

	                            self.unsetLoader(el);

	                            if (typeof el.retrieve('error_callback') == 'function') {
	                                el.retrieve('error_callback')(response, el, e, self);
	                            }
                        	break;

                        	case 'success':
                                var msg = (response.method == 'insert') ? app.get('i18n').translate('the.data.was.saved.successfully') : app.get('i18n').translate('the.data.was.updated.successfully');

                                if (('message' in response) && response.message !== '') {
                                    msg = response.message;
                                }

								if (!el.retrieve('xhr-form-progress')) {
                                	self.setStatus(el, msg, 'success');
                                }

                                if (('values' in response) && typeof response.values === 'object') {
                                	Object.each(response.values, function(val, key) {
                                		var formEl = el.getElement('[name="' + key + '"]');

                                		if (formEl) {
                                			formEl.set('value', val);
                                		}
                                	});
                                }

                                el.store('originalFormData', el.toQueryString().parseQueryString());

								// callback
                                if (typeof el.retrieve('success_callback') == 'function') {
									if (!el.retrieve('xhr-form-progress')) {
                                    	self.unsetLoader(el, false);
                                    }

                                    el.retrieve('success_callback')(response, el, e, self);
                                    return;
                                }

                                var redirectDelay = (el.get('data-redirect-delay')) ? el.get('data-redirect-delay') : 1000;

								// redirect
                                if ('redirect' in response && response.redirect !== '') {
                                    (function(){
                                        window.location.href = app.get('webhost') + response.redirect;
                                    }).delay(redirectDelay);
                                    return;
                                }

                                if (reload === '1') {
                                    self.unsetLoader(el, true);
                                	window.setTimeout(function() {
                                		window.location.reload(true);
                                	}, 2500);
                                    return;
                                }

								// modal
                                var modal = el.getParent('.modal');

                                if (modal) {
                                	var grid = modal.retrieve('modal.trigger').getParent('.mt-grid-table');

                                	grid && app.get('grid').reload(null, grid);

                                    (function() {
                                        self.unsetLoader(el);
                                        app.get('modal').close(modal);
                                    }).delay(redirectDelay);

                                	return;
                                }

								// reload
                                if ((response.method == 'insert' && reload !== "0")) {
                                	window.setTimeout(function() {
                                		window.location.reload(true);
                                	}, 2500);
                                    return;
                                }

								// nothing but hide the message
								if (!keepMessage) {
                                    (function(){
                                        self.unsetStatus(el, true);
                                    }).delay(2500);
                                }
                        	break;
                        }

                        removeStatusLoaderCallback();
                    }
                });

				var uploadedFiles = 0;
				var fileUpload    = null;
                // first step upload files
                if (el.getElements('[type="file"]').length > 0) {
					var fileUpload = new XMLHttpRequest();

					fileUpload.open('POST', action, true);

					fileUpload.upload.onprogress = function(e) {
						if (e.lengthComputable) {
							var percentComplete = (e.loaded / e.total) * 100;

							if (typeof el.retrieve('onprogress_callback') === 'function') {
								el.retrieve('onprogress_callback')(e);
							}

							if (el.retrieve('form-alerts') !== null && el.retrieve('form-alerts').get('alerts').getLength() > 0) {
					            el.retrieve('form-alerts').get('alerts').each(function(formAlert) {
					            	if (formAlert.options.persistent) {
					            		return;
					            	}

					            	formAlert.elements.each(function(formAlertElement) {
										var processElement = formAlertElement.getElement('.process-element');

										if (!processElement) {
											processElement = new Element('span', {
												'class' : 'process-element'
											}).inject(formAlertElement.getElement('span'), 'bottom');
										}

										processElement.set('html', ' (' + app.get('i18n').formatPercent(percentComplete, {multiplier: 1}) + ' ' + app.get('i18n').translate('uploaded') + ')');
					            	});
					            });
							}
						}
					};

					fileUpload.onload = function() {
                        self.unsetLoader(el);
                        var json = {};

                        try {
					     	json = JSON.decode(this.response);
                        } catch (err) {
                        	json = false;
                        }

					    if (json !== false && this.status == 200 && json.status !== 'error') {
					     	var json = JSON.decode(this.response);
							form     = el;

					     	Object.each(json.files, function(fileData, fileElementName) {
					     		var elementWrapper = el.getElement('.form-file-wrapper[data-for-file="' + fileElementName + '"]');

					     		var formNameEl = el.getElement('[name="' + fileElementName + '"]');

					     		if (formNameEl) {
					     			formNameEl.set('data-old-value', formNameEl.get('value'));

									formNameEl.set('value', fileData.tmp_name);
					     		}

					     		var fileNameWrapper = elementWrapper.getElement('[data-value="file_name"]');

								if (fileNameWrapper) {
									//fileNameWrapper.set('html', fileData.name.replace(/.+?\//, ''));
								}

								//elementWrapper.removeClass('hide');
					     	});

				     		el.getElements('[type="file"]').each(function(fileEl) {
				     			fileEl.set('value', '');
				     		});

				     		request.setOptions({'data' : el.toQueryString()});

				     		request.send();
					    } else {
				     		el.getElements('[type="file"]').each(function(fileEl) {
				     			fileEl.set('value', '');
				     			fileEl.removeAttribute('disabled');
				     		});

                            self.setStatus(el, app.get('i18n').translate('there.were.errors.uploading.the.files'), 'danger');
                            self.unsetLoader(el);
					    }
					  };

					var fd = new FormData();

	                fd.append('form_id', el.getElement('[name="form_id"]').get('value'));

	                fd.append('method', 'form-upload-only');

	                el.getElements('[type="file"]').each(function(fileEl) {
	                    el.getElement('[name="' + fileEl.get('name') + '"]').set('value', '');

	                	if (!fileEl.files[0]) {
	                		fileEl.set('disabled', 'true');
	                		return;
	                	}

	                	fd.append(fileEl.get('name'), fileEl.files[0]);

	                	uploadedFiles++;
	                });
  				}

                if (uploadedFiles > 0) {
					fileUpload.setRequestHeader('X-Requested-With', 'XMLHttpRequest');

	  				fileUpload.send(fd);
  				} else {
                    request.send();
  				}

                return false;
            }.bind(this)
        });

        this.initFixedMessages(forms);
    },

    initFixedMessages : function(forms) {
    	var self = this;

        window.addEvent('resize', function(e) {
        	this.each(function(form) {
        		if (form.retrieve('form-alerts') == null) {
        			return;
        		}

	        	form.retrieve('form-alerts').get("wrapper").each(function(wrapper) {
	        		if (wrapper.position == 'fixed') {
	        			wrapper.element.getElements(".mt-form-alert").setStyle('width', wrapper.getCoordinates().width);
	        		}
	        	});
        	});

        }.bind(forms));

        document.addEvent('scroll', function(e) {
        	this.each(function(form) {
        		if (form.retrieve('form-alerts') == null || form.retrieve('form-alerts').get('alerts').getLength() === 0) {
        			return;
        		}

            	self.checkFixedMessages(form);
          });
        }.bind(forms));
    },

    getFieldOptions: function(options) {
        var defaultOptions = {
            type      : 'disabled',
            keepValue : true,
            dummy     : true
        };

        if (typeof options === 'undefined') {
            options = {};
        }

        options = Object.assign({}, defaultOptions, options);

        if (typeof options.classes === 'undefined') {
            options.classes = options.type;
        }

        return options;
    },

    disableFields: function(elements, options) {
        options = this.getFieldOptions(options);

        if (elements instanceof Element) {
            elements = [elements];
        } else {
            elements = [].slice.call(elements);
        }

        elements.each(function(element) {
            var groupElement  = element.getParent('.form-group'),
                addonElements = groupElement.getElements('.flex-addon'),
                errorElements = groupElement.getElements('.error-message-el'),
                dummyElement  = groupElement.getElement('#dummy-' + element.get('id'));

            if (!element.get(options.type)) {
                element.set(options.type, true).addClass(options.classes);

                if (addonElements) {
                    addonElements.set(options.type, true).addClass(options.classes);
                }

                if (options.keepValue) {
                    element.store('data-value', element.get('value')).set('value', '');
                }

                if (options.dummy && !dummyElement) {
                    groupElement.grab(new Element('input', {
                        id    : 'dummy-' + element.get('id'),
                        name  : element.get('name'),
                        type  : 'hidden',
                        value : ''
                    }), 'top');
                }
            }

            if (groupElement) {
                groupElement.removeClass('error');
            }

            if (errorElements) {
                errorElements.destroy();
            }
        });
    },

    enableFields: function(elements, options) {
        options = this.getFieldOptions(options);

        if (elements instanceof Element) {
            elements = [elements];
        } else {
            elements = [].slice.call(elements);
        }

        elements.each(function(element) {
            var groupElement  = element.getParent('.form-group'),
                addonElements = groupElement.getElements('.flex-addon'),
                dummyElement  = groupElement.getElement('#dummy-' + element.get('id'));

            element.set(options.type, false).removeClass(options.classes);

            if (addonElements) {
                addonElements.set(options.type, false).removeClass(options.classes);
            }

            if (options.keepValue && !element.get('value')) {
                element.set('value', element.retrieve('data-value'));
            }

            if (dummyElement) {
                dummyElement.destroy();
            }
        });
    },

    // common Callbacks
    copyPlaceholder : function(target) {
        if (!target.get('value')) {
            target.set('value', target.get('placeholder'));
        }
    }
};


var XmlHttpRequest = {};

["", "JSON", "HTML"].each(function(reqType) {
	var ExtObj = Request;

	if (reqType !== '') {
		ExtObj = Request[reqType];
	}

	var XhrClass = new Class({
		Extends : ExtObj,

		send : function(options) {
			this.parent(options);

			var currCB = this.xhr.onreadystatechange;

		    this.xhr.onreadystatechange = function() {
				if (this.xhr.readyState === 4 && this.xhr.responseText.indexOf('mt-login-form') > -1) {
	        	    if (confirm(app.get('i18n').translate('you.have.now.been.logged.out.switch.to.login'))) {
	        		    location.reload();
	        		}

					if ('error' in this.$events) {
	        			this.fireEvent('error', this.xhr);
		        	} else {
	        			this.fireEvent('failure', this.xhr);
		        	}
	        		return;
	        	}

        		currCB();
	     	}.bind(this);

	     	return this;
		}
	});

	if (reqType !== '') {
		XmlHttpRequest[reqType] = XhrClass;
	} else {
		XmlHttpRequest = XhrClass;
	}
});


var CSSJSON=new function(){var k=this;k.init=function(){String.prototype.trim=function(){return this.replace(/^\s+|\s+$/g,"")};String.prototype.repeat=function(d){return Array(1+d).join(this)}};k.init();var m=/\/\*[\s\S]*?\*\//g,n=/([^\:]+):([^\;]*);/,p=/(\/\*[\s\S]*?\*\/)|([^\s\;\{\}][^\;\{\}]*(?=\{))|(\})|([^\;\{\}]+\;(?!\s*\*\/))/gmi,l=function(d){return"undefined"==typeof d||0==d.length||null==d};k.toJSON=function(d,f){var e={children:{},attributes:{}},a=null,g=0;"undefined"==typeof f&&(f={ordered:!1,
comments:!1,stripComments:!1,split:!1});f.stripComments&&(f.comments=!1,d=d.replace(m,""));for(;null!=(a=p.exec(d));)if(!l(a[1])&&f.comments)a=a[1].trim(),e[g++]=a;else if(l(a[2]))if(l(a[3]))l(a[4])||(a=a[4].trim(),(c=n.exec(a))?(a=c[1].trim(),c=c[2].trim(),f.ordered?(b={},b.name=a,b.value=c,b.type="attr",e[g++]=b):a in e.attributes?(b=e.attributes[a],b instanceof Array||(e.attributes[a]=[b]),e.attributes[a].push(c)):e.attributes[a]=c):e[g++]=a);else break;else{var a=a[2].trim(),c=k.toJSON(d,f);if(f.ordered){var b=
{};b.name=a;b.value=c;b.type="rule";e[g++]=b}else for(i in a=f.split?a.split(","):[a],a)if(a.hasOwnProperty(i))if(b=a[i].trim(),b in e.children)for(var h in c.attributes)e.children[b].attributes[h]=c.attributes[h];else e.children[b]=c}return e};k.toCSS=function(d,f,e){var a="";"undefined"==typeof f&&(f=0);"undefined"==typeof e&&(e=!1);if(d.attributes)for(i in d.attributes){var g=d.attributes[i];if(g instanceof Array)for(var c=0;c<g.length;c++){var b;b=i;var h=g[c];b="\t".repeat(f)+b+": "+h+";\n";
a+=b}else c=a,a=i,g="\t".repeat(f)+a+": "+g+";\n",a=c+g}if(d.children)for(i in g=!0,d.children)e&&!g?a+="\n":g=!1,c=a,h=i,a=d.children[i],b=f,h="\t".repeat(b)+h+" {\n",h+=k.toCSS(a,b+1),h+="\t".repeat(b)+"}\n",a=c+h;return a}};

"use strict";

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/*
 *
 * More info at [www.dropzonejs.com](http://www.dropzonejs.com)
 *
 * Copyright (c) 2012, Matias Meno
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 */

// The Emitter class provides the ability to call `.on()` on Dropzone to listen
// to events.
// It is strongly based on component's emitter class, and I removed the
// functionality because of the dependency hell with different frameworks.
var Emitter = function () {
  function Emitter() {
    _classCallCheck(this, Emitter);
  }

  _createClass(Emitter, [{
    key: "on",

    // Add an event listener for given event
    value: function on(event, fn) {
      this._callbacks = this._callbacks || {};
      // Create namespace for this event
      if (!this._callbacks[event]) {
        this._callbacks[event] = [];
      }
      this._callbacks[event].push(fn);
      return this;
    }
  }, {
    key: "emit",
    value: function emit(event) {
      this._callbacks = this._callbacks || {};
      var callbacks = this._callbacks[event];

      if (callbacks) {
        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          args[_key - 1] = arguments[_key];
        }

        for (var _iterator = callbacks, _isArray = true, _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
          var _ref;

          if (_isArray) {
            if (_i >= _iterator.length) break;
            _ref = _iterator[_i++];
          } else {
            _i = _iterator.next();
            if (_i.done) break;
            _ref = _i.value;
          }

          var callback = _ref;

          callback.apply(this, args);
        }
      }

      return this;
    }

    // Remove event listener for given event. If fn is not provided, all event
    // listeners for that event will be removed. If neither is provided, all
    // event listeners will be removed.

  }, {
    key: "off",
    value: function off(event, fn) {
      if (!this._callbacks || arguments.length === 0) {
        this._callbacks = {};
        return this;
      }

      // specific event
      var callbacks = this._callbacks[event];
      if (!callbacks) {
        return this;
      }

      // remove all handlers
      if (arguments.length === 1) {
        delete this._callbacks[event];
        return this;
      }

      // remove specific handler
      for (var i = 0; i < callbacks.length; i++) {
        var callback = callbacks[i];
        if (callback === fn) {
          callbacks.splice(i, 1);
          break;
        }
      }

      return this;
    }
  }]);

  return Emitter;
}();

var Dropzone = function (_Emitter) {
  _inherits(Dropzone, _Emitter);

  _createClass(Dropzone, null, [{
    key: "initClass",
    value: function initClass() {

      // Exposing the emitter class, mainly for tests
      this.prototype.Emitter = Emitter;

      /*
       This is a list of all available events you can register on a dropzone object.
        You can register an event handler like this:
        dropzone.on("dragEnter", function() { });
        */
      this.prototype.events = ["drop", "dragstart", "dragend", "dragenter", "dragover", "dragleave", "addedfile", "addedfiles", "removedfile", "thumbnail", "error", "errormultiple", "processing", "processingmultiple", "uploadprogress", "totaluploadprogress", "sending", "sendingmultiple", "success", "successmultiple", "canceled", "canceledmultiple", "complete", "completemultiple", "reset", "maxfilesexceeded", "maxfilesreached", "queuecomplete"];

      this.prototype.defaultOptions = {
        /**
         * Has to be specified on elements other than form (or when the form
         * doesn't have an `action` attribute). You can also
         * provide a function that will be called with `files` and
         * must return the url (since `v3.12.0`)
         */
        url: null,

        /**
         * Can be changed to `"put"` if necessary. You can also provide a function
         * that will be called with `files` and must return the method (since `v3.12.0`).
         */
        method: "post",

        /**
         * Will be set on the XHRequest.
         */
        withCredentials: false,

        /**
         * The timeout for the XHR requests in milliseconds (since `v4.4.0`).
         */
        timeout: 30000,

        /**
         * How many file uploads to process in parallel (See the
         * Enqueuing file uploads* documentation section for more info)
         */
        parallelUploads: 2,

        /**
         * Whether to send multiple files in one request. If
         * this it set to true, then the fallback file input element will
         * have the `multiple` attribute as well. This option will
         * also trigger additional events (like `processingmultiple`). See the events
         * documentation section for more information.
         */
        uploadMultiple: false,

        /**
         * Whether you want files to be uploaded in chunks to your server. This can't be
         * used in combination with `uploadMultiple`.
         *
         * See [chunksUploaded](#config-chunksUploaded) for the callback to finalise an upload.
         */
        chunking: false,

        /**
         * If `chunking` is enabled, this defines whether **every** file should be chunked,
         * even if the file size is below chunkSize. This means, that the additional chunk
         * form data will be submitted and the `chunksUploaded` callback will be invoked.
         */
        forceChunking: false,

        /**
         * If `chunking` is `true`, then this defines the chunk size in bytes.
         */
        chunkSize: 2000000,

        /**
         * If `true`, the individual chunks of a file are being uploaded simultaneously.
         */
        parallelChunkUploads: false,

        /**
         * Whether a chunk should be retried if it fails.
         */
        retryChunks: false,

        /**
         * If `retryChunks` is true, how many times should it be retried.
         */
        retryChunksLimit: 3,

        /**
         * If not `null` defines how many files this Dropzone handles. If it exceeds,
         * the event `maxfilesexceeded` will be called. The dropzone element gets the
         * class `dz-max-files-reached` accordingly so you can provide visual feedback.
         */
        maxFilesize: 256,

        /**
         * The name of the file param that gets transferred.
         * **NOTE**: If you have the option  `uploadMultiple` set to `true`, then
         * Dropzone will append `[]` to the name.
         */
        paramName: "file",

        /**
         * Whether thumbnails for images should be generated
         */
        createImageThumbnails: true,

        /**
         * In MB. When the filename exceeds this limit, the thumbnail will not be generated.
         */
        maxThumbnailFilesize: 10,

        /**
         * If `null`, the ratio of the image will be used to calculate it.
         */
        thumbnailWidth: 120,

        /**
         * The same as `thumbnailWidth`. If both are null, images will not be resized.
         */
        thumbnailHeight: 120,

        /**
         * How the images should be scaled down in case both, `thumbnailWidth` and `thumbnailHeight` are provided.
         * Can be either `contain` or `crop`.
         */
        thumbnailMethod: 'crop',

        /**
         * If set, images will be resized to these dimensions before being **uploaded**.
         * If only one, `resizeWidth` **or** `resizeHeight` is provided, the original aspect
         * ratio of the file will be preserved.
         *
         * The `options.transformFile` function uses these options, so if the `transformFile` function
         * is overridden, these options don't do anything.
         */
        resizeWidth: null,

        /**
         * See `resizeWidth`.
         */
        resizeHeight: null,

        /**
         * The mime type of the resized image (before it gets uploaded to the server).
         * If `null` the original mime type will be used. To force jpeg, for example, use `image/jpeg`.
         * See `resizeWidth` for more information.
         */
        resizeMimeType: null,

        /**
         * The quality of the resized images. See `resizeWidth`.
         */
        resizeQuality: 0.8,

        /**
         * How the images should be scaled down in case both, `resizeWidth` and `resizeHeight` are provided.
         * Can be either `contain` or `crop`.
         */
        resizeMethod: 'contain',

        /**
         * The base that is used to calculate the filesize. You can change this to
         * 1024 if you would rather display kibibytes, mebibytes, etc...
         * 1024 is technically incorrect, because `1024 bytes` are `1 kibibyte` not `1 kilobyte`.
         * You can change this to `1024` if you don't care about validity.
         */
        filesizeBase: 1000,

        /**
         * Can be used to limit the maximum number of files that will be handled by this Dropzone
         */
        maxFiles: null,

        /**
         * An optional object to send additional headers to the server. Eg:
         * `{ "My-Awesome-Header": "header value" }`
         */
        headers: null,

        /**
         * If `true`, the dropzone element itself will be clickable, if `false`
         * nothing will be clickable.
         *
         * You can also pass an HTML element, a CSS selector (for multiple elements)
         * or an array of those. In that case, all of those elements will trigger an
         * upload when clicked.
         */
        clickable: true,

        /**
         * Whether hidden files in directories should be ignored.
         */
        ignoreHiddenFiles: true,

        /**
         * The default implementation of `accept` checks the file's mime type or
         * extension against this list. This is a comma separated list of mime
         * types or file extensions.
         *
         * Eg.: `image/*,application/pdf,.psd`
         *
         * If the Dropzone is `clickable` this option will also be used as
         * [`accept`](https://developer.mozilla.org/en-US/docs/HTML/Element/input#attr-accept)
         * parameter on the hidden file input as well.
         */
        acceptedFiles: null,

        /**
         * **Deprecated!**
         * Use acceptedFiles instead.
         */
        acceptedMimeTypes: null,

        /**
         * If false, files will be added to the queue but the queue will not be
         * processed automatically.
         * This can be useful if you need some additional user input before sending
         * files (or if you want want all files sent at once).
         * If you're ready to send the file simply call `myDropzone.processQueue()`.
         *
         * See the [enqueuing file uploads](#enqueuing-file-uploads) documentation
         * section for more information.
         */
        autoProcessQueue: true,

        /**
         * If false, files added to the dropzone will not be queued by default.
         * You'll have to call `enqueueFile(file)` manually.
         */
        autoQueue: true,

        /**
         * If `true`, this will add a link to every file preview to remove or cancel (if
         * already uploading) the file. The `dictCancelUpload`, `dictCancelUploadConfirmation`
         * and `dictRemoveFile` options are used for the wording.
         */
        addRemoveLinks: false,

        /**
         * Defines where to display the file previews – if `null` the
         * Dropzone element itself is used. Can be a plain `HTMLElement` or a CSS
         * selector. The element should have the `dropzone-previews` class so
         * the previews are displayed properly.
         */
        previewsContainer: null,

        /**
         * This is the element the hidden input field (which is used when clicking on the
         * dropzone to trigger file selection) will be appended to. This might
         * be important in case you use frameworks to switch the content of your page.
         */
        hiddenInputContainer: "body",

        /**
         * If null, no capture type will be specified
         * If camera, mobile devices will skip the file selection and choose camera
         * If microphone, mobile devices will skip the file selection and choose the microphone
         * If camcorder, mobile devices will skip the file selection and choose the camera in video mode
         * On apple devices multiple must be set to false.  AcceptedFiles may need to
         * be set to an appropriate mime type (e.g. "image/*", "audio/*", or "video/*").
         */
        capture: null,

        /**
         * **Deprecated**. Use `renameFile` instead.
         */
        renameFilename: null,

        /**
         * A function that is invoked before the file is uploaded to the server and renames the file.
         * This function gets the `File` as argument and can use the `file.name`. The actual name of the
         * file that gets used during the upload can be accessed through `file.upload.filename`.
         */
        renameFile: null,

        /**
         * If `true` the fallback will be forced. This is very useful to test your server
         * implementations first and make sure that everything works as
         * expected without dropzone if you experience problems, and to test
         * how your fallbacks will look.
         */
        forceFallback: false,

        /**
         * The text used before any files are dropped.
         */
        dictDefaultMessage: "Drop files here to upload",

        /**
         * The text that replaces the default message text it the browser is not supported.
         */
        dictFallbackMessage: "Your browser does not support drag'n'drop file uploads.",

        /**
         * The text that will be added before the fallback form.
         * If you provide a  fallback element yourself, or if this option is `null` this will
         * be ignored.
         */
        dictFallbackText: "Please use the fallback form below to upload your files like in the olden days.",

        /**
         * If the filesize is too big.
         * `{{filesize}}` and `{{maxFilesize}}` will be replaced with the respective configuration values.
         */
        dictFileTooBig: "File is too big ({{filesize}}MiB). Max filesize: {{maxFilesize}}MiB.",

        /**
         * If the file doesn't match the file type.
         */
        dictInvalidFileType: "You can't upload files of this type.",

        /**
         * If the server response was invalid.
         * `{{statusCode}}` will be replaced with the servers status code.
         */
        dictResponseError: "Server responded with {{statusCode}} code.",

        /**
         * If `addRemoveLinks` is true, the text to be used for the cancel upload link.
         */
        dictCancelUpload: "Cancel upload",

        /**
         * The text that is displayed if an upload was manually canceled
         */
        dictUploadCanceled: "Upload canceled.",

        /**
         * If `addRemoveLinks` is true, the text to be used for confirmation when cancelling upload.
         */
        dictCancelUploadConfirmation: "Are you sure you want to cancel this upload?",

        /**
         * If `addRemoveLinks` is true, the text to be used to remove a file.
         */
        dictRemoveFile: "Remove file",

        /**
         * If this is not null, then the user will be prompted before removing a file.
         */
        dictRemoveFileConfirmation: null,

        /**
         * Displayed if `maxFiles` is st and exceeded.
         * The string `{{maxFiles}}` will be replaced by the configuration value.
         */
        dictMaxFilesExceeded: "You can not upload any more files.",

        /**
         * Allows you to translate the different units. Starting with `tb` for terabytes and going down to
         * `b` for bytes.
         */
        dictFileSizeUnits: { tb: "TB", gb: "GB", mb: "MB", kb: "KB", b: "b" },
        /**
         * Called when dropzone initialized
         * You can add event listeners here
         */
        init: function init() {},


        /**
         * Can be an **object** of additional parameters to transfer to the server, **or** a `Function`
         * that gets invoked with the `files`, `xhr` and, if it's a chunked upload, `chunk` arguments. In case
         * of a function, this needs to return a map.
         *
         * The default implementation does nothing for normal uploads, but adds relevant information for
         * chunked uploads.
         *
         * This is the same as adding hidden input fields in the form element.
         */
        params: function params(files, xhr, chunk) {
          if (chunk) {
            return {
              dzuuid: chunk.file.upload.uuid,
              dzchunkindex: chunk.index,
              dztotalfilesize: chunk.file.size,
              dzchunksize: this.options.chunkSize,
              dztotalchunkcount: chunk.file.upload.totalChunkCount,
              dzchunkbyteoffset: chunk.index * this.options.chunkSize
            };
          }
        },


        /**
         * A function that gets a [file](https://developer.mozilla.org/en-US/docs/DOM/File)
         * and a `done` function as parameters.
         *
         * If the done function is invoked without arguments, the file is "accepted" and will
         * be processed. If you pass an error message, the file is rejected, and the error
         * message will be displayed.
         * This function will not be called if the file is too big or doesn't match the mime types.
         */
        accept: function accept(file, done) {
          return done();
        },


        /**
         * The callback that will be invoked when all chunks have been uploaded for a file.
         * It gets the file for which the chunks have been uploaded as the first parameter,
         * and the `done` function as second. `done()` needs to be invoked when everything
         * needed to finish the upload process is done.
         */
        chunksUploaded: function chunksUploaded(file, done) {
          done();
        },

        /**
         * Gets called when the browser is not supported.
         * The default implementation shows the fallback input field and adds
         * a text.
         */
        fallback: function fallback() {
          // This code should pass in IE7... :(
          var messageElement = void 0;
          this.element.className = this.element.className + " dz-browser-not-supported";

          for (var _iterator2 = this.element.getElementsByTagName("div"), _isArray2 = true, _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
            var _ref2;

            if (_isArray2) {
              if (_i2 >= _iterator2.length) break;
              _ref2 = _iterator2[_i2++];
            } else {
              _i2 = _iterator2.next();
              if (_i2.done) break;
              _ref2 = _i2.value;
            }

            var child = _ref2;

            if (/(^| )dz-message($| )/.test(child.className)) {
              messageElement = child;
              child.className = "dz-message"; // Removes the 'dz-default' class
              break;
            }
          }
          if (!messageElement) {
            messageElement = Dropzone.createElement("<div class=\"dz-message\"><span></span></div>");
            this.element.appendChild(messageElement);
          }

          var span = messageElement.getElementsByTagName("span")[0];
          if (span) {
            if (span.textContent != null) {
              span.textContent = this.options.dictFallbackMessage;
            } else if (span.innerText != null) {
              span.innerText = this.options.dictFallbackMessage;
            }
          }

          return this.element.appendChild(this.getFallbackForm());
        },


        /**
         * Gets called to calculate the thumbnail dimensions.
         *
         * It gets `file`, `width` and `height` (both may be `null`) as parameters and must return an object containing:
         *
         *  - `srcWidth` & `srcHeight` (required)
         *  - `trgWidth` & `trgHeight` (required)
         *  - `srcX` & `srcY` (optional, default `0`)
         *  - `trgX` & `trgY` (optional, default `0`)
         *
         * Those values are going to be used by `ctx.drawImage()`.
         */
        resize: function resize(file, width, height, resizeMethod) {
          var info = {
            srcX: 0,
            srcY: 0,
            srcWidth: file.width,
            srcHeight: file.height
          };

          var srcRatio = file.width / file.height;

          // Automatically calculate dimensions if not specified
          if (width == null && height == null) {
            width = info.srcWidth;
            height = info.srcHeight;
          } else if (width == null) {
            width = height * srcRatio;
          } else if (height == null) {
            height = width / srcRatio;
          }

          // Make sure images aren't upscaled
          width = Math.min(width, info.srcWidth);
          height = Math.min(height, info.srcHeight);

          var trgRatio = width / height;

          if (info.srcWidth > width || info.srcHeight > height) {
            // Image is bigger and needs rescaling
            if (resizeMethod === 'crop') {
              if (srcRatio > trgRatio) {
                info.srcHeight = file.height;
                info.srcWidth = info.srcHeight * trgRatio;
              } else {
                info.srcWidth = file.width;
                info.srcHeight = info.srcWidth / trgRatio;
              }
            } else if (resizeMethod === 'contain') {
              // Method 'contain'
              if (srcRatio > trgRatio) {
                height = width / srcRatio;
              } else {
                width = height * srcRatio;
              }
            } else {
              throw new Error("Unknown resizeMethod '" + resizeMethod + "'");
            }
          }

          info.srcX = (file.width - info.srcWidth) / 2;
          info.srcY = (file.height - info.srcHeight) / 2;

          info.trgWidth = width;
          info.trgHeight = height;

          return info;
        },


        /**
         * Can be used to transform the file (for example, resize an image if necessary).
         *
         * The default implementation uses `resizeWidth` and `resizeHeight` (if provided) and resizes
         * images according to those dimensions.
         *
         * Gets the `file` as the first parameter, and a `done()` function as the second, that needs
         * to be invoked with the file when the transformation is done.
         */
        transformFile: function transformFile(file, done) {
          if ((this.options.resizeWidth || this.options.resizeHeight) && file.type.match(/image.*/)) {
            return this.resizeImage(file, this.options.resizeWidth, this.options.resizeHeight, this.options.resizeMethod, done);
          } else {
            return done(file);
          }
        },


        /**
         * A string that contains the template used for each dropped
         * file. Change it to fulfill your needs but make sure to properly
         * provide all elements.
         *
         * If you want to use an actual HTML element instead of providing a String
         * as a config option, you could create a div with the id `tpl`,
         * put the template inside it and provide the element like this:
         *
         *     document
         *       .querySelector('#tpl')
         *       .innerHTML
         *
         */
        previewTemplate: "<div class=\"dz-preview dz-file-preview\">\n  <div class=\"dz-image\"><img data-dz-thumbnail /></div>\n  <div class=\"dz-details\">\n    <div class=\"dz-size\"><span data-dz-size></span></div>\n    <div class=\"dz-filename\"><span data-dz-name></span></div>\n  </div>\n  <div class=\"dz-progress\"><span class=\"dz-upload\" data-dz-uploadprogress></span></div>\n  <div class=\"dz-error-message\"><span data-dz-errormessage></span></div>\n  <div class=\"dz-success-mark\">\n    <svg width=\"54px\" height=\"54px\" viewBox=\"0 0 54 54\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" xmlns:sketch=\"http://www.bohemiancoding.com/sketch/ns\">\n      <title>Check</title>\n      <defs></defs>\n      <g id=\"Page-1\" stroke=\"none\" stroke-width=\"1\" fill=\"none\" fill-rule=\"evenodd\" sketch:type=\"MSPage\">\n        <path d=\"M23.5,31.8431458 L17.5852419,25.9283877 C16.0248253,24.3679711 13.4910294,24.366835 11.9289322,25.9289322 C10.3700136,27.4878508 10.3665912,30.0234455 11.9283877,31.5852419 L20.4147581,40.0716123 C20.5133999,40.1702541 20.6159315,40.2626649 20.7218615,40.3488435 C22.2835669,41.8725651 24.794234,41.8626202 26.3461564,40.3106978 L43.3106978,23.3461564 C44.8771021,21.7797521 44.8758057,19.2483887 43.3137085,17.6862915 C41.7547899,16.1273729 39.2176035,16.1255422 37.6538436,17.6893022 L23.5,31.8431458 Z M27,53 C41.3594035,53 53,41.3594035 53,27 C53,12.6405965 41.3594035,1 27,1 C12.6405965,1 1,12.6405965 1,27 C1,41.3594035 12.6405965,53 27,53 Z\" id=\"Oval-2\" stroke-opacity=\"0.198794158\" stroke=\"#747474\" fill-opacity=\"0.816519475\" fill=\"#FFFFFF\" sketch:type=\"MSShapeGroup\"></path>\n      </g>\n    </svg>\n  </div>\n  <div class=\"dz-error-mark\">\n    <svg width=\"54px\" height=\"54px\" viewBox=\"0 0 54 54\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" xmlns:sketch=\"http://www.bohemiancoding.com/sketch/ns\">\n      <title>Error</title>\n      <defs></defs>\n      <g id=\"Page-1\" stroke=\"none\" stroke-width=\"1\" fill=\"none\" fill-rule=\"evenodd\" sketch:type=\"MSPage\">\n        <g id=\"Check-+-Oval-2\" sketch:type=\"MSLayerGroup\" stroke=\"#747474\" stroke-opacity=\"0.198794158\" fill=\"#FFFFFF\" fill-opacity=\"0.816519475\">\n          <path d=\"M32.6568542,29 L38.3106978,23.3461564 C39.8771021,21.7797521 39.8758057,19.2483887 38.3137085,17.6862915 C36.7547899,16.1273729 34.2176035,16.1255422 32.6538436,17.6893022 L27,23.3431458 L21.3461564,17.6893022 C19.7823965,16.1255422 17.2452101,16.1273729 15.6862915,17.6862915 C14.1241943,19.2483887 14.1228979,21.7797521 15.6893022,23.3461564 L21.3431458,29 L15.6893022,34.6538436 C14.1228979,36.2202479 14.1241943,38.7516113 15.6862915,40.3137085 C17.2452101,41.8726271 19.7823965,41.8744578 21.3461564,40.3106978 L27,34.6568542 L32.6538436,40.3106978 C34.2176035,41.8744578 36.7547899,41.8726271 38.3137085,40.3137085 C39.8758057,38.7516113 39.8771021,36.2202479 38.3106978,34.6538436 L32.6568542,29 Z M27,53 C41.3594035,53 53,41.3594035 53,27 C53,12.6405965 41.3594035,1 27,1 C12.6405965,1 1,12.6405965 1,27 C1,41.3594035 12.6405965,53 27,53 Z\" id=\"Oval-2\" sketch:type=\"MSShapeGroup\"></path>\n        </g>\n      </g>\n    </svg>\n  </div>\n</div>",

        // END OPTIONS
        // (Required by the dropzone documentation parser)


        /*
         Those functions register themselves to the events on init and handle all
         the user interface specific stuff. Overwriting them won't break the upload
         but can break the way it's displayed.
         You can overwrite them if you don't like the default behavior. If you just
         want to add an additional event handler, register it on the dropzone object
         and don't overwrite those options.
         */

        // Those are self explanatory and simply concern the DragnDrop.
        drop: function drop(e) {
          return this.element.classList.remove("dz-drag-hover");
        },
        dragstart: function dragstart(e) {},
        dragend: function dragend(e) {
          return this.element.classList.remove("dz-drag-hover");
        },
        dragenter: function dragenter(e) {
          return this.element.classList.add("dz-drag-hover");
        },
        dragover: function dragover(e) {
          return this.element.classList.add("dz-drag-hover");
        },
        dragleave: function dragleave(e) {
          return this.element.classList.remove("dz-drag-hover");
        },
        paste: function paste(e) {},


        // Called whenever there are no files left in the dropzone anymore, and the
        // dropzone should be displayed as if in the initial state.
        reset: function reset() {
          return this.element.classList.remove("dz-started");
        },


        // Called when a file is added to the queue
        // Receives `file`
        addedfile: function addedfile(file) {
          var _this2 = this;

          if (this.element === this.previewsContainer) {
            this.element.classList.add("dz-started");
          }

          if (this.previewsContainer) {
            file.previewElement = Dropzone.createElement(this.options.previewTemplate.trim());
            file.previewTemplate = file.previewElement; // Backwards compatibility

            this.previewsContainer.appendChild(file.previewElement);
            for (var _iterator3 = file.previewElement.querySelectorAll("[data-dz-name]"), _isArray3 = true, _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
              var _ref3;

              if (_isArray3) {
                if (_i3 >= _iterator3.length) break;
                _ref3 = _iterator3[_i3++];
              } else {
                _i3 = _iterator3.next();
                if (_i3.done) break;
                _ref3 = _i3.value;
              }

              var node = _ref3;

              node.textContent = file.name;
            }
            for (var _iterator4 = file.previewElement.querySelectorAll("[data-dz-size]"), _isArray4 = true, _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
              if (_isArray4) {
                if (_i4 >= _iterator4.length) break;
                node = _iterator4[_i4++];
              } else {
                _i4 = _iterator4.next();
                if (_i4.done) break;
                node = _i4.value;
              }

              node.innerHTML = this.filesize(file.size);
            }

            if (this.options.addRemoveLinks) {
              file._removeLink = Dropzone.createElement("<a class=\"dz-remove\" href=\"javascript:undefined;\" data-dz-remove>" + this.options.dictRemoveFile + "</a>");
              file.previewElement.appendChild(file._removeLink);
            }

            var removeFileEvent = function removeFileEvent(e) {
              e.preventDefault();
              e.stopPropagation();
              if (file.status === Dropzone.UPLOADING) {
                return Dropzone.confirm(_this2.options.dictCancelUploadConfirmation, function () {
                  return _this2.removeFile(file);
                });
              } else {
                if (_this2.options.dictRemoveFileConfirmation) {
                  return Dropzone.confirm(_this2.options.dictRemoveFileConfirmation, function () {
                    return _this2.removeFile(file);
                  });
                } else {
                  return _this2.removeFile(file);
                }
              }
            };

            for (var _iterator5 = file.previewElement.querySelectorAll("[data-dz-remove]"), _isArray5 = true, _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
              var _ref4;

              if (_isArray5) {
                if (_i5 >= _iterator5.length) break;
                _ref4 = _iterator5[_i5++];
              } else {
                _i5 = _iterator5.next();
                if (_i5.done) break;
                _ref4 = _i5.value;
              }

              var removeLink = _ref4;

              removeLink.addEventListener("click", removeFileEvent);
            }
          }
        },


        // Called whenever a file is removed.
        removedfile: function removedfile(file) {
          if (file.previewElement != null && file.previewElement.parentNode != null) {
            file.previewElement.parentNode.removeChild(file.previewElement);
          }
          return this._updateMaxFilesReachedClass();
        },


        // Called when a thumbnail has been generated
        // Receives `file` and `dataUrl`
        thumbnail: function thumbnail(file, dataUrl) {
          if (file.previewElement) {
            file.previewElement.classList.remove("dz-file-preview");
            for (var _iterator6 = file.previewElement.querySelectorAll("[data-dz-thumbnail]"), _isArray6 = true, _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
              var _ref5;

              if (_isArray6) {
                if (_i6 >= _iterator6.length) break;
                _ref5 = _iterator6[_i6++];
              } else {
                _i6 = _iterator6.next();
                if (_i6.done) break;
                _ref5 = _i6.value;
              }

              var thumbnailElement = _ref5;

              thumbnailElement.alt = file.name;
              thumbnailElement.src = dataUrl;
            }

            return setTimeout(function () {
              return file.previewElement.classList.add("dz-image-preview");
            }, 1);
          }
        },


        // Called whenever an error occurs
        // Receives `file` and `message`
        error: function error(file, message) {
          if (file.previewElement) {
            file.previewElement.classList.add("dz-error");
            if (typeof message !== "String" && message.error) {
              message = message.error;
            }
            for (var _iterator7 = file.previewElement.querySelectorAll("[data-dz-errormessage]"), _isArray7 = true, _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) {
              var _ref6;

              if (_isArray7) {
                if (_i7 >= _iterator7.length) break;
                _ref6 = _iterator7[_i7++];
              } else {
                _i7 = _iterator7.next();
                if (_i7.done) break;
                _ref6 = _i7.value;
              }

              var node = _ref6;

              node.textContent = message;
            }
          }
        },
        errormultiple: function errormultiple() {},


        // Called when a file gets processed. Since there is a cue, not all added
        // files are processed immediately.
        // Receives `file`
        processing: function processing(file) {
          if (file.previewElement) {
            file.previewElement.classList.add("dz-processing");
            if (file._removeLink) {
              return file._removeLink.textContent = this.options.dictCancelUpload;
            }
          }
        },
        processingmultiple: function processingmultiple() {},


        // Called whenever the upload progress gets updated.
        // Receives `file`, `progress` (percentage 0-100) and `bytesSent`.
        // To get the total number of bytes of the file, use `file.size`
        uploadprogress: function uploadprogress(file, progress, bytesSent) {
          if (file.previewElement) {
            for (var _iterator8 = file.previewElement.querySelectorAll("[data-dz-uploadprogress]"), _isArray8 = true, _i8 = 0, _iterator8 = _isArray8 ? _iterator8 : _iterator8[Symbol.iterator]();;) {
              var _ref7;

              if (_isArray8) {
                if (_i8 >= _iterator8.length) break;
                _ref7 = _iterator8[_i8++];
              } else {
                _i8 = _iterator8.next();
                if (_i8.done) break;
                _ref7 = _i8.value;
              }

              var node = _ref7;

              node.nodeName === 'PROGRESS' ? node.value = progress : node.style.width = progress + "%";
            }
          }
        },


        // Called whenever the total upload progress gets updated.
        // Called with totalUploadProgress (0-100), totalBytes and totalBytesSent
        totaluploadprogress: function totaluploadprogress() {},


        // Called just before the file is sent. Gets the `xhr` object as second
        // parameter, so you can modify it (for example to add a CSRF token) and a
        // `formData` object to add additional information.
        sending: function sending() {},
        sendingmultiple: function sendingmultiple() {},


        // When the complete upload is finished and successful
        // Receives `file`
        success: function success(file) {
          if (file.previewElement) {
            return file.previewElement.classList.add("dz-success");
          }
        },
        successmultiple: function successmultiple() {},


        // When the upload is canceled.
        canceled: function canceled(file) {
          return this.emit("error", file, this.options.dictUploadCanceled);
        },
        canceledmultiple: function canceledmultiple() {},


        // When the upload is finished, either with success or an error.
        // Receives `file`
        complete: function complete(file) {
          if (file._removeLink) {
            file._removeLink.textContent = this.options.dictRemoveFile;
          }
          if (file.previewElement) {
            return file.previewElement.classList.add("dz-complete");
          }
        },
        completemultiple: function completemultiple() {},
        maxfilesexceeded: function maxfilesexceeded() {},
        maxfilesreached: function maxfilesreached() {},
        queuecomplete: function queuecomplete() {},
        addedfiles: function addedfiles() {}
      };

      this.prototype._thumbnailQueue = [];
      this.prototype._processingThumbnail = false;
    }

    // global utility

  }, {
    key: "extend",
    value: function extend(target) {
      for (var _len2 = arguments.length, objects = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
        objects[_key2 - 1] = arguments[_key2];
      }

      for (var _iterator9 = objects, _isArray9 = true, _i9 = 0, _iterator9 = _isArray9 ? _iterator9 : _iterator9[Symbol.iterator]();;) {
        var _ref8;

        if (_isArray9) {
          if (_i9 >= _iterator9.length) break;
          _ref8 = _iterator9[_i9++];
        } else {
          _i9 = _iterator9.next();
          if (_i9.done) break;
          _ref8 = _i9.value;
        }

        var object = _ref8;

        for (var key in object) {
          var val = object[key];
          target[key] = val;
        }
      }
      return target;
    }
  }]);

  function Dropzone(el, options) {
    _classCallCheck(this, Dropzone);

    var _this = _possibleConstructorReturn(this, (Dropzone.__proto__ || Object.getPrototypeOf(Dropzone)).call(this));

    var fallback = void 0,
        left = void 0;
    _this.element = el;
    // For backwards compatibility since the version was in the prototype previously
    _this.version = Dropzone.version;

    _this.defaultOptions.previewTemplate = _this.defaultOptions.previewTemplate.replace(/\n*/g, "");

    _this.clickableElements = [];
    _this.listeners = [];
    _this.files = []; // All files

    if (typeof _this.element === "string") {
      _this.element = document.querySelector(_this.element);
    }

    // Not checking if instance of HTMLElement or Element since IE9 is extremely weird.
    if (!_this.element || _this.element.nodeType == null) {
      throw new Error("Invalid dropzone element.");
    }

    if (_this.element.dropzone) {
      throw new Error("Dropzone already attached.");
    }

    // Now add this dropzone to the instances.
    Dropzone.instances.push(_this);

    // Put the dropzone inside the element itself.
    _this.element.dropzone = _this;

    var elementOptions = (left = Dropzone.optionsForElement(_this.element)) != null ? left : {};

    _this.options = Dropzone.extend({}, _this.defaultOptions, elementOptions, options != null ? options : {});

    // If the browser failed, just call the fallback and leave
    if (_this.options.forceFallback || !Dropzone.isBrowserSupported()) {
      var _ret;

      return _ret = _this.options.fallback.call(_this), _possibleConstructorReturn(_this, _ret);
    }

    // @options.url = @element.getAttribute "action" unless @options.url?
    if (_this.options.url == null) {
      _this.options.url = _this.element.getAttribute("action");
    }

    if (!_this.options.url) {
      throw new Error("No URL provided.");
    }

    if (_this.options.acceptedFiles && _this.options.acceptedMimeTypes) {
      throw new Error("You can't provide both 'acceptedFiles' and 'acceptedMimeTypes'. 'acceptedMimeTypes' is deprecated.");
    }

    if (_this.options.uploadMultiple && _this.options.chunking) {
      throw new Error('You cannot set both: uploadMultiple and chunking.');
    }

    // Backwards compatibility
    if (_this.options.acceptedMimeTypes) {
      _this.options.acceptedFiles = _this.options.acceptedMimeTypes;
      delete _this.options.acceptedMimeTypes;
    }

    // Backwards compatibility
    if (_this.options.renameFilename != null) {
      _this.options.renameFile = function (file) {
        return _this.options.renameFilename.call(_this, file.name, file);
      };
    }

    _this.options.method = _this.options.method.toUpperCase();

    if ((fallback = _this.getExistingFallback()) && fallback.parentNode) {
      // Remove the fallback
      fallback.parentNode.removeChild(fallback);
    }

    // Display previews in the previewsContainer element or the Dropzone element unless explicitly set to false
    if (_this.options.previewsContainer !== false) {
      if (_this.options.previewsContainer) {
        _this.previewsContainer = Dropzone.getElement(_this.options.previewsContainer, "previewsContainer");
      } else {
        _this.previewsContainer = _this.element;
      }
    }

    if (_this.options.clickable) {
      if (_this.options.clickable === true) {
        _this.clickableElements = [_this.element];
      } else {
        _this.clickableElements = Dropzone.getElements(_this.options.clickable, "clickable");
      }
    }

    _this.init();
    return _this;
  }

  // Returns all files that have been accepted


  _createClass(Dropzone, [{
    key: "getAcceptedFiles",
    value: function getAcceptedFiles() {
      return this.files.filter(function (file) {
        return file.accepted;
      }).map(function (file) {
        return file;
      });
    }

    // Returns all files that have been rejected
    // Not sure when that's going to be useful, but added for completeness.

  }, {
    key: "getRejectedFiles",
    value: function getRejectedFiles() {
      return this.files.filter(function (file) {
        return !file.accepted;
      }).map(function (file) {
        return file;
      });
    }
  }, {
    key: "getFilesWithStatus",
    value: function getFilesWithStatus(status) {
      return this.files.filter(function (file) {
        return file.status === status;
      }).map(function (file) {
        return file;
      });
    }

    // Returns all files that are in the queue

  }, {
    key: "getQueuedFiles",
    value: function getQueuedFiles() {
      return this.getFilesWithStatus(Dropzone.QUEUED);
    }
  }, {
    key: "getUploadingFiles",
    value: function getUploadingFiles() {
      return this.getFilesWithStatus(Dropzone.UPLOADING);
    }
  }, {
    key: "getAddedFiles",
    value: function getAddedFiles() {
      return this.getFilesWithStatus(Dropzone.ADDED);
    }

    // Files that are either queued or uploading

  }, {
    key: "getActiveFiles",
    value: function getActiveFiles() {
      return this.files.filter(function (file) {
        return file.status === Dropzone.UPLOADING || file.status === Dropzone.QUEUED;
      }).map(function (file) {
        return file;
      });
    }

    // The function that gets called when Dropzone is initialized. You
    // can (and should) setup event listeners inside this function.

  }, {
    key: "init",
    value: function init() {
      var _this3 = this;

      // In case it isn't set already
      if (this.element.tagName === "form") {
        this.element.setAttribute("enctype", "multipart/form-data");
      }

      if (this.element.classList.contains("dropzone") && !this.element.querySelector(".dz-message")) {
        this.element.appendChild(Dropzone.createElement("<div class=\"dz-default dz-message\"><span>" + this.options.dictDefaultMessage + "</span></div>"));
      }

      if (this.clickableElements.length) {
        var setupHiddenFileInput = function setupHiddenFileInput() {
          if (_this3.hiddenFileInput) {
            _this3.hiddenFileInput.parentNode.removeChild(_this3.hiddenFileInput);
          }
          _this3.hiddenFileInput = document.createElement("input");
          _this3.hiddenFileInput.setAttribute("type", "file");
          if (_this3.options.maxFiles === null || _this3.options.maxFiles > 1) {
            _this3.hiddenFileInput.setAttribute("multiple", "multiple");
          }
          _this3.hiddenFileInput.className = "dz-hidden-input";

          if (_this3.options.acceptedFiles !== null) {
            _this3.hiddenFileInput.setAttribute("accept", _this3.options.acceptedFiles);
          }
          if (_this3.options.capture !== null) {
            _this3.hiddenFileInput.setAttribute("capture", _this3.options.capture);
          }

          // Not setting `display="none"` because some browsers don't accept clicks
          // on elements that aren't displayed.
          _this3.hiddenFileInput.style.visibility = "hidden";
          _this3.hiddenFileInput.style.position = "absolute";
          _this3.hiddenFileInput.style.top = "0";
          _this3.hiddenFileInput.style.left = "0";
          _this3.hiddenFileInput.style.height = "0";
          _this3.hiddenFileInput.style.width = "0";
          document.querySelector(_this3.options.hiddenInputContainer).appendChild(_this3.hiddenFileInput);
          return _this3.hiddenFileInput.addEventListener("change", function () {
            var files = _this3.hiddenFileInput.files;

            if (files.length) {
              for (var _iterator10 = files, _isArray10 = true, _i10 = 0, _iterator10 = _isArray10 ? _iterator10 : _iterator10[Symbol.iterator]();;) {
                var _ref9;

                if (_isArray10) {
                  if (_i10 >= _iterator10.length) break;
                  _ref9 = _iterator10[_i10++];
                } else {
                  _i10 = _iterator10.next();
                  if (_i10.done) break;
                  _ref9 = _i10.value;
                }

                var file = _ref9;

                _this3.addFile(file);
              }
            }
            _this3.emit("addedfiles", files);
            return setupHiddenFileInput();
          });
        };
        setupHiddenFileInput();
      }

      this.URL = window.URL !== null ? window.URL : window.webkitURL;

      // Setup all event listeners on the Dropzone object itself.
      // They're not in @setupEventListeners() because they shouldn't be removed
      // again when the dropzone gets disabled.
      for (var _iterator11 = this.events, _isArray11 = true, _i11 = 0, _iterator11 = _isArray11 ? _iterator11 : _iterator11[Symbol.iterator]();;) {
        var _ref10;

        if (_isArray11) {
          if (_i11 >= _iterator11.length) break;
          _ref10 = _iterator11[_i11++];
        } else {
          _i11 = _iterator11.next();
          if (_i11.done) break;
          _ref10 = _i11.value;
        }

        var eventName = _ref10;

        this.on(eventName, this.options[eventName]);
      }

      this.on("uploadprogress", function () {
        return _this3.updateTotalUploadProgress();
      });

      this.on("removedfile", function () {
        return _this3.updateTotalUploadProgress();
      });

      this.on("canceled", function (file) {
        return _this3.emit("complete", file);
      });

      // Emit a `queuecomplete` event if all files finished uploading.
      this.on("complete", function (file) {
        if (_this3.getAddedFiles().length === 0 && _this3.getUploadingFiles().length === 0 && _this3.getQueuedFiles().length === 0) {
          // This needs to be deferred so that `queuecomplete` really triggers after `complete`
          return setTimeout(function () {
            return _this3.emit("queuecomplete");
          }, 0);
        }
      });

      var noPropagation = function noPropagation(e) {
        e.stopPropagation();
        if (e.preventDefault) {
          return e.preventDefault();
        } else {
          return e.returnValue = false;
        }
      };

      // Create the listeners
      this.listeners = [{
        element: this.element,
        events: {
          "dragstart": function dragstart(e) {
            return _this3.emit("dragstart", e);
          },
          "dragenter": function dragenter(e) {
            noPropagation(e);
            return _this3.emit("dragenter", e);
          },
          "dragover": function dragover(e) {
            // Makes it possible to drag files from chrome's download bar
            // http://stackoverflow.com/questions/19526430/drag-and-drop-file-uploads-from-chrome-downloads-bar
            // Try is required to prevent bug in Internet Explorer 11 (SCRIPT65535 exception)
            var efct = void 0;
            try {
              efct = e.dataTransfer.effectAllowed;
            } catch (error) {}
            e.dataTransfer.dropEffect = 'move' === efct || 'linkMove' === efct ? 'move' : 'copy';

            noPropagation(e);
            return _this3.emit("dragover", e);
          },
          "dragleave": function dragleave(e) {
            return _this3.emit("dragleave", e);
          },
          "drop": function drop(e) {
            noPropagation(e);
            return _this3.drop(e);
          },
          "dragend": function dragend(e) {
            return _this3.emit("dragend", e);
          }

          // This is disabled right now, because the browsers don't implement it properly.
          // "paste": (e) =>
          //   noPropagation e
          //   @paste e
        } }];

      this.clickableElements.forEach(function (clickableElement) {
        return _this3.listeners.push({
          element: clickableElement,
          events: {
            "click": function click(evt) {
              // Only the actual dropzone or the message element should trigger file selection
              if (clickableElement !== _this3.element || evt.target === _this3.element || Dropzone.elementInside(evt.target, _this3.element.querySelector(".dz-message"))) {
                _this3.hiddenFileInput.click(); // Forward the click
              }
              return true;
            }
          }
        });
      });

      this.enable();

      return this.options.init.call(this);
    }

    // Not fully tested yet

  }, {
    key: "destroy",
    value: function destroy() {
      this.disable();
      this.removeAllFiles(true);
      if (this.hiddenFileInput != null ? this.hiddenFileInput.parentNode : undefined) {
        this.hiddenFileInput.parentNode.removeChild(this.hiddenFileInput);
        this.hiddenFileInput = null;
      }
      delete this.element.dropzone;
      return Dropzone.instances.splice(Dropzone.instances.indexOf(this), 1);
    }
  }, {
    key: "updateTotalUploadProgress",
    value: function updateTotalUploadProgress() {
      var totalUploadProgress = void 0;
      var totalBytesSent = 0;
      var totalBytes = 0;

      var activeFiles = this.getActiveFiles();

      if (activeFiles.length) {
        for (var _iterator12 = this.getActiveFiles(), _isArray12 = true, _i12 = 0, _iterator12 = _isArray12 ? _iterator12 : _iterator12[Symbol.iterator]();;) {
          var _ref11;

          if (_isArray12) {
            if (_i12 >= _iterator12.length) break;
            _ref11 = _iterator12[_i12++];
          } else {
            _i12 = _iterator12.next();
            if (_i12.done) break;
            _ref11 = _i12.value;
          }

          var file = _ref11;

          totalBytesSent += file.upload.bytesSent;
          totalBytes += file.upload.total;
        }
        totalUploadProgress = 100 * totalBytesSent / totalBytes;
      } else {
        totalUploadProgress = 100;
      }

      return this.emit("totaluploadprogress", totalUploadProgress, totalBytes, totalBytesSent);
    }

    // @options.paramName can be a function taking one parameter rather than a string.
    // A parameter name for a file is obtained simply by calling this with an index number.

  }, {
    key: "_getParamName",
    value: function _getParamName(n) {
      if (typeof this.options.paramName === "function") {
        return this.options.paramName(n);
      } else {
        return "" + this.options.paramName + (this.options.uploadMultiple ? "[" + n + "]" : "");
      }
    }

    // If @options.renameFile is a function,
    // the function will be used to rename the file.name before appending it to the formData

  }, {
    key: "_renameFile",
    value: function _renameFile(file) {
      if (typeof this.options.renameFile !== "function") {
        return file.name;
      }
      return this.options.renameFile(file);
    }

    // Returns a form that can be used as fallback if the browser does not support DragnDrop
    //
    // If the dropzone is already a form, only the input field and button are returned. Otherwise a complete form element is provided.
    // This code has to pass in IE7 :(

  }, {
    key: "getFallbackForm",
    value: function getFallbackForm() {
      var existingFallback = void 0,
          form = void 0;
      if (existingFallback = this.getExistingFallback()) {
        return existingFallback;
      }

      var fieldsString = "<div class=\"dz-fallback\">";
      if (this.options.dictFallbackText) {
        fieldsString += "<p>" + this.options.dictFallbackText + "</p>";
      }
      fieldsString += "<input type=\"file\" name=\"" + this._getParamName(0) + "\" " + (this.options.uploadMultiple ? 'multiple="multiple"' : undefined) + " /><input type=\"submit\" value=\"Upload!\"></div>";

      var fields = Dropzone.createElement(fieldsString);
      if (this.element.tagName !== "FORM") {
        form = Dropzone.createElement("<form action=\"" + this.options.url + "\" enctype=\"multipart/form-data\" method=\"" + this.options.method + "\"></form>");
        form.appendChild(fields);
      } else {
        // Make sure that the enctype and method attributes are set properly
        this.element.setAttribute("enctype", "multipart/form-data");
        this.element.setAttribute("method", this.options.method);
      }
      return form != null ? form : fields;
    }

    // Returns the fallback elements if they exist already
    //
    // This code has to pass in IE7 :(

  }, {
    key: "getExistingFallback",
    value: function getExistingFallback() {
      var getFallback = function getFallback(elements) {
        for (var _iterator13 = elements, _isArray13 = true, _i13 = 0, _iterator13 = _isArray13 ? _iterator13 : _iterator13[Symbol.iterator]();;) {
          var _ref12;

          if (_isArray13) {
            if (_i13 >= _iterator13.length) break;
            _ref12 = _iterator13[_i13++];
          } else {
            _i13 = _iterator13.next();
            if (_i13.done) break;
            _ref12 = _i13.value;
          }

          var el = _ref12;

          if (/(^| )fallback($| )/.test(el.className)) {
            return el;
          }
        }
      };

      var _arr = ["div", "form"];
      for (var _i14 = 0; _i14 < _arr.length; _i14++) {
        var tagName = _arr[_i14];
        var fallback;
        if (fallback = getFallback(this.element.getElementsByTagName(tagName))) {
          return fallback;
        }
      }
    }

    // Activates all listeners stored in @listeners

  }, {
    key: "setupEventListeners",
    value: function setupEventListeners() {
      return this.listeners.map(function (elementListeners) {
        return function () {
          var result = [];
          for (var event in elementListeners.events) {
            var listener = elementListeners.events[event];
            result.push(elementListeners.element.addEventListener(event, listener, false));
          }
          return result;
        }();
      });
    }

    // Deactivates all listeners stored in @listeners

  }, {
    key: "removeEventListeners",
    value: function removeEventListeners() {
      return this.listeners.map(function (elementListeners) {
        return function () {
          var result = [];
          for (var event in elementListeners.events) {
            var listener = elementListeners.events[event];
            result.push(elementListeners.element.removeEventListener(event, listener, false));
          }
          return result;
        }();
      });
    }

    // Removes all event listeners and cancels all files in the queue or being processed.

  }, {
    key: "disable",
    value: function disable() {
      var _this4 = this;

      this.clickableElements.forEach(function (element) {
        return element.classList.remove("dz-clickable");
      });
      this.removeEventListeners();
      this.disabled = true;

      return this.files.map(function (file) {
        return _this4.cancelUpload(file);
      });
    }
  }, {
    key: "enable",
    value: function enable() {
      delete this.disabled;
      this.clickableElements.forEach(function (element) {
        return element.classList.add("dz-clickable");
      });
      return this.setupEventListeners();
    }

    // Returns a nicely formatted filesize

  }, {
    key: "filesize",
    value: function filesize(size) {
      var selectedSize = 0;
      var selectedUnit = "b";

      if (size > 0) {
        var units = ['tb', 'gb', 'mb', 'kb', 'b'];

        for (var i = 0; i < units.length; i++) {
          var unit = units[i];
          var cutoff = Math.pow(this.options.filesizeBase, 4 - i) / 10;

          if (size >= cutoff) {
            selectedSize = size / Math.pow(this.options.filesizeBase, 4 - i);
            selectedUnit = unit;
            break;
          }
        }

        selectedSize = Math.round(10 * selectedSize) / 10; // Cutting of digits
      }

      return "<strong>" + selectedSize + "</strong> " + this.options.dictFileSizeUnits[selectedUnit];
    }

    // Adds or removes the `dz-max-files-reached` class from the form.

  }, {
    key: "_updateMaxFilesReachedClass",
    value: function _updateMaxFilesReachedClass() {
      if (this.options.maxFiles != null && this.getAcceptedFiles().length >= this.options.maxFiles) {
        if (this.getAcceptedFiles().length === this.options.maxFiles) {
          this.emit('maxfilesreached', this.files);
        }
        return this.element.classList.add("dz-max-files-reached");
      } else {
        return this.element.classList.remove("dz-max-files-reached");
      }
    }
  }, {
    key: "drop",
    value: function drop(e) {
      if (!e.dataTransfer) {
        return;
      }
      this.emit("drop", e);

      // Convert the FileList to an Array
      // This is necessary for IE11
      var files = [];
      for (var i = 0; i < e.dataTransfer.files.length; i++) {
        files[i] = e.dataTransfer.files[i];
      }

      this.emit("addedfiles", files);

      // Even if it's a folder, files.length will contain the folders.
      if (files.length) {
        var items = e.dataTransfer.items;

        if (items && items.length && items[0].webkitGetAsEntry != null) {
          // The browser supports dropping of folders, so handle items instead of files
          this._addFilesFromItems(items);
        } else {
          this.handleFiles(files);
        }
      }
    }
  }, {
    key: "paste",
    value: function paste(e) {
      if (__guard__(e != null ? e.clipboardData : undefined, function (x) {
        return x.items;
      }) == null) {
        return;
      }

      this.emit("paste", e);
      var items = e.clipboardData.items;


      if (items.length) {
        return this._addFilesFromItems(items);
      }
    }
  }, {
    key: "handleFiles",
    value: function handleFiles(files) {
      for (var _iterator14 = files, _isArray14 = true, _i15 = 0, _iterator14 = _isArray14 ? _iterator14 : _iterator14[Symbol.iterator]();;) {
        var _ref13;

        if (_isArray14) {
          if (_i15 >= _iterator14.length) break;
          _ref13 = _iterator14[_i15++];
        } else {
          _i15 = _iterator14.next();
          if (_i15.done) break;
          _ref13 = _i15.value;
        }

        var file = _ref13;

        this.addFile(file);
      }
    }

    // When a folder is dropped (or files are pasted), items must be handled
    // instead of files.

  }, {
    key: "_addFilesFromItems",
    value: function _addFilesFromItems(items) {
      var _this5 = this;

      return function () {
        var result = [];
        for (var _iterator15 = items, _isArray15 = true, _i16 = 0, _iterator15 = _isArray15 ? _iterator15 : _iterator15[Symbol.iterator]();;) {
          var _ref14;

          if (_isArray15) {
            if (_i16 >= _iterator15.length) break;
            _ref14 = _iterator15[_i16++];
          } else {
            _i16 = _iterator15.next();
            if (_i16.done) break;
            _ref14 = _i16.value;
          }

          var item = _ref14;

          var entry;
          if (item.webkitGetAsEntry != null && (entry = item.webkitGetAsEntry())) {
            if (entry.isFile) {
              result.push(_this5.addFile(item.getAsFile()));
            } else if (entry.isDirectory) {
              // Append all files from that directory to files
              result.push(_this5._addFilesFromDirectory(entry, entry.name));
            } else {
              result.push(undefined);
            }
          } else if (item.getAsFile != null) {
            if (item.kind == null || item.kind === "file") {
              result.push(_this5.addFile(item.getAsFile()));
            } else {
              result.push(undefined);
            }
          } else {
            result.push(undefined);
          }
        }
        return result;
      }();
    }

    // Goes through the directory, and adds each file it finds recursively

  }, {
    key: "_addFilesFromDirectory",
    value: function _addFilesFromDirectory(directory, path) {
      var _this6 = this;

      var dirReader = directory.createReader();

      var errorHandler = function errorHandler(error) {
        return __guardMethod__(console, 'log', function (o) {
          return o.log(error);
        });
      };

      var readEntries = function readEntries() {
        return dirReader.readEntries(function (entries) {
          if (entries.length > 0) {
            for (var _iterator16 = entries, _isArray16 = true, _i17 = 0, _iterator16 = _isArray16 ? _iterator16 : _iterator16[Symbol.iterator]();;) {
              var _ref15;

              if (_isArray16) {
                if (_i17 >= _iterator16.length) break;
                _ref15 = _iterator16[_i17++];
              } else {
                _i17 = _iterator16.next();
                if (_i17.done) break;
                _ref15 = _i17.value;
              }

              var entry = _ref15;

              if (entry.isFile) {
                entry.file(function (file) {
                  if (_this6.options.ignoreHiddenFiles && file.name.substring(0, 1) === '.') {
                    return;
                  }
                  file.fullPath = path + "/" + file.name;
                  return _this6.addFile(file);
                });
              } else if (entry.isDirectory) {
                _this6._addFilesFromDirectory(entry, path + "/" + entry.name);
              }
            }

            // Recursively call readEntries() again, since browser only handle
            // the first 100 entries.
            // See: https://developer.mozilla.org/en-US/docs/Web/API/DirectoryReader#readEntries
            readEntries();
          }
          return null;
        }, errorHandler);
      };

      return readEntries();
    }

    // If `done()` is called without argument the file is accepted
    // If you call it with an error message, the file is rejected
    // (This allows for asynchronous validation)
    //
    // This function checks the filesize, and if the file.type passes the
    // `acceptedFiles` check.

  }, {
    key: "accept",
    value: function accept(file, done) {
      if (this.options.maxFilesize && file.size > this.options.maxFilesize * 1024 * 1024) {
        return done(this.options.dictFileTooBig.replace("{{filesize}}", Math.round(file.size / 1024 / 10.24) / 100).replace("{{maxFilesize}}", this.options.maxFilesize));
      } else if (!Dropzone.isValidFile(file, this.options.acceptedFiles)) {
        return done(this.options.dictInvalidFileType);
      } else if (this.options.maxFiles != null && this.getAcceptedFiles().length >= this.options.maxFiles) {
        done(this.options.dictMaxFilesExceeded.replace("{{maxFiles}}", this.options.maxFiles));
        return this.emit("maxfilesexceeded", file);
      } else {
        return this.options.accept.call(this, file, done);
      }
    }
  }, {
    key: "addFile",
    value: function addFile(file) {
      var _this7 = this;

      file.upload = {
        uuid: Dropzone.uuidv4(),
        progress: 0,
        // Setting the total upload size to file.size for the beginning
        // It's actual different than the size to be transmitted.
        total: file.size,
        bytesSent: 0,
        filename: this._renameFile(file),
        chunked: this.options.chunking && (this.options.forceChunking || file.size > this.options.chunkSize),
        totalChunkCount: Math.ceil(file.size / this.options.chunkSize)
      };
      this.files.push(file);

      file.status = Dropzone.ADDED;

      this.emit("addedfile", file);

      this._enqueueThumbnail(file);

      return this.accept(file, function (error) {
        if (error) {
          file.accepted = false;
          _this7._errorProcessing([file], error); // Will set the file.status
        } else {
          file.accepted = true;
          if (_this7.options.autoQueue) {
            _this7.enqueueFile(file);
          } // Will set .accepted = true
        }
        return _this7._updateMaxFilesReachedClass();
      });
    }

    // Wrapper for enqueueFile

  }, {
    key: "enqueueFiles",
    value: function enqueueFiles(files) {
      for (var _iterator17 = files, _isArray17 = true, _i18 = 0, _iterator17 = _isArray17 ? _iterator17 : _iterator17[Symbol.iterator]();;) {
        var _ref16;

        if (_isArray17) {
          if (_i18 >= _iterator17.length) break;
          _ref16 = _iterator17[_i18++];
        } else {
          _i18 = _iterator17.next();
          if (_i18.done) break;
          _ref16 = _i18.value;
        }

        var file = _ref16;

        this.enqueueFile(file);
      }
      return null;
    }
  }, {
    key: "enqueueFile",
    value: function enqueueFile(file) {
      var _this8 = this;

      if (file.status === Dropzone.ADDED && file.accepted === true) {
        file.status = Dropzone.QUEUED;
        if (this.options.autoProcessQueue) {
          return setTimeout(function () {
            return _this8.processQueue();
          }, 0); // Deferring the call
        }
      } else {
        throw new Error("This file can't be queued because it has already been processed or was rejected.");
      }
    }
  }, {
    key: "_enqueueThumbnail",
    value: function _enqueueThumbnail(file) {
      var _this9 = this;

      if (this.options.createImageThumbnails && file.type.match(/image.*/) && file.size <= this.options.maxThumbnailFilesize * 1024 * 1024) {
        this._thumbnailQueue.push(file);
        return setTimeout(function () {
          return _this9._processThumbnailQueue();
        }, 0); // Deferring the call
      }
    }
  }, {
    key: "_processThumbnailQueue",
    value: function _processThumbnailQueue() {
      var _this10 = this;

      if (this._processingThumbnail || this._thumbnailQueue.length === 0) {
        return;
      }

      this._processingThumbnail = true;
      var file = this._thumbnailQueue.shift();
      return this.createThumbnail(file, this.options.thumbnailWidth, this.options.thumbnailHeight, this.options.thumbnailMethod, true, function (dataUrl) {
        _this10.emit("thumbnail", file, dataUrl);
        _this10._processingThumbnail = false;
        return _this10._processThumbnailQueue();
      });
    }

    // Can be called by the user to remove a file

  }, {
    key: "removeFile",
    value: function removeFile(file) {
      if (file.status === Dropzone.UPLOADING) {
        this.cancelUpload(file);
      }
      this.files = without(this.files, file);

      this.emit("removedfile", file);
      if (this.files.length === 0) {
        return this.emit("reset");
      }
    }

    // Removes all files that aren't currently processed from the list

  }, {
    key: "removeAllFiles",
    value: function removeAllFiles(cancelIfNecessary) {
      // Create a copy of files since removeFile() changes the @files array.
      if (cancelIfNecessary == null) {
        cancelIfNecessary = false;
      }
      for (var _iterator18 = this.files.slice(), _isArray18 = true, _i19 = 0, _iterator18 = _isArray18 ? _iterator18 : _iterator18[Symbol.iterator]();;) {
        var _ref17;

        if (_isArray18) {
          if (_i19 >= _iterator18.length) break;
          _ref17 = _iterator18[_i19++];
        } else {
          _i19 = _iterator18.next();
          if (_i19.done) break;
          _ref17 = _i19.value;
        }

        var file = _ref17;

        if (file.status !== Dropzone.UPLOADING || cancelIfNecessary) {
          this.removeFile(file);
        }
      }
      return null;
    }

    // Resizes an image before it gets sent to the server. This function is the default behavior of
    // `options.transformFile` if `resizeWidth` or `resizeHeight` are set. The callback is invoked with
    // the resized blob.

  }, {
    key: "resizeImage",
    value: function resizeImage(file, width, height, resizeMethod, callback) {
      var _this11 = this;

      return this.createThumbnail(file, width, height, resizeMethod, false, function (dataUrl, canvas) {
        if (canvas == null) {
          // The image has not been resized
          return callback(file);
        } else {
          var resizeMimeType = _this11.options.resizeMimeType;

          if (resizeMimeType == null) {
            resizeMimeType = file.type;
          }
          var resizedDataURL = canvas.toDataURL(resizeMimeType, _this11.options.resizeQuality);
          if (resizeMimeType === 'image/jpeg' || resizeMimeType === 'image/jpg') {
            // Now add the original EXIF information
            resizedDataURL = ExifRestore.restore(file.dataURL, resizedDataURL);
          }
          return callback(Dropzone.dataURItoBlob(resizedDataURL));
        }
      });
    }
  }, {
    key: "createThumbnail",
    value: function createThumbnail(file, width, height, resizeMethod, fixOrientation, callback) {
      var _this12 = this;

      var fileReader = new FileReader();

      fileReader.onload = function () {

        file.dataURL = fileReader.result;

        // Don't bother creating a thumbnail for SVG images since they're vector
        if (file.type === "image/svg+xml") {
          if (callback != null) {
            callback(fileReader.result);
          }
          return;
        }

        return _this12.createThumbnailFromUrl(file, width, height, resizeMethod, fixOrientation, callback);
      };

      return fileReader.readAsDataURL(file);
    }
  }, {
    key: "createThumbnailFromUrl",
    value: function createThumbnailFromUrl(file, width, height, resizeMethod, fixOrientation, callback, crossOrigin) {
      var _this13 = this;

      // Not using `new Image` here because of a bug in latest Chrome versions.
      // See https://github.com/enyo/dropzone/pull/226
      var img = document.createElement("img");

      if (crossOrigin) {
        img.crossOrigin = crossOrigin;
      }

      img.onload = function () {
        var loadExif = function loadExif(callback) {
          return callback(1);
        };
        if (typeof EXIF !== 'undefined' && EXIF !== null && fixOrientation) {
          loadExif = function loadExif(callback) {
            return EXIF.getData(img, function () {
              return callback(EXIF.getTag(this, 'Orientation'));
            });
          };
        }

        return loadExif(function (orientation) {
          file.width = img.width;
          file.height = img.height;

          var resizeInfo = _this13.options.resize.call(_this13, file, width, height, resizeMethod);

          var canvas = document.createElement("canvas");
          var ctx = canvas.getContext("2d");

          canvas.width = resizeInfo.trgWidth;
          canvas.height = resizeInfo.trgHeight;

          if (orientation > 4) {
            canvas.width = resizeInfo.trgHeight;
            canvas.height = resizeInfo.trgWidth;
          }

          switch (orientation) {
            case 2:
              // horizontal flip
              ctx.translate(canvas.width, 0);
              ctx.scale(-1, 1);
              break;
            case 3:
              // 180° rotate left
              ctx.translate(canvas.width, canvas.height);
              ctx.rotate(Math.PI);
              break;
            case 4:
              // vertical flip
              ctx.translate(0, canvas.height);
              ctx.scale(1, -1);
              break;
            case 5:
              // vertical flip + 90 rotate right
              ctx.rotate(0.5 * Math.PI);
              ctx.scale(1, -1);
              break;
            case 6:
              // 90° rotate right
              ctx.rotate(0.5 * Math.PI);
              ctx.translate(0, -canvas.height);
              break;
            case 7:
              // horizontal flip + 90 rotate right
              ctx.rotate(0.5 * Math.PI);
              ctx.translate(canvas.width, -canvas.height);
              ctx.scale(-1, 1);
              break;
            case 8:
              // 90° rotate left
              ctx.rotate(-0.5 * Math.PI);
              ctx.translate(-canvas.width, 0);
              break;
          }

          // This is a bugfix for iOS' scaling bug.
          drawImageIOSFix(ctx, img, resizeInfo.srcX != null ? resizeInfo.srcX : 0, resizeInfo.srcY != null ? resizeInfo.srcY : 0, resizeInfo.srcWidth, resizeInfo.srcHeight, resizeInfo.trgX != null ? resizeInfo.trgX : 0, resizeInfo.trgY != null ? resizeInfo.trgY : 0, resizeInfo.trgWidth, resizeInfo.trgHeight);

          var thumbnail = canvas.toDataURL("image/png");

          if (callback != null) {
            return callback(thumbnail, canvas);
          }
        });
      };

      if (callback != null) {
        img.onerror = callback;
      }

      return img.src = file.dataURL;
    }

    // Goes through the queue and processes files if there aren't too many already.

  }, {
    key: "processQueue",
    value: function processQueue() {
      var parallelUploads = this.options.parallelUploads;

      var processingLength = this.getUploadingFiles().length;
      var i = processingLength;

      // There are already at least as many files uploading than should be
      if (processingLength >= parallelUploads) {
        return;
      }

      var queuedFiles = this.getQueuedFiles();

      if (!(queuedFiles.length > 0)) {
        return;
      }

      if (this.options.uploadMultiple) {
        // The files should be uploaded in one request
        return this.processFiles(queuedFiles.slice(0, parallelUploads - processingLength));
      } else {
        while (i < parallelUploads) {
          if (!queuedFiles.length) {
            return;
          } // Nothing left to process
          this.processFile(queuedFiles.shift());
          i++;
        }
      }
    }

    // Wrapper for `processFiles`

  }, {
    key: "processFile",
    value: function processFile(file) {
      return this.processFiles([file]);
    }

    // Loads the file, then calls finishedLoading()

  }, {
    key: "processFiles",
    value: function processFiles(files) {
      for (var _iterator19 = files, _isArray19 = true, _i20 = 0, _iterator19 = _isArray19 ? _iterator19 : _iterator19[Symbol.iterator]();;) {
        var _ref18;

        if (_isArray19) {
          if (_i20 >= _iterator19.length) break;
          _ref18 = _iterator19[_i20++];
        } else {
          _i20 = _iterator19.next();
          if (_i20.done) break;
          _ref18 = _i20.value;
        }

        var file = _ref18;

        file.processing = true; // Backwards compatibility
        file.status = Dropzone.UPLOADING;

        this.emit("processing", file);
      }

      if (this.options.uploadMultiple) {
        this.emit("processingmultiple", files);
      }

      return this.uploadFiles(files);
    }
  }, {
    key: "_getFilesWithXhr",
    value: function _getFilesWithXhr(xhr) {
      var files = void 0;
      return files = this.files.filter(function (file) {
        return file.xhr === xhr;
      }).map(function (file) {
        return file;
      });
    }

    // Cancels the file upload and sets the status to CANCELED
    // **if** the file is actually being uploaded.
    // If it's still in the queue, the file is being removed from it and the status
    // set to CANCELED.

  }, {
    key: "cancelUpload",
    value: function cancelUpload(file) {
      if (file.status === Dropzone.UPLOADING) {
        var groupedFiles = this._getFilesWithXhr(file.xhr);
        for (var _iterator20 = groupedFiles, _isArray20 = true, _i21 = 0, _iterator20 = _isArray20 ? _iterator20 : _iterator20[Symbol.iterator]();;) {
          var _ref19;

          if (_isArray20) {
            if (_i21 >= _iterator20.length) break;
            _ref19 = _iterator20[_i21++];
          } else {
            _i21 = _iterator20.next();
            if (_i21.done) break;
            _ref19 = _i21.value;
          }

          var groupedFile = _ref19;

          groupedFile.status = Dropzone.CANCELED;
        }
        if (typeof file.xhr !== 'undefined') {
          file.xhr.abort();
        }
        for (var _iterator21 = groupedFiles, _isArray21 = true, _i22 = 0, _iterator21 = _isArray21 ? _iterator21 : _iterator21[Symbol.iterator]();;) {
          var _ref20;

          if (_isArray21) {
            if (_i22 >= _iterator21.length) break;
            _ref20 = _iterator21[_i22++];
          } else {
            _i22 = _iterator21.next();
            if (_i22.done) break;
            _ref20 = _i22.value;
          }

          var _groupedFile = _ref20;

          this.emit("canceled", _groupedFile);
        }
        if (this.options.uploadMultiple) {
          this.emit("canceledmultiple", groupedFiles);
        }
      } else if (file.status === Dropzone.ADDED || file.status === Dropzone.QUEUED) {
        file.status = Dropzone.CANCELED;
        this.emit("canceled", file);
        if (this.options.uploadMultiple) {
          this.emit("canceledmultiple", [file]);
        }
      }

      if (this.options.autoProcessQueue) {
        return this.processQueue();
      }
    }
  }, {
    key: "resolveOption",
    value: function resolveOption(option) {
      if (typeof option === 'function') {
        for (var _len3 = arguments.length, args = Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
          args[_key3 - 1] = arguments[_key3];
        }

        return option.apply(this, args);
      }
      return option;
    }
  }, {
    key: "uploadFile",
    value: function uploadFile(file) {
      return this.uploadFiles([file]);
    }
  }, {
    key: "uploadFiles",
    value: function uploadFiles(files) {
      var _this14 = this;

      this._transformFiles(files, function (transformedFiles) {
        if (files[0].upload.chunked) {
          // This file should be sent in chunks!

          // If the chunking option is set, we **know** that there can only be **one** file, since
          // uploadMultiple is not allowed with this option.
          var file = files[0];
          var transformedFile = transformedFiles[0];
          var startedChunkCount = 0;

          file.upload.chunks = [];

          var handleNextChunk = function handleNextChunk() {
            var chunkIndex = 0;

            // Find the next item in file.upload.chunks that is not defined yet.
            while (file.upload.chunks[chunkIndex] !== undefined) {
              chunkIndex++;
            }

            // This means, that all chunks have already been started.
            if (chunkIndex >= file.upload.totalChunkCount) return;

            startedChunkCount++;

            var start = chunkIndex * _this14.options.chunkSize;
            var end = Math.min(start + _this14.options.chunkSize, file.size);

            var dataBlock = {
              name: _this14._getParamName(0),
              data: transformedFile.webkitSlice ? transformedFile.webkitSlice(start, end) : transformedFile.slice(start, end),
              filename: file.upload.filename,
              chunkIndex: chunkIndex
            };

            file.upload.chunks[chunkIndex] = {
              file: file,
              index: chunkIndex,
              dataBlock: dataBlock, // In case we want to retry.
              status: Dropzone.UPLOADING,
              progress: 0,
              retries: 0 // The number of times this block has been retried.
            };

            _this14._uploadData(files, [dataBlock]);
          };

          file.upload.finishedChunkUpload = function (chunk) {
            var allFinished = true;
            chunk.status = Dropzone.SUCCESS;

            // Clear the data from the chunk
            chunk.dataBlock = null;

            for (var i = 0; i < file.upload.totalChunkCount; i++) {
              if (file.upload.chunks[i] === undefined) {
                return handleNextChunk();
              }
              if (file.upload.chunks[i].status !== Dropzone.SUCCESS) {
                allFinished = false;
              }
            }

            if (allFinished) {
              _this14.options.chunksUploaded(file, function () {
                _this14._finished(files, '', null);
              });
            }
          };

          if (_this14.options.parallelChunkUploads) {
            for (var i = 0; i < file.upload.totalChunkCount; i++) {
              handleNextChunk();
            }
          } else {
            handleNextChunk();
          }
        } else {
          var dataBlocks = [];
          for (var _i23 = 0; _i23 < files.length; _i23++) {
            dataBlocks[_i23] = {
              name: _this14._getParamName(_i23),
              data: transformedFiles[_i23],
              filename: files[_i23].upload.filename
            };
          }
          _this14._uploadData(files, dataBlocks);
        }
      });
    }

    /// Returns the right chunk for given file and xhr

  }, {
    key: "_getChunk",
    value: function _getChunk(file, xhr) {
      for (var i = 0; i < file.upload.totalChunkCount; i++) {
        if (file.upload.chunks[i] !== undefined && file.upload.chunks[i].xhr === xhr) {
          return file.upload.chunks[i];
        }
      }
    }

    // This function actually uploads the file(s) to the server.
    // If dataBlocks contains the actual data to upload (meaning, that this could either be transformed
    // files, or individual chunks for chunked upload).

  }, {
    key: "_uploadData",
    value: function _uploadData(files, dataBlocks) {
      var _this15 = this;

      var xhr = new XMLHttpRequest();

      // Put the xhr object in the file objects to be able to reference it later.
      for (var _iterator22 = files, _isArray22 = true, _i24 = 0, _iterator22 = _isArray22 ? _iterator22 : _iterator22[Symbol.iterator]();;) {
        var _ref21;

        if (_isArray22) {
          if (_i24 >= _iterator22.length) break;
          _ref21 = _iterator22[_i24++];
        } else {
          _i24 = _iterator22.next();
          if (_i24.done) break;
          _ref21 = _i24.value;
        }

        var file = _ref21;

        file.xhr = xhr;
      }
      if (files[0].upload.chunked) {
        // Put the xhr object in the right chunk object, so it can be associated later, and found with _getChunk
        files[0].upload.chunks[dataBlocks[0].chunkIndex].xhr = xhr;
      }

      var method = this.resolveOption(this.options.method, files);
      var url = this.resolveOption(this.options.url, files);
      xhr.open(method, url, true);

      // Setting the timeout after open because of IE11 issue: https://gitlab.com/meno/dropzone/issues/8
      xhr.timeout = this.resolveOption(this.options.timeout, files);

      // Has to be after `.open()`. See https://github.com/enyo/dropzone/issues/179
      xhr.withCredentials = !!this.options.withCredentials;

      xhr.onload = function (e) {
        _this15._finishedUploading(files, xhr, e);
      };

      xhr.onerror = function () {
        _this15._handleUploadError(files, xhr);
      };

      // Some browsers do not have the .upload property
      var progressObj = xhr.upload != null ? xhr.upload : xhr;
      progressObj.onprogress = function (e) {
        return _this15._updateFilesUploadProgress(files, xhr, e);
      };

      var headers = {
        "Accept": "application/json",
        "Cache-Control": "no-cache",
        "X-Requested-With": "XMLHttpRequest"
      };

      if (this.options.headers) {
        Dropzone.extend(headers, this.options.headers);
      }

      for (var headerName in headers) {
        var headerValue = headers[headerName];
        if (headerValue) {
          xhr.setRequestHeader(headerName, headerValue);
        }
      }

      var formData = new FormData();

      // Adding all @options parameters
      if (this.options.params) {
        var additionalParams = this.options.params;
        if (typeof additionalParams === 'function') {
          additionalParams = additionalParams.call(this, files, xhr, files[0].upload.chunked ? this._getChunk(files[0], xhr) : null);
        }

        for (var key in additionalParams) {
          var value = additionalParams[key];
          formData.append(key, value);
        }
      }

      // Let the user add additional data if necessary
      for (var _iterator23 = files, _isArray23 = true, _i25 = 0, _iterator23 = _isArray23 ? _iterator23 : _iterator23[Symbol.iterator]();;) {
        var _ref22;

        if (_isArray23) {
          if (_i25 >= _iterator23.length) break;
          _ref22 = _iterator23[_i25++];
        } else {
          _i25 = _iterator23.next();
          if (_i25.done) break;
          _ref22 = _i25.value;
        }

        var _file = _ref22;

        this.emit("sending", _file, xhr, formData);
      }
      if (this.options.uploadMultiple) {
        this.emit("sendingmultiple", files, xhr, formData);
      }

      this._addFormElementData(formData);

      // Finally add the files
      // Has to be last because some servers (eg: S3) expect the file to be the last parameter
      for (var i = 0; i < dataBlocks.length; i++) {
        var dataBlock = dataBlocks[i];
        formData.append(dataBlock.name, dataBlock.data, dataBlock.filename);
      }

      this.submitRequest(xhr, formData, files);
    }

    // Transforms all files with this.options.transformFile and invokes done with the transformed files when done.

  }, {
    key: "_transformFiles",
    value: function _transformFiles(files, done) {
      var _this16 = this;

      var transformedFiles = [];
      // Clumsy way of handling asynchronous calls, until I get to add a proper Future library.
      var doneCounter = 0;

      var _loop = function _loop(i) {
        _this16.options.transformFile.call(_this16, files[i], function (transformedFile) {
          transformedFiles[i] = transformedFile;
          if (++doneCounter === files.length) {
            done(transformedFiles);
          }
        });
      };

      for (var i = 0; i < files.length; i++) {
        _loop(i);
      }
    }

    // Takes care of adding other input elements of the form to the AJAX request

  }, {
    key: "_addFormElementData",
    value: function _addFormElementData(formData) {
      // Take care of other input elements
      if (this.element.tagName === "FORM") {
        for (var _iterator24 = this.element.querySelectorAll("input, textarea, select, button"), _isArray24 = true, _i26 = 0, _iterator24 = _isArray24 ? _iterator24 : _iterator24[Symbol.iterator]();;) {
          var _ref23;

          if (_isArray24) {
            if (_i26 >= _iterator24.length) break;
            _ref23 = _iterator24[_i26++];
          } else {
            _i26 = _iterator24.next();
            if (_i26.done) break;
            _ref23 = _i26.value;
          }

          var input = _ref23;

          var inputName = input.getAttribute("name");
          var inputType = input.getAttribute("type");
          if (inputType) inputType = inputType.toLowerCase();

          // If the input doesn't have a name, we can't use it.
          if (typeof inputName === 'undefined' || inputName === null) continue;

          if (input.tagName === "SELECT" && input.hasAttribute("multiple")) {
            // Possibly multiple values
            for (var _iterator25 = input.options, _isArray25 = true, _i27 = 0, _iterator25 = _isArray25 ? _iterator25 : _iterator25[Symbol.iterator]();;) {
              var _ref24;

              if (_isArray25) {
                if (_i27 >= _iterator25.length) break;
                _ref24 = _iterator25[_i27++];
              } else {
                _i27 = _iterator25.next();
                if (_i27.done) break;
                _ref24 = _i27.value;
              }

              var option = _ref24;

              if (option.selected) {
                formData.append(inputName, option.value);
              }
            }
          } else if (!inputType || inputType !== "checkbox" && inputType !== "radio" || input.checked) {
            formData.append(inputName, input.value);
          }
        }
      }
    }

    // Invoked when there is new progress information about given files.
    // If e is not provided, it is assumed that the upload is finished.

  }, {
    key: "_updateFilesUploadProgress",
    value: function _updateFilesUploadProgress(files, xhr, e) {
      var progress = void 0;
      if (typeof e !== 'undefined') {
        progress = 100 * e.loaded / e.total;

        if (files[0].upload.chunked) {
          var file = files[0];
          // Since this is a chunked upload, we need to update the appropriate chunk progress.
          var chunk = this._getChunk(file, xhr);
          chunk.progress = progress;
          chunk.total = e.total;
          chunk.bytesSent = e.loaded;
          var fileProgress = 0,
              fileTotal = void 0,
              fileBytesSent = void 0;
          file.upload.progress = 0;
          file.upload.total = 0;
          file.upload.bytesSent = 0;
          for (var i = 0; i < file.upload.totalChunkCount; i++) {
            if (file.upload.chunks[i] !== undefined && file.upload.chunks[i].progress !== undefined) {
              file.upload.progress += file.upload.chunks[i].progress;
              file.upload.total += file.upload.chunks[i].total;
              file.upload.bytesSent += file.upload.chunks[i].bytesSent;
            }
          }
          file.upload.progress = file.upload.progress / file.upload.totalChunkCount;
        } else {
          for (var _iterator26 = files, _isArray26 = true, _i28 = 0, _iterator26 = _isArray26 ? _iterator26 : _iterator26[Symbol.iterator]();;) {
            var _ref25;

            if (_isArray26) {
              if (_i28 >= _iterator26.length) break;
              _ref25 = _iterator26[_i28++];
            } else {
              _i28 = _iterator26.next();
              if (_i28.done) break;
              _ref25 = _i28.value;
            }

            var _file2 = _ref25;

            _file2.upload.progress = progress;
            _file2.upload.total = e.total;
            _file2.upload.bytesSent = e.loaded;
          }
        }
        for (var _iterator27 = files, _isArray27 = true, _i29 = 0, _iterator27 = _isArray27 ? _iterator27 : _iterator27[Symbol.iterator]();;) {
          var _ref26;

          if (_isArray27) {
            if (_i29 >= _iterator27.length) break;
            _ref26 = _iterator27[_i29++];
          } else {
            _i29 = _iterator27.next();
            if (_i29.done) break;
            _ref26 = _i29.value;
          }

          var _file3 = _ref26;

          this.emit("uploadprogress", _file3, _file3.upload.progress, _file3.upload.bytesSent);
        }
      } else {
        // Called when the file finished uploading

        var allFilesFinished = true;

        progress = 100;

        for (var _iterator28 = files, _isArray28 = true, _i30 = 0, _iterator28 = _isArray28 ? _iterator28 : _iterator28[Symbol.iterator]();;) {
          var _ref27;

          if (_isArray28) {
            if (_i30 >= _iterator28.length) break;
            _ref27 = _iterator28[_i30++];
          } else {
            _i30 = _iterator28.next();
            if (_i30.done) break;
            _ref27 = _i30.value;
          }

          var _file4 = _ref27;

          if (_file4.upload.progress !== 100 || _file4.upload.bytesSent !== _file4.upload.total) {
            allFilesFinished = false;
          }
          _file4.upload.progress = progress;
          _file4.upload.bytesSent = _file4.upload.total;
        }

        // Nothing to do, all files already at 100%
        if (allFilesFinished) {
          return;
        }

        for (var _iterator29 = files, _isArray29 = true, _i31 = 0, _iterator29 = _isArray29 ? _iterator29 : _iterator29[Symbol.iterator]();;) {
          var _ref28;

          if (_isArray29) {
            if (_i31 >= _iterator29.length) break;
            _ref28 = _iterator29[_i31++];
          } else {
            _i31 = _iterator29.next();
            if (_i31.done) break;
            _ref28 = _i31.value;
          }

          var _file5 = _ref28;

          this.emit("uploadprogress", _file5, progress, _file5.upload.bytesSent);
        }
      }
    }
  }, {
    key: "_finishedUploading",
    value: function _finishedUploading(files, xhr, e) {
      var response = void 0;

      if (files[0].status === Dropzone.CANCELED) {
        return;
      }

      if (xhr.readyState !== 4) {
        return;
      }

      if (xhr.responseType !== 'arraybuffer' && xhr.responseType !== 'blob') {
        response = xhr.responseText;

        if (xhr.getResponseHeader("content-type") && ~xhr.getResponseHeader("content-type").indexOf("application/json")) {
          try {
            response = JSON.parse(response);
          } catch (error) {
            e = error;
            response = "Invalid JSON response from server.";
          }
        }
      }

      this._updateFilesUploadProgress(files);

      if (!(200 <= xhr.status && xhr.status < 300)) {
        this._handleUploadError(files, xhr, response);
      } else {
        if (files[0].upload.chunked) {
          files[0].upload.finishedChunkUpload(this._getChunk(files[0], xhr));
        } else {
          this._finished(files, response, e);
        }
      }
    }
  }, {
    key: "_handleUploadError",
    value: function _handleUploadError(files, xhr, response) {
      if (files[0].status === Dropzone.CANCELED) {
        return;
      }

      if (files[0].upload.chunked && this.options.retryChunks) {
        var chunk = this._getChunk(files[0], xhr);
        if (chunk.retries++ < this.options.retryChunksLimit) {
          this._uploadData(files, [chunk.dataBlock]);
          return;
        } else {
          console.warn('Retried this chunk too often. Giving up.');
        }
      }

      for (var _iterator30 = files, _isArray30 = true, _i32 = 0, _iterator30 = _isArray30 ? _iterator30 : _iterator30[Symbol.iterator]();;) {
        var _ref29;

        if (_isArray30) {
          if (_i32 >= _iterator30.length) break;
          _ref29 = _iterator30[_i32++];
        } else {
          _i32 = _iterator30.next();
          if (_i32.done) break;
          _ref29 = _i32.value;
        }

        var file = _ref29;

        this._errorProcessing(files, response || this.options.dictResponseError.replace("{{statusCode}}", xhr.status), xhr);
      }
    }
  }, {
    key: "submitRequest",
    value: function submitRequest(xhr, formData, files) {
      xhr.send(formData);
    }

    // Called internally when processing is finished.
    // Individual callbacks have to be called in the appropriate sections.

  }, {
    key: "_finished",
    value: function _finished(files, responseText, e) {
      for (var _iterator31 = files, _isArray31 = true, _i33 = 0, _iterator31 = _isArray31 ? _iterator31 : _iterator31[Symbol.iterator]();;) {
        var _ref30;

        if (_isArray31) {
          if (_i33 >= _iterator31.length) break;
          _ref30 = _iterator31[_i33++];
        } else {
          _i33 = _iterator31.next();
          if (_i33.done) break;
          _ref30 = _i33.value;
        }

        var file = _ref30;

        file.status = Dropzone.SUCCESS;
        this.emit("success", file, responseText, e);
        this.emit("complete", file);
      }
      if (this.options.uploadMultiple) {
        this.emit("successmultiple", files, responseText, e);
        this.emit("completemultiple", files);
      }

      if (this.options.autoProcessQueue) {
        return this.processQueue();
      }
    }

    // Called internally when processing is finished.
    // Individual callbacks have to be called in the appropriate sections.

  }, {
    key: "_errorProcessing",
    value: function _errorProcessing(files, message, xhr) {
      for (var _iterator32 = files, _isArray32 = true, _i34 = 0, _iterator32 = _isArray32 ? _iterator32 : _iterator32[Symbol.iterator]();;) {
        var _ref31;

        if (_isArray32) {
          if (_i34 >= _iterator32.length) break;
          _ref31 = _iterator32[_i34++];
        } else {
          _i34 = _iterator32.next();
          if (_i34.done) break;
          _ref31 = _i34.value;
        }

        var file = _ref31;

        file.status = Dropzone.ERROR;
        this.emit("error", file, message, xhr);
        this.emit("complete", file);
      }
      if (this.options.uploadMultiple) {
        this.emit("errormultiple", files, message, xhr);
        this.emit("completemultiple", files);
      }

      if (this.options.autoProcessQueue) {
        return this.processQueue();
      }
    }
  }], [{
    key: "uuidv4",
    value: function uuidv4() {
      return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
        var r = Math.random() * 16 | 0,
            v = c === 'x' ? r : r & 0x3 | 0x8;
        return v.toString(16);
      });
    }
  }]);

  return Dropzone;
}(Emitter);

Dropzone.initClass();

Dropzone.version = "5.4.0";

// This is a map of options for your different dropzones. Add configurations
// to this object for your different dropzone elemens.
//
// Example:
//
//     Dropzone.options.myDropzoneElementId = { maxFilesize: 1 };
//
// To disable autoDiscover for a specific element, you can set `false` as an option:
//
//     Dropzone.options.myDisabledElementId = false;
//
// And in html:
//
//     <form action="/upload" id="my-dropzone-element-id" class="dropzone"></form>
Dropzone.options = {};

// Returns the options for an element or undefined if none available.
Dropzone.optionsForElement = function (element) {
  // Get the `Dropzone.options.elementId` for this element if it exists
  if (element.getAttribute("id")) {
    return Dropzone.options[camelize(element.getAttribute("id"))];
  } else {
    return undefined;
  }
};

// Holds a list of all dropzone instances
Dropzone.instances = [];

// Returns the dropzone for given element if any
Dropzone.forElement = function (element) {
  if (typeof element === "string") {
    element = document.querySelector(element);
  }
  if ((element != null ? element.dropzone : undefined) == null) {
    throw new Error("No Dropzone found for given element. This is probably because you're trying to access it before Dropzone had the time to initialize. Use the `init` option to setup any additional observers on your Dropzone.");
  }
  return element.dropzone;
};

// Set to false if you don't want Dropzone to automatically find and attach to .dropzone elements.
Dropzone.autoDiscover = true;

// Looks for all .dropzone elements and creates a dropzone for them
Dropzone.discover = function () {
  var dropzones = void 0;
  if (document.querySelectorAll) {
    dropzones = document.querySelectorAll(".dropzone");
  } else {
    dropzones = [];
    // IE :(
    var checkElements = function checkElements(elements) {
      return function () {
        var result = [];
        for (var _iterator33 = elements, _isArray33 = true, _i35 = 0, _iterator33 = _isArray33 ? _iterator33 : _iterator33[Symbol.iterator]();;) {
          var _ref32;

          if (_isArray33) {
            if (_i35 >= _iterator33.length) break;
            _ref32 = _iterator33[_i35++];
          } else {
            _i35 = _iterator33.next();
            if (_i35.done) break;
            _ref32 = _i35.value;
          }

          var el = _ref32;

          if (/(^| )dropzone($| )/.test(el.className)) {
            result.push(dropzones.push(el));
          } else {
            result.push(undefined);
          }
        }
        return result;
      }();
    };
    checkElements(document.getElementsByTagName("div"));
    checkElements(document.getElementsByTagName("form"));
  }

  return function () {
    var result = [];
    for (var _iterator34 = dropzones, _isArray34 = true, _i36 = 0, _iterator34 = _isArray34 ? _iterator34 : _iterator34[Symbol.iterator]();;) {
      var _ref33;

      if (_isArray34) {
        if (_i36 >= _iterator34.length) break;
        _ref33 = _iterator34[_i36++];
      } else {
        _i36 = _iterator34.next();
        if (_i36.done) break;
        _ref33 = _i36.value;
      }

      var dropzone = _ref33;

      // Create a dropzone unless auto discover has been disabled for specific element
      if (Dropzone.optionsForElement(dropzone) !== false) {
        result.push(new Dropzone(dropzone));
      } else {
        result.push(undefined);
      }
    }
    return result;
  }();
};

// Since the whole Drag'n'Drop API is pretty new, some browsers implement it,
// but not correctly.
// So I created a blacklist of userAgents. Yes, yes. Browser sniffing, I know.
// But what to do when browsers *theoretically* support an API, but crash
// when using it.
//
// This is a list of regular expressions tested against navigator.userAgent
//
// ** It should only be used on browser that *do* support the API, but
// incorrectly **
//
Dropzone.blacklistedBrowsers = [
// The mac os and windows phone version of opera 12 seems to have a problem with the File drag'n'drop API.
/opera.*(Macintosh|Windows Phone).*version\/12/i];

// Checks if the browser is supported
Dropzone.isBrowserSupported = function () {
  var capableBrowser = true;

  if (window.File && window.FileReader && window.FileList && window.Blob && window.FormData && document.querySelector) {
    if (!("classList" in document.createElement("a"))) {
      capableBrowser = false;
    } else {
      // The browser supports the API, but may be blacklisted.
      for (var _iterator35 = Dropzone.blacklistedBrowsers, _isArray35 = true, _i37 = 0, _iterator35 = _isArray35 ? _iterator35 : _iterator35[Symbol.iterator]();;) {
        var _ref34;

        if (_isArray35) {
          if (_i37 >= _iterator35.length) break;
          _ref34 = _iterator35[_i37++];
        } else {
          _i37 = _iterator35.next();
          if (_i37.done) break;
          _ref34 = _i37.value;
        }

        var regex = _ref34;

        if (regex.test(navigator.userAgent)) {
          capableBrowser = false;
          continue;
        }
      }
    }
  } else {
    capableBrowser = false;
  }

  return capableBrowser;
};

Dropzone.dataURItoBlob = function (dataURI) {
  // convert base64 to raw binary data held in a string
  // doesn't handle URLEncoded DataURIs - see SO answer #6850276 for code that does this
  var byteString = atob(dataURI.split(',')[1]);

  // separate out the mime component
  var mimeString = dataURI.split(',')[0].split(':')[1].split(';')[0];

  // write the bytes of the string to an ArrayBuffer
  var ab = new ArrayBuffer(byteString.length);
  var ia = new Uint8Array(ab);
  for (var i = 0, end = byteString.length, asc = 0 <= end; asc ? i <= end : i >= end; asc ? i++ : i--) {
    ia[i] = byteString.charCodeAt(i);
  }

  // write the ArrayBuffer to a blob
  return new Blob([ab], { type: mimeString });
};

// Returns an array without the rejected item
var without = function without(list, rejectedItem) {
  return list.filter(function (item) {
    return item !== rejectedItem;
  }).map(function (item) {
    return item;
  });
};

// abc-def_ghi -> abcDefGhi
var camelize = function camelize(str) {
  return str.replace(/[\-_](\w)/g, function (match) {
    return match.charAt(1).toUpperCase();
  });
};

// Creates an element from string
Dropzone.createElement = function (string) {
  var div = document.createElement("div");
  div.innerHTML = string;
  return div.childNodes[0];
};

// Tests if given element is inside (or simply is) the container
Dropzone.elementInside = function (element, container) {
  if (element === container) {
    return true;
  } // Coffeescript doesn't support do/while loops
  while (element = element.parentNode) {
    if (element === container) {
      return true;
    }
  }
  return false;
};

Dropzone.getElement = function (el, name) {
  var element = void 0;
  if (typeof el === "string") {
    element = document.querySelector(el);
  } else if (el.nodeType != null) {
    element = el;
  }
  if (element == null) {
    throw new Error("Invalid `" + name + "` option provided. Please provide a CSS selector or a plain HTML element.");
  }
  return element;
};

Dropzone.getElements = function (els, name) {
  var el = void 0,
      elements = void 0;
  if (els instanceof Array) {
    elements = [];
    try {
      for (var _iterator36 = els, _isArray36 = true, _i38 = 0, _iterator36 = _isArray36 ? _iterator36 : _iterator36[Symbol.iterator]();;) {
        if (_isArray36) {
          if (_i38 >= _iterator36.length) break;
          el = _iterator36[_i38++];
        } else {
          _i38 = _iterator36.next();
          if (_i38.done) break;
          el = _i38.value;
        }

        elements.push(this.getElement(el, name));
      }
    } catch (e) {
      elements = null;
    }
  } else if (typeof els === "string") {
    elements = [];
    for (var _iterator37 = document.querySelectorAll(els), _isArray37 = true, _i39 = 0, _iterator37 = _isArray37 ? _iterator37 : _iterator37[Symbol.iterator]();;) {
      if (_isArray37) {
        if (_i39 >= _iterator37.length) break;
        el = _iterator37[_i39++];
      } else {
        _i39 = _iterator37.next();
        if (_i39.done) break;
        el = _i39.value;
      }

      elements.push(el);
    }
  } else if (els.nodeType != null) {
    elements = [els];
  }

  if (elements == null || !elements.length) {
    throw new Error("Invalid `" + name + "` option provided. Please provide a CSS selector, a plain HTML element or a list of those.");
  }

  return elements;
};

// Asks the user the question and calls accepted or rejected accordingly
//
// The default implementation just uses `window.confirm` and then calls the
// appropriate callback.
Dropzone.confirm = function (question, accepted, rejected) {
  if (window.confirm(question)) {
    return accepted();
  } else if (rejected != null) {
    return rejected();
  }
};

// Validates the mime type like this:
//
// https://developer.mozilla.org/en-US/docs/HTML/Element/input#attr-accept
Dropzone.isValidFile = function (file, acceptedFiles) {
  if (!acceptedFiles) {
    return true;
  } // If there are no accepted mime types, it's OK
  acceptedFiles = acceptedFiles.split(",");

  var mimeType = file.type;
  var baseMimeType = mimeType.replace(/\/.*$/, "");

  for (var _iterator38 = acceptedFiles, _isArray38 = true, _i40 = 0, _iterator38 = _isArray38 ? _iterator38 : _iterator38[Symbol.iterator]();;) {
    var _ref35;

    if (_isArray38) {
      if (_i40 >= _iterator38.length) break;
      _ref35 = _iterator38[_i40++];
    } else {
      _i40 = _iterator38.next();
      if (_i40.done) break;
      _ref35 = _i40.value;
    }

    var validType = _ref35;

    validType = validType.trim();
    if (validType.charAt(0) === ".") {
      if (file.name.toLowerCase().indexOf(validType.toLowerCase(), file.name.length - validType.length) !== -1) {
        return true;
      }
    } else if (/\/\*$/.test(validType)) {
      // This is something like a image/* mime type
      if (baseMimeType === validType.replace(/\/.*$/, "")) {
        return true;
      }
    } else {
      if (mimeType === validType) {
        return true;
      }
    }
  }

  return false;
};

// Augment jQuery
if (typeof jQuery !== 'undefined' && jQuery !== null) {
  jQuery.fn.dropzone = function (options) {
    return this.each(function () {
      return new Dropzone(this, options);
    });
  };
}

if (typeof module !== 'undefined' && module !== null) {
  module.exports = Dropzone;
} else {
  window.Dropzone = Dropzone;
}

// Dropzone file status codes
Dropzone.ADDED = "added";

Dropzone.QUEUED = "queued";
// For backwards compatibility. Now, if a file is accepted, it's either queued
// or uploading.
Dropzone.ACCEPTED = Dropzone.QUEUED;

Dropzone.UPLOADING = "uploading";
Dropzone.PROCESSING = Dropzone.UPLOADING; // alias

Dropzone.CANCELED = "canceled";
Dropzone.ERROR = "error";
Dropzone.SUCCESS = "success";

/*

 Bugfix for iOS 6 and 7
 Source: http://stackoverflow.com/questions/11929099/html5-canvas-drawimage-ratio-bug-ios
 based on the work of https://github.com/stomita/ios-imagefile-megapixel

 */

// Detecting vertical squash in loaded image.
// Fixes a bug which squash image vertically while drawing into canvas for some images.
// This is a bug in iOS6 devices. This function from https://github.com/stomita/ios-imagefile-megapixel
var detectVerticalSquash = function detectVerticalSquash(img) {
  var iw = img.naturalWidth;
  var ih = img.naturalHeight;
  var canvas = document.createElement("canvas");
  canvas.width = 1;
  canvas.height = ih;
  var ctx = canvas.getContext("2d");
  ctx.drawImage(img, 0, 0);

  var _ctx$getImageData = ctx.getImageData(1, 0, 1, ih),
      data = _ctx$getImageData.data;

  // search image edge pixel position in case it is squashed vertically.


  var sy = 0;
  var ey = ih;
  var py = ih;
  while (py > sy) {
    var alpha = data[(py - 1) * 4 + 3];

    if (alpha === 0) {
      ey = py;
    } else {
      sy = py;
    }

    py = ey + sy >> 1;
  }
  var ratio = py / ih;

  if (ratio === 0) {
    return 1;
  } else {
    return ratio;
  }
};

// A replacement for context.drawImage
// (args are for source and destination).
var drawImageIOSFix = function drawImageIOSFix(ctx, img, sx, sy, sw, sh, dx, dy, dw, dh) {
  var vertSquashRatio = detectVerticalSquash(img);
  return ctx.drawImage(img, sx, sy, sw, sh, dx, dy, dw, dh / vertSquashRatio);
};

// Based on MinifyJpeg
// Source: http://www.perry.cz/files/ExifRestorer.js
// http://elicon.blog57.fc2.com/blog-entry-206.html

var ExifRestore = function () {
  function ExifRestore() {
    _classCallCheck(this, ExifRestore);
  }

  _createClass(ExifRestore, null, [{
    key: "initClass",
    value: function initClass() {
      this.KEY_STR = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
    }
  }, {
    key: "encode64",
    value: function encode64(input) {
      var output = '';
      var chr1 = undefined;
      var chr2 = undefined;
      var chr3 = '';
      var enc1 = undefined;
      var enc2 = undefined;
      var enc3 = undefined;
      var enc4 = '';
      var i = 0;
      while (true) {
        chr1 = input[i++];
        chr2 = input[i++];
        chr3 = input[i++];
        enc1 = chr1 >> 2;
        enc2 = (chr1 & 3) << 4 | chr2 >> 4;
        enc3 = (chr2 & 15) << 2 | chr3 >> 6;
        enc4 = chr3 & 63;
        if (isNaN(chr2)) {
          enc3 = enc4 = 64;
        } else if (isNaN(chr3)) {
          enc4 = 64;
        }
        output = output + this.KEY_STR.charAt(enc1) + this.KEY_STR.charAt(enc2) + this.KEY_STR.charAt(enc3) + this.KEY_STR.charAt(enc4);
        chr1 = chr2 = chr3 = '';
        enc1 = enc2 = enc3 = enc4 = '';
        if (!(i < input.length)) {
          break;
        }
      }
      return output;
    }
  }, {
    key: "restore",
    value: function restore(origFileBase64, resizedFileBase64) {
      if (!origFileBase64.match('data:image/jpeg;base64,')) {
        return resizedFileBase64;
      }
      var rawImage = this.decode64(origFileBase64.replace('data:image/jpeg;base64,', ''));
      var segments = this.slice2Segments(rawImage);
      var image = this.exifManipulation(resizedFileBase64, segments);
      return "data:image/jpeg;base64," + this.encode64(image);
    }
  }, {
    key: "exifManipulation",
    value: function exifManipulation(resizedFileBase64, segments) {
      var exifArray = this.getExifArray(segments);
      var newImageArray = this.insertExif(resizedFileBase64, exifArray);
      var aBuffer = new Uint8Array(newImageArray);
      return aBuffer;
    }
  }, {
    key: "getExifArray",
    value: function getExifArray(segments) {
      var seg = undefined;
      var x = 0;
      while (x < segments.length) {
        seg = segments[x];
        if (seg[0] === 255 & seg[1] === 225) {
          return seg;
        }
        x++;
      }
      return [];
    }
  }, {
    key: "insertExif",
    value: function insertExif(resizedFileBase64, exifArray) {
      var imageData = resizedFileBase64.replace('data:image/jpeg;base64,', '');
      var buf = this.decode64(imageData);
      var separatePoint = buf.indexOf(255, 3);
      var mae = buf.slice(0, separatePoint);
      var ato = buf.slice(separatePoint);
      var array = mae;
      array = array.concat(exifArray);
      array = array.concat(ato);
      return array;
    }
  }, {
    key: "slice2Segments",
    value: function slice2Segments(rawImageArray) {
      var head = 0;
      var segments = [];
      while (true) {
        var length;
        if (rawImageArray[head] === 255 & rawImageArray[head + 1] === 218) {
          break;
        }
        if (rawImageArray[head] === 255 & rawImageArray[head + 1] === 216) {
          head += 2;
        } else {
          length = rawImageArray[head + 2] * 256 + rawImageArray[head + 3];
          var endPoint = head + length + 2;
          var seg = rawImageArray.slice(head, endPoint);
          segments.push(seg);
          head = endPoint;
        }
        if (head > rawImageArray.length) {
          break;
        }
      }
      return segments;
    }
  }, {
    key: "decode64",
    value: function decode64(input) {
      var output = '';
      var chr1 = undefined;
      var chr2 = undefined;
      var chr3 = '';
      var enc1 = undefined;
      var enc2 = undefined;
      var enc3 = undefined;
      var enc4 = '';
      var i = 0;
      var buf = [];
      // remove all characters that are not A-Z, a-z, 0-9, +, /, or =
      var base64test = /[^A-Za-z0-9\+\/\=]/g;
      if (base64test.exec(input)) {
        console.warn('There were invalid base64 characters in the input text.\nValid base64 characters are A-Z, a-z, 0-9, \'+\', \'/\',and \'=\'\nExpect errors in decoding.');
      }
      input = input.replace(/[^A-Za-z0-9\+\/\=]/g, '');
      while (true) {
        enc1 = this.KEY_STR.indexOf(input.charAt(i++));
        enc2 = this.KEY_STR.indexOf(input.charAt(i++));
        enc3 = this.KEY_STR.indexOf(input.charAt(i++));
        enc4 = this.KEY_STR.indexOf(input.charAt(i++));
        chr1 = enc1 << 2 | enc2 >> 4;
        chr2 = (enc2 & 15) << 4 | enc3 >> 2;
        chr3 = (enc3 & 3) << 6 | enc4;
        buf.push(chr1);
        if (enc3 !== 64) {
          buf.push(chr2);
        }
        if (enc4 !== 64) {
          buf.push(chr3);
        }
        chr1 = chr2 = chr3 = '';
        enc1 = enc2 = enc3 = enc4 = '';
        if (!(i < input.length)) {
          break;
        }
      }
      return buf;
    }
  }]);

  return ExifRestore;
}();

ExifRestore.initClass();

/*
 * contentloaded.js
 *
 * Author: Diego Perini (diego.perini at gmail.com)
 * Summary: cross-browser wrapper for DOMContentLoaded
 * Updated: 20101020
 * License: MIT
 * Version: 1.2
 *
 * URL:
 * http://javascript.nwbox.com/ContentLoaded/
 * http://javascript.nwbox.com/ContentLoaded/MIT-LICENSE
 */

// @win window reference
// @fn function reference
var contentLoaded = function contentLoaded(win, fn) {
  var done = false;
  var top = true;
  var doc = win.document;
  var root = doc.documentElement;
  var add = doc.addEventListener ? "addEventListener" : "attachEvent";
  var rem = doc.addEventListener ? "removeEventListener" : "detachEvent";
  var pre = doc.addEventListener ? "" : "on";
  var init = function init(e) {
    if (e.type === "readystatechange" && doc.readyState !== "complete") {
      return;
    }
    (e.type === "load" ? win : doc)[rem](pre + e.type, init, false);
    if (!done && (done = true)) {
      return fn.call(win, e.type || e);
    }
  };

  var poll = function poll() {
    try {
      root.doScroll("left");
    } catch (e) {
      setTimeout(poll, 50);
      return;
    }
    return init("poll");
  };

  if (doc.readyState !== "complete") {
    if (doc.createEventObject && root.doScroll) {
      try {
        top = !win.frameElement;
      } catch (error) {}
      if (top) {
        poll();
      }
    }
    doc[add](pre + "DOMContentLoaded", init, false);
    doc[add](pre + "readystatechange", init, false);
    return win[add](pre + "load", init, false);
  }
};

// As a single function to be able to write tests.
Dropzone._autoDiscoverFunction = function () {
  if (Dropzone.autoDiscover) {
    return Dropzone.discover();
  }
};
contentLoaded(window, Dropzone._autoDiscoverFunction);

function __guard__(value, transform) {
  return typeof value !== 'undefined' && value !== null ? transform(value) : undefined;
}
function __guardMethod__(obj, methodName, transform) {
  if (typeof obj !== 'undefined' && obj !== null && typeof obj[methodName] === 'function') {
    return transform(obj, methodName);
  } else {
    return undefined;
  }
}


/*
---
name: Picker
description: Creates a Picker, which can be used for anything
authors: Arian Stolwijk
requires: [Core/Element.Dimensions, Core/Fx.Tween, Core/Fx.Transitions]
provides: Picker
...
*/


var Picker = new Class({

    Implements: [Options, Events],

    options: {/*
        onShow: function(){},
        onOpen: function(){},
        onHide: function(){},
        onClose: function(){},*/

        pickerClass: 'datepicker',
        inject: null,
        animationDuration: 400,
        useFadeInOut: true,
        positionOffset: {x: 0, y: 0},
        pickerPosition: 'bottom',
        draggable: true,
        showOnInit: true,
        columns: 1,
        footer: false
    },

    initialize: function(options){
        this.setOptions(options);
        this.constructPicker();
        if (this.options.showOnInit) this.show();
    },

    constructPicker: function(){
        var options = this.options;

        var picker = this.picker = new Element('div', {
            'class': options.pickerClass,
            styles: {
                left: 0,
                top: 0,
                display: 'none',
                opacity: 0
            }
        }).inject(options.inject || document.body);
        picker.addClass('column_' + options.columns);

        if (options.useFadeInOut){
            picker.set('tween', {
                duration: options.animationDuration,
                link: 'cancel'
            });
        }

        // Build the header
        var header = this.header = new Element('div.header').inject(picker);

        var title = this.title = new Element('div.title').inject(header);
        var titleID = this.titleID = 'pickertitle-' + String.uniqueID();
        this.titleText = new Element('div', {
            'role': 'heading',
            'class': 'titleText',
            'id': titleID,
            'aria-live': 'assertive',
            'aria-atomic': 'true'
        }).inject(title);

        this.closeButton = new Element('div.closeButton[text=x][role=button]')
            .addEvent('click', this.close.pass(false, this))
            .inject(header);

        // Build the body of the picker
        var body = this.body = new Element('div.body').inject(picker);

        if (options.footer){
            this.footer = new Element('div.footer').inject(picker);
            picker.addClass('footer');
        }

        // oldContents and newContents are used to slide from the old content to a new one.
        var slider = this.slider = new Element('div.slider', {
            styles: {
                position: 'absolute',
                top: 0,
                left: 0
            }
        }).set('tween', {
            duration: options.animationDuration,
            transition: Fx.Transitions.Quad.easeInOut
        }).inject(body);

        this.newContents = new Element('div', {
            styles: {
                position: 'absolute',
                top: 0,
                left: 0
            }
        }).inject(slider);

        this.oldContents = new Element('div', {
            styles: {
                position: 'absolute',
                top: 0
            }
        }).inject(slider);

        this.originalColumns = options.columns;
        this.setColumns(options.columns);

        // IFrameShim for select fields in IE
        var shim = this.shim = window['IframeShim'] ? new IframeShim(picker) : null;

        // Dragging
        if (options.draggable && typeOf(picker.makeDraggable) == 'function'){
            this.dragger = picker.makeDraggable(shim ? {
                onDrag: shim.position.bind(shim)
            } : null);
            picker.setStyle('cursor', 'move');
        }
    },

    open: function(noFx){
        if (this.opened == true) return this;
        this.opened = true;
        var self = this,
            picker = this.picker.setStyle('display', 'block').set('aria-hidden', 'false')
        if (this.shim) this.shim.show();
        this.fireEvent('open');
        if (this.options.useFadeInOut && !noFx){
            picker.get('tween').start('opacity', 1).chain(function(){
                self.fireEvent('show');
                this.callChain();
            });
        } else {
            picker.setStyle('opacity', 1);
            this.fireEvent('show');
        }
        return this;
    },

    show: function(){
        return this.open(true);
    },

    close: function(noFx){
        if (this.opened == false) return this;
        this.opened = false;
        this.fireEvent('close');
        var self = this, picker = this.picker, hide = function(){
            picker.setStyle('display', 'none').set('aria-hidden', 'true');
            if (self.shim) self.shim.hide();
            self.fireEvent('hide');
        };
        if (this.options.useFadeInOut && !noFx){
            picker.get('tween').start('opacity', 0).chain(hide);
        } else {
            picker.setStyle('opacity', 0);
            hide();
        }
        return this;
    },

    hide: function(){
        return this.close(true);
    },

    toggle: function(){
        return this[this.opened == true ? 'close' : 'open']();
    },

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

    position: function(x, y){
        var offset = this.options.positionOffset,
            scroll = document.getScroll(),
            size = document.getSize(),
            pickersize = this.picker.getSize();

        if (typeOf(x) == 'element'){
            var element = x,
                where = y || this.options.pickerPosition;

            var elementCoords = element.getCoordinates();

            x = (where == 'left') ? elementCoords.left - pickersize.x
                : (where == 'bottom' || where == 'top') ? elementCoords.left
                : elementCoords.right
            y = (where == 'bottom') ? elementCoords.bottom
                : (where == 'top') ? elementCoords.top - pickersize.y
                : elementCoords.top;
        }

        x += offset.x * ((where && where == 'left') ? -1 : 1);
        y += offset.y * ((where && where == 'top') ? -1: 1);

        if ((x + pickersize.x) > (size.x + scroll.x)) x = (size.x + scroll.x) - pickersize.x;
        if ((y + pickersize.y) > (size.y + scroll.y)) y = (size.y + scroll.y) - pickersize.y;
        if (x < 0) x = 0;
        if (y < 0) y = 0;

        this.picker.setStyles({
            left: x,
            top: y
        });
        if (this.shim) this.shim.position();
        return this;
    },

    setBodySize: function(){
        var bodysize = this.bodysize = this.body.getSize();

        this.slider.setStyles({
            width: 2 * bodysize.x,
            height: bodysize.y
        });
        this.oldContents.setStyles({
            left: bodysize.x,
            width: bodysize.x,
            height: bodysize.y
        });
        this.newContents.setStyles({
            width: bodysize.x,
            height: bodysize.y
        });
    },

    setColumnContent: function(column, content){
        var columnElement = this.columns[column];
        if (!columnElement) return this;

        var type = typeOf(content);
        if (['string', 'number'].contains(type)) columnElement.set('text', content);
        else columnElement.empty().adopt(content);

        return this;
    },

    setColumnsContent: function(content, fx){
        var old = this.columns;
        this.columns = this.newColumns;
        this.newColumns = old;

        content.forEach(function(_content, i){
            this.setColumnContent(i, _content);
        }, this);
        return this.setContent(null, fx);
    },

    setColumns: function(columns){
        var _columns = this.columns = new Elements, _newColumns = this.newColumns = new Elements;
        for (var i = columns; i--;){
            _columns.push(new Element('div.column').addClass('column_' + (columns - i)));
            _newColumns.push(new Element('div.column').addClass('column_' + (columns - i)));
        }

        var oldClass = 'column_' + this.options.columns, newClass = 'column_' + columns;
        this.picker.removeClass(oldClass).addClass(newClass);

        this.options.columns = columns;
        return this;
    },

    setContent: function(content, fx){
        if (content) return this.setColumnsContent([content], fx);

        // swap contents so we can fill the newContents again and animate
        var old = this.oldContents;
        this.oldContents = this.newContents;
        this.newContents = old;
        this.newContents.empty();

        this.newContents.adopt(this.columns);

        this.setBodySize();

        if (fx){
            this.fx(fx);
        } else {
            this.slider.setStyle('left', 0);
            this.oldContents.setStyles({left: this.bodysize.x, opacity: 0});
            this.newContents.setStyles({left: 0, opacity: 1});
        }
        return this;
    },

    fx: function(fx){
        var oldContents = this.oldContents,
            newContents = this.newContents,
            slider = this.slider,
            bodysize = this.bodysize;
        if (fx == 'right'){
            oldContents.setStyles({left: 0, opacity: 1});
            newContents.setStyles({left: bodysize.x, opacity: 1});
            slider.setStyle('left', 0).tween('left', 0, -bodysize.x);
        } else if (fx == 'left'){
            oldContents.setStyles({left: bodysize.x, opacity: 1});
            newContents.setStyles({left: 0, opacity: 1});
            slider.setStyle('left', -bodysize.x).tween('left', -bodysize.x, 0);
        } else if (fx == 'fade'){
            slider.setStyle('left', 0);
            oldContents.setStyle('left', 0).set('tween', {
                duration: this.options.animationDuration / 2
            }).tween('opacity', 1, 0).get('tween').chain(function(){
                oldContents.setStyle('left', bodysize.x);
            });
            newContents.setStyles({opacity: 0, left: 0}).set('tween', {
                duration: this.options.animationDuration
            }).tween('opacity', 0, 1);
        }
    },

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

    setTitle: function(content, fn){
        if (!fn) fn = Function.from;
        this.titleText.empty().adopt(
            Array.convert(content).map(function(item, i){
                return typeOf(item) == 'element'
                    ? item
                    : new Element('div.column', {text: fn(item, this.options)}).addClass('column_' + (i + 1));
            }, this)
        );
        return this;
    },

    setTitleEvent: function(fn){
        this.titleText.removeEvents('click');
        if (fn) this.titleText.addEvent('click', fn);
        this.titleText.setStyle('cursor', fn ? 'pointer' : '');
        return this;
    }

});

/*
---
name: Picker.Attach
description: Adds attach and detach methods to the Picker, to attach it to element events
authors: Arian Stolwijk
requires: [Picker, Core/Element.Event]
provides: Picker.Attach
...
*/


Picker.Attach = new Class({

    Extends: Picker,

    options: {/*
        onAttached: function(event){},
        toggleElements: null, // deprecated
        toggle: null, // When set it deactivate toggling by clicking on the input */
        togglesOnly: true, // set to false to always make calendar popup on input element, if true, it depends on the toggles elements set.
        showOnInit: false, // overrides the Picker option
        blockKeydown: true
    },

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

        this.attachedEvents = [];
        this.attachedElements = [];
        this.toggles = [];
        this.inputs = [];

        var documentEvent = function(event){
            if (this.attachedElements.contains(event.target)) return;
            this.close();
        }.bind(this);
        var document = this.picker.getDocument().addEvent('click', documentEvent);

        var preventPickerClick = function(event){
            event.stopPropagation();
            return false;
        };
        this.picker.addEvent('click', preventPickerClick);

        // Support for deprecated toggleElements
        if (this.options.toggleElements) this.options.toggle = document.getElements(this.options.toggleElements);

        this.attach(attachTo, this.options.toggle);
    },

    attach: function(attachTo, toggle){
        if (typeOf(attachTo) == 'string') attachTo = document.id(attachTo);
        if (typeOf(toggle) == 'string') toggle = document.id(toggle);

        var elements = Array.convert(attachTo),
            toggles = Array.convert(toggle),
            allElements = [].append(elements).combine(toggles),
            self = this;

        var closeEvent = function(event){
            var stopInput = self.options.blockKeydown
                    && event.type == 'keydown'
                    && !(['tab', 'esc'].contains(event.key)),
                isCloseKey = event.type == 'keydown'
                    && (['tab', 'esc'].contains(event.key)),
                isA = event.target.get('tag') == 'a';

            if (stopInput || isA) event.preventDefault();
            if (isCloseKey || isA) self.close();
        };

        var getOpenEvent = function(element){
            return function(event){
                var tag = event.target.get('tag');
                if (tag == 'input' && event.type == 'click' && !element.match(':focus') || (self.opened && self.input == element)) return;
                if (tag == 'a') event.stop();
                self.position(element);
                self.open();
                self.fireEvent('attached', [event, element]);
            };
        };

        var getToggleEvent = function(open, close){
            return function(event){
                if (self.opened) close(event);
                else open(event);
            };
        };

        allElements.each(function(element){

            // The events are already attached!
            if (self.attachedElements.contains(element)) return;

            var events = {},
                tag = element.get('tag'),
                openEvent = getOpenEvent(element),
                // closeEvent does not have a depency on element
                toggleEvent = getToggleEvent(openEvent, closeEvent);

            if (tag == 'input'){
                // Fix in order to use togglers only
                if (!self.options.togglesOnly || !toggles.length){
                    events = {
                        focus: openEvent,
                        click: openEvent,
                        keydown: closeEvent
                    };
                }
                self.inputs.push(element);
            } else {
                if (toggles.contains(element)){
                    self.toggles.push(element);
                    events.click = toggleEvent
                } else {
                    events.click = openEvent;
                }
            }
            element.addEvents(events);
            self.attachedElements.push(element);
            self.attachedEvents.push(events);
        });
        return this;
    },

    detach: function(attachTo, toggle){
        if (typeOf(attachTo) == 'string') attachTo = document.id(attachTo);
        if (typeOf(toggle) == 'string') toggle = document.id(toggle);

        var elements = Array.convert(attachTo),
            toggles = Array.convert(toggle),
            allElements = [].append(elements).combine(toggles),
            self = this;

        if (!allElements.length) allElements = self.attachedElements;

        allElements.each(function(element){
            var i = self.attachedElements.indexOf(element);
            if (i < 0) return;

            var events = self.attachedEvents[i];
            element.removeEvents(events);
            delete self.attachedEvents[i];
            delete self.attachedElements[i];

            var toggleIndex = self.toggles.indexOf(element);
            if (toggleIndex != -1) delete self.toggles[toggleIndex];

            var inputIndex = self.inputs.indexOf(element);
            if (toggleIndex != -1) delete self.inputs[inputIndex];
        });
        return this;
    },

    destroy: function(){
        this.detach();
        return this.parent();
    }

});

/*
---
name: Picker.Date
description: Creates a DatePicker, can be used for picking years/months/days and time, or all of them
authors: Arian Stolwijk
requires: [Picker, Picker.Attach, Locale.en-US.DatePicker, More/Locale, More/Date]
provides: Picker.Date
...
*/


(function(){

this.DatePicker = Picker.Date = new Class({

    Extends: Picker.Attach,

    options: {/*
        onSelect: function(date){},
        minDate: new Date('3/4/2010'), // Date object or a string
        maxDate: new Date('3/4/2011'), // same as minDate
        availableDates: {}, //
        invertAvailable: false,
        format: null,*/

        timePicker: false,
        timePickerOnly: false, // deprecated, use onlyView = 'time'
        timeWheelStep: 1, // 10,15,20,30

        yearPicker: true,
        yearsPerPage: 20,

        startDay: 1, // Sunday (0) through Saturday (6) - be aware that this may affect your layout, since the days on the right might have a different margin
        rtl: false,

        startView: 'days', // allowed values: {time, days, months, years}
        openLastView: false,
        pickOnly: false, // 'years', 'months', 'days', 'time'
        canAlwaysGoUp: ['months', 'days'],
        updateAll : false, //whether or not to update all inputs when selecting a date

        weeknumbers: false,

        // if you like to use your own translations
        months_abbr: null,
        days_abbr: null,
        years_title: function(date, options){
            var year = date.get('year');
            return year + '-' + (year + options.yearsPerPage - 1);
        },
        months_title: function(date, options){
            return date.get('year');
        },
        days_title: function(date, options){
            return date.format('%b %Y');
        },
        time_title: function(date, options){
            return (options.pickOnly == 'time') ? Locale.get('DatePicker.select_a_time') : date.format('%d %B, %Y');
        }
    },

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

        this.setOptions(options);
        options = this.options;

        // If we only want to use one picker / backwards compatibility
        ['year', 'month', 'day', 'time'].some(function(what){
            if (options[what + 'PickerOnly']){
                options.pickOnly = what;
                return true;
            }
            return false;
        });
        if (options.pickOnly){
            options[options.pickOnly + 'Picker'] = true;
            options.startView = options.pickOnly;
        }

        // backward compatibility for startView
        var newViews = ['days', 'months', 'years'];
        ['month', 'year', 'decades'].some(function(what, i){
            return (options.startView == what) && (options.startView = newViews[i]);
        });

        options.canAlwaysGoUp = options.canAlwaysGoUp ? Array.convert(options.canAlwaysGoUp) : [];

        // Set the min and max dates as Date objects
        if (options.minDate){
            if (!(options.minDate instanceof Date)) options.minDate = Date.parse(options.minDate);
            options.minDate.clearTime();
        }
        if (options.maxDate){
            if (!(options.maxDate instanceof Date)) options.maxDate = Date.parse(options.maxDate);
            options.maxDate.clearTime();
        }

        if (!options.format){
            options.format = (options.pickOnly != 'time') ? Locale.get('Date.shortDate') : '';
            if (options.timePicker) options.format = (options.format) + (options.format ? ' ' : '') + Locale.get('Date.shortTime');
        }

        // Some link or input has fired an event!
        this.addEvent('attached', function(event, element){

            // This is where we store the selected date
            if (!this.currentView || !options.openLastView) this.currentView = options.startView;

            this.date = limitDate(new Date(), options.minDate, options.maxDate);
            var tag = element.get('tag'), input;
            if (tag == 'input') input = element;
            else {
                var index = this.toggles.indexOf(element);
                if (this.inputs[index]) input = this.inputs[index];
            }
            this.getInputDate(input);
            this.input = input;
            this.setColumns(this.originalColumns);
        }.bind(this), true);

    },

    getDateByFormatDate : function(date, dateObj) {
        var dateKeys = {
            '%d' : '1',
            '%m' : '1',
            '%Y' : '1970'
        };

        if (String(date) === '') {
            return new Date();
        }

        if (typeof dateObj === 'undefined') {
            dateObj = false;
        }

        var regexStr  = this.options.format.replace(/%[a-z]{1}/gi, '([0-9]+)');

        format = this.options.format.match(/%[a-z]{1}/ig);

        if (!format) {
            return date;
        }

        regexStr = regexStr.replace(/\./g, '\\.');
        regexStr = regexStr.replace(/\//, '\/');

        date = date.match(new RegExp(regexStr));

        var ret = this.options.format;

        for (var i = 0; i < format.length; i++) {
            if (!date || !date[i+1]) {
                continue;
            }

            ret = ret.replace(format[i], date[i+1]);
            dateKeys[format[i]] = date[i+1];
        }

        if (dateObj) {
        	format = format.clean();

            ret = new Date(dateKeys["%Y"], (parseInt(dateKeys["%m"]) - 1), dateKeys["%d"]);

            if (format.length === 5) {
            	ret = new Date(dateKeys["%Y"], (parseInt(dateKeys["%m"]) - 1), dateKeys["%d"], dateKeys["%H"], dateKeys["%M"]);
            }

            if (format.length === 6) {
            	ret = new Date(dateKeys["%Y"], (parseInt(dateKeys["%m"]) - 1), dateKeys["%d"], dateKeys["%H"], dateKeys["%M"], dateKeys["%S"]);
            }
        }

        return ret;
    },

    getInputDate: function(input){
        this.date = new Date();
        if (!input) return;

        if (input.get('value') !== '') {
            var date = this.getDateByFormatDate(input.get('value'), true);
        } else {
            var date = this.date;

			var timeParts = input.get('data-default-time') ? input.get('data-default-time').split(':') : [];

			if (timeParts.length === 3) {
				this.date.setHours(timeParts[0], timeParts[1], timeParts[2], 0);
			}
        }

        if (date == null || !date.isValid()){
            var storeDate = input.retrieve('datepicker:value');
            if (storeDate) date = Date.parse(storeDate);
        }


        if (date != null && date.isValid()) this.date = date;
    },

    // Control the previous and next elements

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

        if (!this.options.rtl){
            this.previous = new Element('div.previous[html=&#171;]').inject(this.header);
            this.next = new Element('div.next[html=&#187;]').inject(this.header);
        } else {
            this.next = new Element('div.previous[html=&#171;]').inject(this.header);
            this.previous = new Element('div.next[html=&#187;]').inject(this.header);
        }
    },

    hidePrevious: function(_next, _show){
        this[_next ? 'next' : 'previous'].setStyle('display', _show ? 'block' : 'none');
        return this;
    },

    showPrevious: function(_next){
        return this.hidePrevious(_next, true);
    },

    setPreviousEvent: function(fn, _next){
        this[_next ? 'next' : 'previous'].removeEvents('click');
        if (fn) this[_next ? 'next' : 'previous'].addEvent('click', fn);
        return this;
    },

    hideNext: function(){
        return this.hidePrevious(true);
    },

    showNext: function(){
        return this.showPrevious(true);
    },

    setNextEvent: function(fn){
        return this.setPreviousEvent(fn, true);
    },

    setColumns: function(columns, view, date, viewFx){
        var ret = this.parent(columns), method;

        if ((view || this.currentView)
            && (method = 'render' + (view || this.currentView).capitalize())
            && this[method]
        ) this[method](date || this.date.clone(), viewFx);

        return ret;
    },

    // Render the Pickers

    renderYears: function(date, fx){
        var options = this.options, pages = options.columns, perPage = options.yearsPerPage,
            _columns = [], _dates = [];
        this.dateElements = [];

        // start neatly at interval (eg. 1980 instead of 1987)
        date = date.clone().decrement('year', date.get('year') % perPage);

        var iterateDate = date.clone().decrement('year', Math.floor((pages - 1) / 2) * perPage);

        for (var i = pages; i--;){
            var _date = iterateDate.clone();
            _dates.push(_date);
            _columns.push(renderers.years(
                timesSelectors.years(options, _date.clone()),
                options,
                this.date.clone(),
                this.dateElements,
                function(date){
                    if (options.pickOnly == 'years') this.select(date);
                    else this.renderMonths(date, 'fade');
                    this.date = date;
                }.bind(this)
            ));
            iterateDate.increment('year', perPage);
        }

        this.setColumnsContent(_columns, fx);
        this.setTitle(_dates, options.years_title);

        // Set limits
        var limitLeft = (options.minDate && date.get('year') <= options.minDate.get('year')),
            limitRight = (options.maxDate && (date.get('year') + options.yearsPerPage) >= options.maxDate.get('year'));
        this[(limitLeft ? 'hide' : 'show') + 'Previous']();
        this[(limitRight ? 'hide' : 'show') + 'Next']();

        this.setPreviousEvent(function(){
            this.renderYears(date.decrement('year', perPage), 'left');
        }.bind(this));

        this.setNextEvent(function(){
            this.renderYears(date.increment('year', perPage), 'right');
        }.bind(this));

        // We can't go up!
        this.setTitleEvent(null);

        this.currentView = 'years';
    },

    renderMonths: function(date, fx){
        var options = this.options, years = options.columns, _columns = [], _dates = [],
            iterateDate = date.clone().decrement('year', Math.floor((years - 1) / 2));
        this.dateElements = [];

        for (var i = years; i--;){
            var _date = iterateDate.clone();
            _dates.push(_date);
            _columns.push(renderers.months(
                timesSelectors.months(options, _date.clone()),
                options,
                this.date.clone(),
                this.dateElements,
                function(date){
                    if (options.pickOnly == 'months') this.select(date);
                    else this.renderDays(date, 'fade');
                    this.date = date;
                }.bind(this)
            ));
            iterateDate.increment('year', 1);
        }

        this.setColumnsContent(_columns, fx);
        this.setTitle(_dates, options.months_title);

        // Set limits
        var year = date.get('year'),
            limitLeft = (options.minDate && year <= options.minDate.get('year')),
            limitRight = (options.maxDate && year >= options.maxDate.get('year'));
        this[(limitLeft ? 'hide' : 'show') + 'Previous']();
        this[(limitRight ? 'hide' : 'show') + 'Next']();

        this.setPreviousEvent(function(){
            this.renderMonths(date.decrement('year', years), 'left');
        }.bind(this));

        this.setNextEvent(function(){
            this.renderMonths(date.increment('year', years), 'right');
        }.bind(this));

        var canGoUp = options.yearPicker && (options.pickOnly != 'months' || options.canAlwaysGoUp.contains('months'));
        var titleEvent = (canGoUp) ? function(){
            this.renderYears(date, 'fade');
        }.bind(this) : null;
        this.setTitleEvent(titleEvent);

        this.currentView = 'months';
    },

    renderDays: function(date, fx){
        var options = this.options, months = options.columns, _columns = [], _dates = [],
            iterateDate = date.clone().decrement('month', Math.floor((months - 1) / 2));
        this.dateElements = [];

        for (var i = months; i--;){
            var _date = iterateDate.clone();

            _dates.push(_date);

            _columns.push(renderers.days(
                timesSelectors.days(options, _date.clone()),
                options,
                this.date.clone(),
                this.dateElements,
                function(date){
                    if (options.pickOnly == 'days' || !options.timePicker) this.select(date)
                    else this.renderTime(date, 'fade');
                    this.date = date;
                }.bind(this)
            ));
            iterateDate.increment('month', 1);
        }

        this.setColumnsContent(_columns, fx);
        this.setTitle(_dates, options.days_title);

        var yearmonth = date.format('%Y%m').toInt(),
            limitLeft = (options.minDate && yearmonth <= options.minDate.format('%Y%m')),
            limitRight = (options.maxDate && yearmonth >= options.maxDate.format('%Y%m'));
        this[(limitLeft ? 'hide' : 'show') + 'Previous']();
        this[(limitRight ? 'hide' : 'show') + 'Next']();

        this.setPreviousEvent(function(){
            this.renderDays(date.decrement('month', months), 'left');
        }.bind(this));

        this.setNextEvent(function(){
            this.renderDays(date.increment('month', months), 'right');
        }.bind(this));

        var canGoUp = options.pickOnly != 'days' || options.canAlwaysGoUp.contains('days');
        var titleEvent = (canGoUp) ? function(){
            this.renderMonths(date, 'fade');
        }.bind(this) : null;
        this.setTitleEvent(titleEvent);

        this.currentView = 'days';
    },

    renderTime: function(date, fx){
        var options = this.options;
        this.setTitle(date, options.time_title);

        var originalColumns = this.originalColumns = options.columns;
        this.currentView = null; // otherwise you'd get crazy recursion
        if (originalColumns != 1) this.setColumns(1);

        this.setContent(renderers.time(
            options,
            date.clone(),
            function(date){
                this.select(date);
            }.bind(this)
        ), fx);

        // Hide « and » buttons
        this.hidePrevious()
            .hideNext()
            .setPreviousEvent(null)
            .setNextEvent(null);

        var canGoUp = options.pickOnly != 'time' || options.canAlwaysGoUp.contains('time');
        var titleEvent = (canGoUp) ? function(){
            this.setColumns(originalColumns, 'days', date, 'fade');
        }.bind(this) : null;
        this.setTitleEvent(titleEvent);

        this.currentView = 'time';
    },

    select: function(date, all){
        this.date = date;
        var formatted = date.format(this.options.format),
            time = date.strftime(),
            inputs = (!this.options.updateAll && !all && this.input) ? [this.input] : this.inputs;

        inputs.each(function(input){
            input.set('value', formatted).store('datepicker:value', time).fireEvent('change');
        }, this);

        this.fireEvent('select', [date].concat(inputs));
        this.close();
        return this;
    }

});


// Renderers only output elements and calculate the limits!

var timesSelectors = {

    years: function(options, date){
        var times = [];
        for (var i = 0; i < options.yearsPerPage; i++){
            times.push(+date);
            date.increment('year', 1);
        }
        return times;
    },

    months: function(options, date){
        var times = [];
        date.set('month', 0);
        for (var i = 0; i <= 11; i++){
            times.push(+date);
            date.increment('month', 1);
        }
        return times;
    },

    days: function(options, date){
        var times = [];
        date.set('date', 1);
        while (date.get('day') != options.startDay) date.set('date', date.get('date') - 1);
        for (var i = 0; i < 42; i++){
            times.push(+date);
            date.increment('day',  1);
        }
        return times;
    }

};

var renderers = {

    years: function(years, options, currentDate, dateElements, fn){
        var container = new Element('table.years'),
            today     = new Date(),
            rows      = [],
            element, classes;

        years.each(function(_year, i){
            var date = new Date(_year), year = date.get('year');
            if (i % 4 === 0) {
                rows.push(new Element('tr'));
                rows[rows.length - 1].inject(container)
            }
            classes = '.year.year' + i;
            if (year == today.get('year')) classes += '.today';
            if (year == currentDate.get('year')) classes += '.selected';
            element = new Element('td' + classes, {text: year}).inject(rows[rows.length - 1]);

            dateElements.push({element: element, time: _year});

            if (isUnavailable('year', date, options)) element.addClass('unavailable');
            else element.addEvent('click', fn.pass(date));
        });

        return container;
    },

    months: function(months, options, currentDate, dateElements, fn){
        var today        = new Date(),
            month        = today.get('month'),
            thisyear     = today.get('year'),
            selectedyear = currentDate.get('year'),
            container    = new Element('table.months'),
            monthsAbbr   = options.months_abbr || Locale.get('Date.months_abbr'),
            rows         = [],
            element, classes;

        months.each(function(_month, i){
            var date = new Date(_month), year = date.get('year');
            if (i % 3 === 0) {
                rows.push(new Element('tr'));
                rows[rows.length - 1].inject(container)
            }

            classes = '.month.month' + (i + 1);
            if (i == month && year == thisyear) classes += '.today';
            if (i == currentDate.get('month') && year == selectedyear) classes += '.selected';
            element = new Element('td' + classes, {text: monthsAbbr[i]}).inject(rows[rows.length - 1]);
            dateElements.push({element: element, time: _month});

            if (isUnavailable('month', date, options)) element.addClass('unavailable');
            else element.addEvent('click', fn.pass(date));
        });

        return container;
    },

    days: function(days, options, currentDate, dateElements, fn){
        var month = new Date(days[14]).get('month'),
            todayString = new Date().toDateString(),
            currentString = currentDate.toDateString(),
            weeknumbers = options.weeknumbers,
            container = new Element('table.days' + (weeknumbers ? '.weeknumbers' : ''), {
                role: 'grid', 'aria-labelledby': this.titleID
            }),
            header = new Element('thead').inject(container),
            body = new Element('tbody').inject(container),
            titles = new Element('tr.titles').inject(header),
            localeDaysShort = options.days_abbr || Locale.get('Date.days_abbr'),
            day, classes, element, weekcontainer, dateString,
            where = options.rtl ? 'top' : 'bottom';

        if (weeknumbers) new Element('th.title.day.weeknumber', {
            text: Locale.get('DatePicker.week')
        }).inject(titles);

        for (day = options.startDay; day < (options.startDay + 7); day++){
            new Element('th.title.day.day' + (day % 7), {
                text: localeDaysShort[(day % 7)],
                role: 'columnheader'
            }).inject(titles, where);
        }

        days.each(function(_date, i){
            var date = new Date(_date);

            if (i % 7 == 0){
                weekcontainer = new Element('tr.week.week' + (Math.floor(i / 7))).set('role', 'row').inject(body);
                if (weeknumbers) new Element('th.day.weeknumber', {text: date.get('week'), scope: 'row', role: 'rowheader'}).inject(weekcontainer);
            }

            dateString = date.toDateString();
            classes = '.day.day' + date.get('day');
            if (dateString == todayString) classes += '.today';
            if (date.get('month') != month) classes += '.otherMonth';
            element = new Element('td' + classes, {text: date.getDate(), role: 'gridcell'}).inject(weekcontainer, where);

            if (dateString == currentString) element.addClass('selected').set('aria-selected', 'true');
            else element.set('aria-selected', 'false');

            dateElements.push({element: element, time: _date});


            if (isUnavailable('date', date, options)) {
            	element.addClass('unavailable');
            } else {
            	element.addEvent('click', fn.pass(date.clone()));
            }
        });

        return container;
    },

    time: function(options, date, fn){
        var container = new Element('div.time'),
            // make sure that the minutes are timeWheelStep * k

            initMinutes = (date.get('minutes') / options.timeWheelStep).round() * options.timeWheelStep
            initSeconds = (date.get('seconds') / options.timeWheelStep).round() * options.timeWheelStep

        if (initMinutes >= 60) {
        	initMinutes = 0;
        }

        if (initSeconds >= 60) {
        	initSeconds = 0;
        }

        date.set('minutes', initMinutes);
        date.set('seconds', initSeconds);

        var hoursInput = new Element('input.hour[type=text]', {
            title: Locale.get('DatePicker.use_mouse_wheel'),
            value: date.format('%H'),
            events: {
                click: function(event){
                    event.target.focus();
                    event.stop();
                },
                mousewheel: function(event){
                    event.stop();
                    hoursInput.focus();
                    var value = hoursInput.get('value').toInt();
                    value = (event.wheel > 0) ? ((value < 23) ? value + 1 : 0)
                        : ((value > 0) ? value - 1 : 23)
                    date.set('hours', value);
                    hoursInput.set('value', date.format('%H'));
                }.bind(this)
            },
            maxlength: 2
        }).inject(container);

        new Element('div.separator[text=:]').inject(container);

        var minutesInput = new Element('input.minutes[type=text]', {
            title: Locale.get('DatePicker.use_mouse_wheel'),
            value: date.format('%M'),
            events: {
                click: function(event){
                    event.target.focus();
                    event.stop();
                },
                mousewheel: function(event){
                    event.stop();
                    minutesInput.focus();
                    var value = minutesInput.get('value').toInt();
                    value = (event.wheel > 0) ? ((value < 59) ? (value + options.timeWheelStep) : 0)
                        : ((value > 0) ? (value - options.timeWheelStep) : (60 - options.timeWheelStep));
                    if (value >= 60) value = 0;
                    date.set('minutes', value);
                    minutesInput.set('value', date.format('%M'));
                }.bind(this)
            },
            maxlength: 2
        }).inject(container);

        new Element('div.separator[text=:]').inject(container);

        var secondsInput = new Element('input.seconds[type=text]', {
            title: Locale.get('DatePicker.use_mouse_wheel'),
            value: date.format('%S'),
            events: {
                click: function(event){
                    event.target.focus();
                    event.stop();
                },

                mousewheel: function(event){
                    event.stop();

                    secondsInput.focus();
                    var value = secondsInput.get('value').toInt();

                    value = (event.wheel > 0) ? ((value < 59) ? (value + options.timeWheelStep) : 0)
                        : ((value > 0) ? (value - options.timeWheelStep) : (60 - options.timeWheelStep));
                    if (value >= 60) value = 0;

                    date.set('seconds', value);
                    secondsInput.set('value', date.format('%S'));
                }.bind(this)
            },

            maxlength: 2
        }).inject(container);


        new Element('input.ok', {
            'type': 'submit',
            value: Locale.get('DatePicker.time_confirm_button'),
            events: {click: function(event){
                event.stop();

                date.set({
                    hours: hoursInput.get('value').toInt(),
                    minutes: minutesInput.get('value').toInt(),
                    seconds: secondsInput.get('value').toInt()
                });
                fn(date.clone());
            }}
        }).inject(container);

        return container;
    }

};


Picker.Date.defineRenderer = function(name, fn){
    renderers[name] = fn;
    return this;
};

Picker.Date.getRenderer = function(name) {
    return renderers[name];
}

var limitDate = function(date, min, max){
    if (min && date < min) return min;
    if (max && date > max) return max;
    return date;
};

var isUnavailable = function(type, date, options){
    var minDate = options.minDate,
        maxDate = options.maxDate,
        availableDates = options.availableDates,
        year, month, day, ms;

    if (!minDate && !maxDate && !availableDates) return false;

    if (!options.timePicker) {
    	date.clearTime();
    }

    if (type == 'year'){
        year = date.get('year');
        return (
            (minDate && year < minDate.get('year')) ||
            (maxDate && year > maxDate.get('year')) ||
            (
                (availableDates != null &&  !options.invertAvailable) && (
                    availableDates[year] == null ||
                    Object.getLength(availableDates[year]) == 0 ||
                    Object.getLength(
                        Object.filter(availableDates[year], function(days){
                            return (days.length > 0);
                        })
                    ) == 0
                )
            )
        );
    }

    if (type == 'month'){
        year = date.get('year');
        month = date.get('month') + 1;
        ms = date.format('%Y%m').toInt();
        return (
            (minDate && ms < minDate.format('%Y%m').toInt()) ||
            (maxDate && ms > maxDate.format('%Y%m').toInt()) ||
            (
                (availableDates != null && !options.invertAvailable) && (
                    availableDates[year] == null ||
                    availableDates[year][month] == null ||
                    availableDates[year][month].length == 0
                )
            )
        );
    }

    // type == 'date'
    year = date.get('year');
    month = date.get('month') + 1;
    day = date.get('date');

    var dateAllow = (minDate && date < minDate) || (maxDate && date > maxDate);
    if (availableDates != null){
        dateAllow = dateAllow
            || availableDates[year] == null
            || availableDates[year][month] == null
            || !availableDates[year][month].contains(day);
        if (options.invertAvailable) dateAllow = !dateAllow;
    }

    return dateAllow;
};

})();

/**
 * smartcrop.js
 * A javascript library implementing content aware image cropping
 *
 * Copyright (C) 2016 Jonas Wagner
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

(function() {
'use strict';

var smartcrop = {};
// Promise implementation to use
smartcrop.Promise = typeof Promise !== 'undefined' ? Promise : function() {
  throw new Error('No native promises and smartcrop.promise not set.');
};

smartcrop.DEFAULTS = {
  width: 0,
  height: 0,
  aspect: 0,
  cropWidth: 0,
  cropHeight: 0,
  detailWeight: 0.2,
  skinColor: [0.78, 0.57, 0.44],
  skinBias: 0.01,
  skinBrightnessMin: 0.2,
  skinBrightnessMax: 1.0,
  skinThreshold: 0.8,
  skinWeight: 1.8,
  saturationBrightnessMin: 0.05,
  saturationBrightnessMax: 0.9,
  saturationThreshold: 0.4,
  saturationBias: 0.2,
  saturationWeight: 0.3,
  // Step * minscale rounded down to the next power of two should be good
  scoreDownSample: 8,
  step: 8,
  scaleStep: 0.1,
  minScale: 1.0,
  maxScale: 1.0,
  edgeRadius: 0.4,
  edgeWeight: -20.0,
  outsideImportance: -0.5,
  boostWeight: 100.0,
  ruleOfThirds: true,
  prescale: true,
  imageOperations: null,
  canvasFactory: defaultCanvasFactory,
  // Factory: defaultFactories,
  debug: false,
};



smartcrop.crop = function(inputImage, options_, callback) {
  var options = extend({}, smartcrop.DEFAULTS, options_);

  if (options.aspect) {
    options.width = options.aspect;
    options.height = 1;
  }

  if (options.imageOperations === null) {
    options.imageOperations = canvasImageOperations(options.canvasFactory);
  }

  var iop = options.imageOperations;

  var scale = 1;
  var prescale = 1;

  return iop.open(inputImage, options.input).then(function(image) {

    if (options.width && options.height) {
      scale = min(image.width / options.width, image.height / options.height);
      options.cropWidth = ~~(options.width * scale);
      options.cropHeight = ~~(options.height * scale);
      // Img = 100x100, width = 95x95, scale = 100/95, 1/scale > min
      // don't set minscale smaller than 1/scale
      // -> don't pick crops that need upscaling
      options.minScale = min(options.maxScale, max(1 / scale, options.minScale));

      if (options.prescale !== false) {
        prescale = 1 / scale / options.minScale;
        if (prescale < 1) {
          image = iop.resample(image, image.width * prescale, image.height * prescale);
          options.cropWidth = ~~(options.cropWidth * prescale);
          options.cropHeight = ~~(options.cropHeight * prescale);
          if (options.boost) {
            options.boost = options.boost.map(function(boost) {
              return {
                x: ~~(boost.x * prescale),
                y: ~~(boost.y * prescale),
                width: ~~(boost.width * prescale),
                height: ~~(boost.height * prescale),
                weight: boost.weight
              };
            });
          }
        }
        else {
          prescale = 1;
        }
      }
    }
    return image;
  })
  .then(function(image) {
    return iop.getData(image).then(function(data) {
      var result = analyse(options, data);

      var crops = result.crops || [result.topCrop];
      for (var i = 0, iLen = crops.length; i < iLen; i++) {
        var crop = crops[i];
        crop.x = ~~(crop.x / prescale);
        crop.y = ~~(crop.y / prescale);
        crop.width = ~~(crop.width / prescale);
        crop.height = ~~(crop.height / prescale);
      }
      if (callback) callback(result);
      return result;
    });
  });
};


// Check if all the dependencies are there
// todo:
smartcrop.isAvailable = function(options) {
  if (!smartcrop.Promise) return false;

  var canvasFactory = options ? options.canvasFactory : defaultCanvasFactory;

  if (canvasFactory === defaultCanvasFactory) {
    var c = document.createElement('canvas');
    if (!c.getContext('2d')) {
      return false;
    }
  }

  return true;
};

function edgeDetect(i, o) {
  var id = i.data;
  var od = o.data;
  var w = i.width;
  var h = i.height;

  for (var y = 0; y < h; y++) {
    for (var x = 0; x < w; x++) {
      var p = (y * w + x) * 4;
      var lightness;

      if (x === 0 || x >= w - 1 || y === 0 || y >= h - 1) {
        lightness = sample(id, p);
      }
      else {
        lightness = sample(id, p) * 4 -
            sample(id, p - w * 4) -
            sample(id, p - 4) -
            sample(id, p + 4) -
            sample(id, p + w * 4);
      }

      od[p + 1] = lightness;
    }
  }
}

function skinDetect(options, i, o) {
  var id = i.data;
  var od = o.data;
  var w = i.width;
  var h = i.height;

  for (var y = 0; y < h; y++) {
    for (var x = 0; x < w; x++) {
      var p = (y * w + x) * 4;
      var lightness = cie(id[p], id[p + 1], id[p + 2]) / 255;
      var skin = skinColor(options, id[p], id[p + 1], id[p + 2]);
      var isSkinColor = skin > options.skinThreshold;
      var isSkinBrightness = lightness >= options.skinBrightnessMin && lightness <= options.skinBrightnessMax;
      if (isSkinColor && isSkinBrightness) {
        od[p] = (skin - options.skinThreshold) * (255 / (1 - options.skinThreshold));
      }
      else {
        od[p] = 0;
      }
    }
  }
}

function saturationDetect(options, i, o) {
  var id = i.data;
  var od = o.data;
  var w = i.width;
  var h = i.height;
  for (var y = 0; y < h; y++) {
    for (var x = 0; x < w; x++) {
      var p = (y * w + x) * 4;

      var lightness = cie(id[p], id[p + 1], id[p + 2]) / 255;
      var sat = saturation(id[p], id[p + 1], id[p + 2]);

      var acceptableSaturation = sat > options.saturationThreshold;
      var acceptableLightness = lightness >= options.saturationBrightnessMin &&
          lightness <= options.saturationBrightnessMax;
      if (acceptableLightness && acceptableLightness) {
        od[p + 2] = (sat - options.saturationThreshold) * (255 / (1 - options.saturationThreshold));
      }
      else {
        od[p + 2] = 0;
      }
    }
  }
}

function applyBoosts(options, output) {
  if (!options.boost) return;
  var od = output.data;
  for (var i = 0; i < output.width; i += 4) {
    od[i + 3] = 0;
  }
  for (i = 0; i < options.boost.length; i++) {
    applyBoost(options.boost[i], options, output);
  }
}

function applyBoost(boost, options, output) {
  var od = output.data;
  var w = output.width;
  var x0 = ~~boost.x;
  var x1 = ~~(boost.x + boost.width);
  var y0 = ~~boost.y;
  var y1 = ~~(boost.y + boost.height);
  var weight = boost.weight * 255;
  for (var y = y0; y < y1; y++) {
    for (var x = x0; x < x1; x++) {
      var i = (y * w + x) * 4;
      od[i + 3] += weight;
    }
  }
}

function generateCrops(options, width, height) {
  var results = [];
  var minDimension = min(width, height);
  var cropWidth = options.cropWidth || minDimension;
  var cropHeight = options.cropHeight || minDimension;
  for (var scale = options.maxScale; scale >= options.minScale; scale -= options.scaleStep) {
    for (var y = 0; y + cropHeight * scale <= height; y += options.step) {
      for (var x = 0; x + cropWidth * scale <= width; x += options.step) {
        results.push({
          x: x,
          y: y,
          width: cropWidth * scale,
          height: cropHeight * scale,
        });
      }
    }
  }
  return results;
}

function score(options, output, crop) {
  var result = {
    detail: 0,
    saturation: 0,
    skin: 0,
    boost: 0,
    total: 0,
  };

  var od = output.data;
  var downSample = options.scoreDownSample;
  var invDownSample = 1 / downSample;
  var outputHeightDownSample = output.height * downSample;
  var outputWidthDownSample = output.width * downSample;
  var outputWidth = output.width;

  for (var y = 0; y < outputHeightDownSample; y += downSample) {
    for (var x = 0; x < outputWidthDownSample; x += downSample) {
      var p = (~~(y * invDownSample) * outputWidth + ~~(x * invDownSample)) * 4;
      var i = importance(options, crop, x, y);
      var detail = od[p + 1] / 255;

      result.skin += od[p] / 255 * (detail + options.skinBias) * i;
      result.detail += detail * i;
      result.saturation += od[p + 2] / 255 * (detail + options.saturationBias) * i;
      result.boost += od[p + 3] / 255 * i;
    }
  }

  result.total = (result.detail * options.detailWeight +
                  result.skin * options.skinWeight +
                  result.saturation * options.saturationWeight +
                  result.boost * options.boostWeight) / (crop.width * crop.height);
  return result;
}

function importance(options, crop, x, y) {
  if (crop.x > x || x >= crop.x + crop.width || crop.y > y || y >= crop.y + crop.height) {
    return options.outsideImportance;
  }
  x = (x - crop.x) / crop.width;
  y = (y - crop.y) / crop.height;
  var px = abs(0.5 - x) * 2;
  var py = abs(0.5 - y) * 2;
  // Distance from edge
  var dx = Math.max(px - 1.0 + options.edgeRadius, 0);
  var dy = Math.max(py - 1.0 + options.edgeRadius, 0);
  var d = (dx * dx + dy * dy) * options.edgeWeight;
  var s = 1.41 - sqrt(px * px + py * py);
  if (options.ruleOfThirds) {
    s += (Math.max(0, s + d + 0.5) * 1.2) * (thirds(px) + thirds(py));
  }
  return s + d;
}
smartcrop.importance = importance;

function skinColor(options, r, g, b) {
  var mag = sqrt(r * r + g * g + b * b);
  var rd = (r / mag - options.skinColor[0]);
  var gd = (g / mag - options.skinColor[1]);
  var bd = (b / mag - options.skinColor[2]);
  var d = sqrt(rd * rd + gd * gd + bd * bd);
  return 1 - d;
}

function analyse(options, input) {
  var result = {};
  var output = new ImgData(input.width, input.height);

  edgeDetect(input, output);
  skinDetect(options, input, output);
  saturationDetect(options, input, output);
  applyBoosts(options, output);

  var scoreOutput = downSample(output, options.scoreDownSample);

  var topScore = -Infinity;
  var topCrop = null;
  var crops = generateCrops(options, input.width, input.height);

  for (var i = 0, iLen = crops.length; i < iLen; i++) {
    var crop = crops[i];
    crop.score = score(options, scoreOutput, crop);
    if (crop.score.total > topScore) {
      topCrop = crop;
      topScore = crop.score.total;
    }

  }

  result.topCrop = topCrop;

  if (options.debug && topCrop) {
    result.crops = crops;
    result.debugOutput = output;
    result.debugOptions = options;
    // Create a copy which will not be adjusted by the post scaling of smartcrop.crop
    result.debugTopCrop = extend({}, result.topCrop);
  }
  return result;
}

function ImgData(width, height, data) {
  this.width = width;
  this.height = height;
  if (data) {
    this.data = new Uint8ClampedArray(data);
  }
  else {
    this.data = new Uint8ClampedArray(width * height * 4);
  }
}
smartcrop.ImgData = ImgData;

function downSample(input, factor) {
  var idata = input.data;
  var iwidth = input.width;
  var width = Math.floor(input.width / factor);
  var height = Math.floor(input.height / factor);
  var output = new ImgData(width, height);
  var data = output.data;
  var ifactor2 = 1 / (factor * factor);
  for (var y = 0; y < height; y++) {
    for (var x = 0; x < width; x++) {
      var i = (y * width + x) * 4;

      var r = 0;
      var g = 0;
      var b = 0;
      var a = 0;

      var mr = 0;
      var mg = 0;
      var mb = 0;

      for (var v = 0; v < factor; v++) {
        for (var u = 0; u < factor; u++) {
          var j = ((y * factor + v) * iwidth + (x * factor + u)) * 4;
          r += idata[j];
          g += idata[j + 1];
          b += idata[j + 2];
          a += idata[j + 3];
          mr = Math.max(mr, idata[j]);
          mg = Math.max(mg, idata[j + 1]);
          mb = Math.max(mb, idata[j + 2]);
        }
      }
      // this is some funky magic to preserve detail a bit more for
      // skin (r) and detail (g). Saturation (b) does not get this boost.
      data[i] = r * ifactor2 * 0.5 + mr * 0.5;
      data[i + 1] = g * ifactor2 * 0.7 + mg * 0.3;
      data[i + 2] = b * ifactor2;
      data[i + 3] = a * ifactor2;
    }
  }
  return output;
}
smartcrop._downSample = downSample;

function defaultCanvasFactory(w, h) {
  var c = document.createElement('canvas');
  c.width = w;
  c.height = h;
  return c;
}

function canvasImageOperations(canvasFactory) {
  return {
    // Takes imageInput as argument
    // returns an object which has at least
    // {width: n, height: n}
    open: function(image) {
      // Work around images scaled in css by drawing them onto a canvas
      var w = image.naturalWidth || image.width;
      var h = image.naturalHeight || image.height;
      var c = canvasFactory(w, h);
      var ctx = c.getContext('2d');
      if (image.naturalWidth && (image.naturalWidth != image.width || image.naturalHeight != image.height)) {
        c.width = image.naturalWidth;
        c.height = image.naturalHeight;
      }
      else {
        c.width = image.width;
        c.height = image.height;
      }
      ctx.drawImage(image, 0, 0);
      return smartcrop.Promise.resolve(c);
    },
    // Takes an image (as returned by open), and changes it's size by resampling
    resample: function(image, width, height) {
      return Promise.resolve(image).then(function(image) {
        var c = canvasFactory(~~width, ~~height);
        var ctx = c.getContext('2d');

        ctx.drawImage(image, 0, 0, image.width, image.height, 0, 0, c.width, c.height);
        return smartcrop.Promise.resolve(c);
      });
    },
    getData: function(image) {
      return Promise.resolve(image).then(function(c) {
        var ctx = c.getContext('2d');
        var id = ctx.getImageData(0, 0, c.width, c.height);
        return new ImgData(c.width, c.height, id.data);
      });
    },
  };
}
smartcrop._canvasImageOperations = canvasImageOperations;

// Aliases and helpers
var min = Math.min;
var max = Math.max;
var abs = Math.abs;
var ceil = Math.ceil;
var sqrt = Math.sqrt;

function extend(o) {
  for (var i = 1, iLen = arguments.length; i < iLen; i++) {
    var arg = arguments[i];
    if (arg) {
      for (var name in arg) {
        o[name] = arg[name];
      }
    }
  }
  return o;
}

// Gets value in the range of [0, 1] where 0 is the center of the pictures
// returns weight of rule of thirds [0, 1]
function thirds(x) {
  x = ((x - (1 / 3) + 1.0) % 2.0 * 0.5 - 0.5) * 16;
  return Math.max(1.0 - x * x, 0.0);
}

function cie(r, g, b) {
  return 0.5126 * b + 0.7152 * g + 0.0722 * r;
}
function sample(id, p) {
  return cie(id[p], id[p + 1], id[p + 2]);
}
function saturation(r, g, b) {
  var maximum = max(r / 255, g / 255, b / 255);
  var minumum = min(r / 255, g / 255, b / 255);

  if (maximum === minumum) {
    return 0;
  }

  var l = (maximum + minumum) / 2;
  var d = maximum - minumum;

  return l > 0.5 ? d / (2 - maximum - minumum) : d / (maximum + minumum);
}

// Amd
if (typeof define !== 'undefined' && define.amd) define(function() {return smartcrop;});
// Common js
if (typeof exports !== 'undefined') exports.smartcrop = smartcrop;
// Browser
else if (typeof navigator !== 'undefined') window.SmartCrop = window.smartcrop = smartcrop;
// Nodejs
if (typeof module !== 'undefined') {
  module.exports = smartcrop;
}
})();
	    var options = window.sessionData || {};

    options['webhost']   = 'https://app.suntcontent.se/';
    options['cdnhost']   = 'https://c.suntcontent.se/';
    options['chart_url'] = 'https://app.suntcontent.se/api/statistic/chart/';

    var endPoints = {};

        	endPoints["c"] = "https://c.suntcontent.se";
        	endPoints["d"] = "https://d.suntcontent.se";
        	endPoints["t"] = "https://t.suntcontent.se";
        	endPoints["s"] = "https://s.suntcontent.se";
        	endPoints["p"] = "https://p.suntcontent.se";
        	endPoints["b"] = "https://b.suntcontent.se";
    
    options['endpoints'] = endPoints;

    var app = new Allium(options);

                	   app.set('primary-color', '#0bf');
    	    	   app.set('secondary-color', '#3d4045');
    	                	   app.set('theme-color-1', '#00bbff');
    	    	   app.set('theme-color-2', '#00a5e1');
    	    	   app.set('theme-color-3', '#008fc4');
    	    	   app.set('theme-color-4', '#007aa6');
    	    	   app.set('theme-color-5', '#006488');
    	    	   app.set('theme-color-6', '#004e6a');
    	    	   app.set('theme-color-7', '#00384d');
    	                	   app.set('theme-grey-1', '#808080');
    	    	   app.set('theme-grey-2', '#717171');
    	    	   app.set('theme-grey-3', '#626262');
    	    	   app.set('theme-grey-4', '#535353');
    	    	   app.set('theme-grey-5', '#444444');
    	    	   app.set('theme-grey-6', '#353535');
    	    	   app.set('theme-grey-7', '#262626');
    	    
    app.set('color-count', '7');

    var locales  = [],
        patterns = {"default":{"date_time":{"date_picker":{"date":"%d.%m.%Y","time":"%H:%M:%S"}}},"en_GB":{"date_time":{"date_picker":{"date":"%d\/%m\/%Y","time":"%H:%M:%S"}}},"en_US":{"date_time":{"date_picker":{"date":"%m\/%d\/%Y","time":"%H:%M:%S"}}},"sv_SE":{"date_time":{"formatter":{"medium":{"date":{"year":"numeric","month":"2-digit","day":"2-digit"},"time":{"hour":"numeric","minute":"2-digit","second":"2-digit"}}},"date_picker":{"date":"%Y-%m-%d","time":"%H:%M:%S"}}}},
        i18n     = (new I18n())
            .setLocale('sv_SE')      // Set default locale
            .setLanguage('EN')  // Set default language
            .setCurrency('SEK')  // Set default currency
            .setTimeZone('Europe/Berlin'); // Set default time zone

    /*
     * Set locale and pattern mappings
     *
     * Useful for using other locales/patterns than the given user/default one to format numbers or dates
     */
    Object.each(locales, function(mapping, locale) {
        Object.each(mapping, function(targetLocale, type) {
            i18n.setLocale(targetLocale, type, locale);
        });
    });

    Object.each(patterns, function(mapping, locale) {
        Object.each(mapping, function(pattern, type) {
            i18n.setPattern(pattern, type, locale);
        });
    });

    app.set('i18n', i18n);

    // Set locale/pattern for date picker
    var locale   = i18n.getLocale('date_time'),
        patterns = i18n.getPattern('date_time');

    if (patterns && typeof patterns['date_picker'] !== 'undefined') {
        if (typeof patterns['date_picker']['date'] !== 'undefined') {
            Locale.define(locale, 'Date', 'shortDate', patterns['date_picker']['date']);
        }

        if (typeof patterns['date_picker']['time'] !== 'undefined') {
            Locale.define(locale, 'Date', 'shortTime', patterns['date_picker']['time']);
        }
    }

    Locale.use(locale);

    if (typeof AmCharts !== 'undefined') {
        var AmCharts_path = "https://app.suntcontent.se/theme/nativendo/asset/js/vendor/amcharts/";

            }

    // at first init the router
app.set('router', new Router({
    host : app.get('webhost'),
    url  : location.href,
    error_callback : function(err) {
    	console.warn(err);
    	// @todo better error reporting?
    }
}));

app.get('router').request('/', function() {
    // set the loader
    app.set('loader', new Loader());

    // set alert
    app.set('alert', new AlertMessage());

	var grid = new Grid;
	grid.initialize('.mt-grid-table');

	// add the grid
	app.set('grid', grid);

	// add the (sub)tabs
	app.set('tab', new Tab);

	// add widgets
	app.set('widget', new Widget);

	// add char length check
	app.set('charLengthCheck', new CharLengthCheck(document.body));

	// set dwell time formatter
	app.set('dwellTime', {
		formatSecsToDwellTime : function(allSecs, totalLabel, avg, total) {
			if (typeof total === 'undefined') {
				total = true;
			}

		    if (typeof totalLabel === 'undefined') {
		        totalLabel = false;
		    }

		    if (typeof avg === 'undefined') {
		        avg = false;
		    }

		    var label = [];

			if (total) {
			    var timeLabels = {
			        'd' : ['day', 'days'],
			        'h' : ['hour','hours'],
			        'm' : ['minute', 'minutes'],
			        's' : ['second', 'seconds']
			    };

			    allSecs     = allSecs;

			    var values = {
			        s  : 0,
			        d  : 0,
			        m  : 0,
			        h  : 0
			    };

			    values['s'] = Math.round(allSecs % 60);
			    allMinutes  = (allSecs - values['s']) / 60;

			    values['m'] = Math.round(allMinutes % 60);
			    allHours    = (allMinutes - values['m']) / 60;

			    values['h'] = Math.round(allHours % 24);
			    values['d'] = Math.round((allHours - values['h']) / 24);

			    ['d', 'h', 'm', 's'].each(function(timeKey) {
			        if (!values[timeKey] || values[timeKey] === 0) {
			            return;
			        }

			        label.push(values[timeKey] + ' ' + '{' + timeLabels[timeKey][values[timeKey] > 1 ? 1 : 0] + '}');
			    });

			    var c = label.length - 2;

			    label.each(function(lab, k) {
			        if ((k === c)) {
			            label[k] += ' ' + '{and}';
			        } else if (k < label.length - 1) {
			            label[k] += ',';
			        }
			    });

			    if (totalLabel && label.length > 0) {
			        totalLabel = '∑' + ': ';
			    } else {
			        totalLabel = '';
			    }
		    }

		    if (avg) {
		        avg = (total) ? ' / Ø: ' + app.get('dwellTime').formatSecsToDwellTime(allSecs/avg) : 'Ø ' + app.get('dwellTime').formatSecsToDwellTime(allSecs/avg) ;
		    } else {
		        avg = '';
		    }

		    var returnLabel = '';

		    if (label.length > 0) {
		    	returnLabel = totalLabel + label.join(' ');
		    }

		    return returnLabel + avg;
		},

		format : function(allSecs, totalLabel, avg, total) {
			var string = app.get('dwellTime').formatSecsToDwellTime(allSecs, totalLabel, avg, total);

			string = string.replace(/\{([^\}]+)\}/g, function(search, translateKey) {
				return app.get('i18n').translate(translateKey);
			});

			return (string.length > 0) ? string : false;
		}
	});

	// set W5gEditor
	app.set('W5gEditor', new W5gEditor());

    // set Ace editor
    app.set('ace', new Ace());

	// set global xhr
	app.set('xhr', new Xhr());

	// set xhrForms
	app.set('xhrForm', new XhrForm(document.body));

    // set TargetingSelect
    app.set('targetingSelect', new TargetingSelect());

    // set modal
    app.set('modal', new Modal(document.body));

    // set chart
    app.set('chart', new Chart(document.body));

    // set chosen
    app.set('chosen', new Chosen(document.body));

    // set chosen
    app.set('chosenXhr', new ChosenXhr());

    app.set('search', new Search());

    $$('[data-chosen-xhr-search]').each(function(chosenXhrEl) {
    	if (['account_id', 'campaign_id', 'account_approval[]', 'account_ids[]'].indexOf(chosenXhrEl.get('name')) === -1) {
    		return;
    	}

    	var pleaseSelOpt = chosenXhrEl.getElement('option[value=""]');

		if (pleaseSelOpt) {
    		pleaseSelOpt.set('data-type', 'search-results');
    	}

		app.get('chosenXhr').init(chosenXhrEl.getParent());
    });

    // set datepicker
    app.set('picker.date', new PickerDate(document.body));

	if ($$('.chart-filter-container').length > 0) {
	    // set chart filter
	    app.set('chartFilter', new ChartFilter($$('.chart-filter-container')[0]));
    }

    // Number elements
    ['focus', 'paste'].forEach(function(eventName) {
        document.addEvent(eventName + ':relay(input.number)', function(e, target) {
           target.store('number-format-timeout', setTimeout(function() {
                var value            = target.get('value'),
                    unformattedValue = app.get('i18n').unformatNumber(value),
                    caret            = target.getCaretPosition(),
                    caretNew         = caret,
                    regexGrouping    = new RegExp('\\' + app.get('i18n').getThousandsSeparator()),
                    regexDigits      = new RegExp('^([\\d\\' + app.get('i18n').getThousandsSeparator() + ']*\\' + app.get('i18n').getDecimalSeparator() + '?)(.*)'),
                    digitCount       = value.replace(regexDigits, '$2').length;

                for (var i = 0; i < caret; i++) {
                    if (value.charAt(i).match(regexGrouping)) {
                        caretNew--;
                    }
                }

                value = (!isNaN(unformattedValue)) ? app.get('i18n').formatNumber(unformattedValue, {grouping: false, precision: digitCount, fixed: true}) : value;

                if (value !== 'NaN') {
                    target.set('value', value);
                    target.setCaretPosition(caretNew);
                }
            }, 1));
        });
    });

    document.addEvent('blur:relay(input.number)', function(e, target) {
    	window.clearTimeout(target.retrieve('number-format-timeout'));

        var value            = target.get('value'),
            unformattedValue = app.get('i18n').unformatNumber(value),
            regexDigits      = new RegExp('^([\\d\\' + app.get('i18n').getThousandsSeparator() + ']*\\' + app.get('i18n').getDecimalSeparator() + '?)(.*)'),
            digitCount       = value.replace(regexDigits, '$2').length;

        value = (!isNaN(unformattedValue)) ? app.get('i18n').formatNumber(unformattedValue, {precision: digitCount, fixed: true}) : value;

        if (value !== 'NaN') {
            target.set('value', value);
        }
    });

	// init top, left menu functions
	var sideNav = $$('.side-nav').getLast();

	var sidenavChange = function(show) {
		show = (typeof show === 'undefined') ? true : show;

		if (show) {
            sideNav.addClass('is-active').removeClass('is-inactive');
            document.body.addClass('sidenav-visible').removeClass('sidenav-hidden');
            return;
		}

        sideNav.addClass('is-inactive').removeClass('is-active');
        document.body.addClass('sidenav-hidden').removeClass('sidenav-visible');
	}

	if (sideNav) {
	    $$('.side-nav-toggler').addEvent('click', function(e) {
	        e && e.stop();

	        var showSideNav = (document.body.hasClass('sidenav-hidden'));

	        sidenavChange(showSideNav);

	        Cookie.prototype.set('nativendo_show_menu', showSideNav ? 1 : 0);
	    });
	}

	/**
	 * left navigation function
	 * @todo die funktionalität woanders hinpacken???
	 */
	$$('.dropdown-toggler > a').addEvent('click', function(e) {
	    if (this.get('href').indexOf('#!') != -1) {
	    	e.stop();

			this.getParent().toggleClass('active').getChildren('.dropdown').toggleClass('is-visible');
	    }
	});

	// right top person element
    var currentTarget = null;
    document.addEvent('mousemove', function(e) {
        currentTarget = e.target;
    });

    $$('.top-nav .dropdown-toggler, .creative-selection .dropdown-toggler').each(function(dropdownToggler) {
        dropdownToggler.store('toggle-elements', dropdownToggler.getElements('*'));

        var dropDown = dropdownToggler.getFirst('.dropdown');

        dropdownToggler.store('toggle-dropdown', dropDown);
    });

    $$('.top-nav .dropdown-toggler, .creative-selection .dropdown-toggler').addEvents({
        'mouseover' : function(e) {
            var dropDown = this.getFirst('.dropdown');

            if (!dropDown || ('ontouchstart' in window)) {
                return;
            }

            dropDown.addClass('click-lock');

            window.setTimeout(function(e) {
                dropDown.removeClass('click-lock');
            }.bind(this), 100);

            dropDown.addClass('is-visible');

            dropDown.setStyle('top', '');

			// 3px padding puffer
			if (dropDown.getCoordinates().bottom > window.getScroll().y + window.innerHeight) {
				dropDown.setStyle('top', '-' + (dropDown.getCoordinates().height + 3) + 'px');
			}
        },

        'mouseout' : function(e) {
            window.clearTimeout(this.tId);

            this.tId = window.setTimeout(function(e) {
                if (this.retrieve('toggle-elements').indexOf(currentTarget) === -1) {
                    this.retrieve('toggle-dropdown') && this.retrieve('toggle-dropdown').removeClass('is-visible');
                }
            }.bind(this), 50);
        },

        'click:relay(.flex-center)' : function(e) {
            var dropDown = this.getNext('.dropdown');

            if (dropDown && !dropDown.hasClass('click-lock')) {
                dropDown.toggleClass('is-visible');
            }
        }
    });

	// hide select on open a tooltip
	var lastSelect = null;

	document.addEvent('mouseout:relay(select)', function(e, target) {
		lastSelect = target;
	});

	document.addEvent('mouseover:relay(.tooltip)', function(e, target) {
		if (lastSelect) {
			lastSelect.blur();

			lastSelect = null;
		}

		var toolTip = target.getElement('span[rel="tooltip"]');

        if (toolTip) {
    		// remove old stylings
    		toolTip
    			.set('style', '')
    			.removeClass('rm-tt-arrow');

    		if (toolTip.getCoordinates().left + toolTip.getCoordinates().width > window.getWidth()) {
    			toolTip.setStyles({
    				'top'  : parseInt(target.getCoordinates().height)  * 1.3,
    				'left' : parseInt(toolTip.getStyle('left')) - ((toolTip.getCoordinates().left + toolTip.getCoordinates().width) - window.getWidth()) - 5
    			}).addClass('rm-tt-arrow');
    		}
        }
	});
}, 'domready');