hatemile 2.0

data/lib/js/common.js

@@ -0,0 +1,98 @@
+isEmpty = function(value) {
+	if ((value === undefined) ||
+			(value === false) ||
+			(value === null)) {
+		return true;
+	} else if ((typeof value === typeof '') ||
+			(typeof value === typeof [])) {
+		if (value.length === 0) {
+			return true;
+		}
+	}
+	return false;
+};
+
+var __exports, __base;
+__exports = this;
+__exports.hatemile || (__exports.hatemile = {});
+(__base = __exports.hatemile).util || (__base.util = {});
+__exports.hatemile.util.CommonFunctions = {
+	count: 0,
+	generateId: function(element, prefix) {
+		if (!element.hasAttribute('id')) {
+			element.setAttribute('id', prefix + this.count.toString());
+			this.count++;
+		}
+	},
+	setListAttributes: function(element1, element2, attributes) {
+		var attribute, _i, _len;
+		for (_i = 0, _len = attributes.length; _i < _len; _i++) {
+			attribute = attributes[_i];
+			if (element1.hasAttribute(attribute)) {
+				element2.setAttribute(attribute, element1.getAttribute(attribute));
+			}
+		}
+	},
+	increaseInList: function(list, stringToIncrease) {
+		if (!(isEmpty(list) || isEmpty(stringToIncrease))) {
+			if (this.inList(list, stringToIncrease)) {
+				return list;
+			} else {
+				return list + ' ' + stringToIncrease;
+			}
+		} else if (isEmpty(list)) {
+			return stringToIncrease;
+		} else {
+			return list;
+		}
+	},
+	inList: function(list, stringToSearch) {
+		var array, item, _i, _len;
+		if (!(isEmpty(list) || isEmpty(stringToSearch))) {
+			array = list.split(new RegExp('[ \n\t\r]+'));
+			for (_i = 0, _len = array.length; _i < _len; _i++) {
+				item = array[_i];
+				if (item === stringToSearch) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+};
+
+var addEventHandler = function(element, typeEvent, typeDataEvent, typeFix, eventHandler) {
+	var attribute, found;
+	if (!hasEvent(element, typeEvent, typeDataEvent, typeFix)) {
+		found = false;
+		attribute = element.getAttribute(typeDataEvent);
+		if (!hasEvent(element, typeEvent)) {
+			element['liston' + typeEvent] = [];
+			element['on' + typeEvent] = function(event) {
+				var addedEvent, _i, _len, _ref;
+				_ref = element['liston' + typeEvent];
+				for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+					addedEvent = _ref[_i];
+					addedEvent(event);
+				}
+			};
+		} else {
+			found = __exports.hatemile.util.CommonFunctions.inList(attribute, typeFix);
+		}
+		if (!found) {
+			element['liston' + typeEvent].push(eventHandler);
+			attribute = __exports.hatemile.util.CommonFunctions.increaseInList(attribute, typeFix);
+			element.setAttribute(typeDataEvent, attribute);
+		}
+	}
+};
+
+var hasEvent = function(element, typeEvent, typeDataEvent, typeFix) {
+	var attribute;
+	if (isEmpty(typeDataEvent) || isEmpty(typeFix)) {
+		return (!isEmpty(element['on' + typeEvent])) || ((!isEmpty(element.eventListenerList)) && (!isEmpty(element.eventListenerList[typeEvent])));
+	} else {
+		attribute = element.getAttribute(typeDataEvent);
+		return (hasEvent(element, typeEvent) && (!element.hasAttribute(typeDataEvent))) || __exports.hatemile.util.CommonFunctions.inList(attribute, typeFix);
+	}
+};

data/lib/js/eventlistener.js

@@ -0,0 +1,36 @@
+if (!Element.prototype.eventListenerList) {
+	Element.prototype.eventListenerList = {};
+	Element.prototype.__eventListenerListAdded = false;
+
+	Element.prototype.__addEventListener = Element.prototype.addEventListener;
+	Element.prototype.addEventListener = function() {
+		if (!this.__eventListenerListAdded) {
+			this.eventListenerList = {};
+			this.__eventListenerListAdded = true;
+		}
+		if (!this.eventListenerList[arguments[0]]) {
+			this.eventListenerList[arguments[0]] = [];
+		}
+		this.eventListenerList[arguments[0]].push(arguments[1]);
+		return (this.__addEventListener.apply(this, arguments));
+	};
+
+	Element.prototype.__removeEventListener = Element.prototype.removeEventListener;
+	Element.prototype.removeEventListener = function() {
+		var found = false;
+		if (!this.eventListenerList[arguments[0]]) {
+			this.eventListenerList[arguments[0]] = [];
+		}
+		var key;
+		for (key in this.eventListenerList[arguments[0]]) {
+			found = this.eventListenerList[arguments[0]][key] === arguments[1];
+			if (found) {
+				break;
+			}
+		}
+		if (found) {
+			this.eventListenerList[arguments[0]].splice(key, 1);
+		}
+		return (this.__removeEventListener.apply(this, arguments));
+	};
+}

data/lib/js/include.js

@@ -0,0 +1,292 @@
+__exports.__aria_grabbed__elements__ = [];
+__exports.__aria_dropeffect__elements__ = [];
+
+enterPressed = function(keyCode) {
+	var enter1, enter2;
+	enter1 = '\n'.charCodeAt(0);
+	enter2 = '\r'.charCodeAt(0);
+	return (keyCode === enter1) || (keyCode === enter2);
+};
+
+keyboardAccess = function(element) {
+	var tag;
+	if (!element.hasAttribute('tabindex')) {
+		tag = element.tagName.toUpperCase();
+		if ((tag === 'A') && (!element.hasAttribute('href'))) {
+			element.setAttribute('tabindex', '0');
+		} else if ((tag !== 'INPUT') && (tag !== 'BUTTON') && (tag !== 'SELECT') && (tag !== 'TEXTAREA')) {
+			element.setAttribute('tabindex', '0');
+		}
+	}
+};
+
+clearDropEffect = function() {
+	var activeEvents, dragEvents, droppedElement, droppedElements, hoverEvents, _i, _len;
+	droppedElements = __exports.__aria_dropeffect__elements__;
+	for (_i = 0, _len = droppedElements.length; _i < _len; _i++) {
+		droppedElement = droppedElements[_i];
+		dragEvents = (!hasEvent(droppedElement, 'keydown', 'data-keydownadded', 'drag')) && (!hasEvent(droppedElement, 'keyup', 'data-keyupadded', 'drag'));
+		activeEvents = (!droppedElement.hasAttribute('data-keypressadded')) && (!hasEvent(droppedElement, 'keydown', 'data-keydownadded', 'active')) && (!hasEvent(droppedElement, 'keyup', 'data-keyupadded', 'active'));
+		hoverEvents = (!hasEvent(droppedElement, 'focus', 'data-focusadded', 'hover')) && (!hasEvent(droppedElement, 'blur', 'data-bluradded', 'hover'));
+		droppedElement.setAttribute('aria-dropeffect', 'none');
+		if (droppedElement.hasAttribute('tabindex') && dragEvents && activeEvents && hoverEvents) {
+			droppedElement.removeAttribute('tabindex');
+		}
+	}
+};
+
+generateDropEffect = function() {
+	var ariaDropEffect, dropEffect, droppedElement, droppedElements, effectAllowed, _i, _len;
+	dropEffect = __exports.__dragEventDataTransfer__.dropEffect;
+	effectAllowed = __exports.__dragEventDataTransfer__.effectAllowed;
+	if ((dropEffect === 'none') || ((dropEffect !== 'copy') && (dropEffect !== 'link') && (dropEffect !== 'move'))) {
+		if ((effectAllowed === 'copyLink') || (effectAllowed === 'copyMove') || (effectAllowed === 'linkMove') || (effectAllowed === 'all')) {
+			ariaDropEffect = 'popup';
+		} else if ((effectAllowed === 'copy') || (effectAllowed === 'move') || (effectAllowed === 'link')) {
+			ariaDropEffect = effectAllowed;
+		} else {
+			ariaDropEffect = 'move';
+		}
+	} else {
+		ariaDropEffect = dropEffect;
+	}
+	droppedElements = __exports.__aria_dropeffect__elements__;
+	for (_i = 0, _len = droppedElements.length; _i < _len; _i++) {
+		droppedElement = droppedElements[_i];
+		if (hasEvent(droppedElement, 'drop')) {
+			droppedElement.setAttribute('aria-dropeffect', ariaDropEffect);
+		}
+		keyboardAccess(droppedElement);
+	}
+};
+
+executeMouseEvent = function(type, element, event) {
+	executeEvent(element, createMouseEvent(type, element, event));
+};
+
+executeDragEvent = function(type, element, event) {
+	if (isEmpty(__exports.__dragEventDataTransfer__)) {
+		__exports.__dragEventDataTransfer__ = {
+			'files': null,
+			'types': null,
+			'effectAllowed': 'uninitialized',
+			'dropEffect': 'none'
+		};
+		__exports.__dragEventDataTransfer__.setDragImage = function() {
+		};
+		__exports.__dragEventDataTransfer__.addElement = function() {
+		};
+		__exports.__dragEventDataTransfer__._data = {};
+		__exports.__dragEventDataTransfer__.setData = function(format, data) {
+			__exports.__dragEventDataTransfer__._data[format] = data;
+		};
+		__exports.__dragEventDataTransfer__.getData = function(format) {
+			return __exports.__dragEventDataTransfer__._data[format];
+		};
+		__exports.__dragEventDataTransfer__.clearData = function(format) {
+			if (isEmpty(format)) {
+				__exports.__dragEventDataTransfer__._data = {};
+			} else {
+				__exports.__dragEventDataTransfer__._data[format] = void 0;
+			}
+		};
+	}
+	executeEvent(element, createDragEvent(type, element, event));
+};
+
+executeEvent = function(element, event) {
+	var error, handlerEvent, listenerEvent, _i, _len, _ref;
+	if (hasEvent(element, event.type)) {
+		try {
+			if (!isEmpty(element.dispatchEvent)) {
+				element.dispatchEvent(event);
+			} else {
+				handlerEvent = element['on' + event.type];
+				if (!isEmpty(handlerEvent)) {
+					handlerEvent(event);
+				}
+				if ((!isEmpty(element.eventListenerList)) && (!isEmpty(element.eventListenerList[event.type]))) {
+					_ref = element.eventListenerList[event.type];
+					for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+						listenerEvent = _ref[_i];
+						listenerEvent(event);
+					}
+				}
+			}
+		} catch (_error) {
+			error = _error;
+		}
+	}
+};
+
+createMouseEvent = function(type, element, event) {
+	var data, mouseEvent;
+	data = {
+		'view': event.view,
+		'bubbles': true,
+		'cancelable': true,
+		'target': element,
+		'altKey': event.altKey,
+		'ctrlKey': event.ctrlKey,
+		'cancelBubble': false,
+		'isTrusted': true,
+		'metaKey': false,
+		'shiftKey': event.shiftKey,
+		'clientX': 0,
+		'clientY': 0,
+		'pageX': 0,
+		'pageY': 0,
+		'screenX': 0,
+		'screenY': 0
+	};
+	if (isEmpty(Event)) {
+		mouseEvent = data;
+		mouseEvent.type = type;
+	} else {
+		mouseEvent = new Event(type, data);
+	}
+	mouseEvent.preventDefault = function() {
+		return event.preventDefault();
+	};
+	mouseEvent.stopImmediatePropagation = function() {
+		return event.stopImmediatePropagation();
+	};
+	mouseEvent.stopPropagation = function() {
+		return event.stopPropagation();
+	};
+	return mouseEvent;
+};
+
+createDragEvent = function(type, element, event) {
+	var dragEvent;
+	dragEvent = createMouseEvent(type, element, event);
+	dragEvent.dataTransfer = __exports.__dragEventDataTransfer__;
+	return dragEvent;
+};
+
+fixActiveInElement = function(element) {
+	if (element.tagName.toUpperCase() !== 'A') {
+		addEventHandler(element, 'keypress', 'data-keypressadded', 'active', function(event) {
+			if (enterPressed(event.keyCode)) {
+				if (hasEvent(element, 'click')) {
+					executeMouseEvent('click', element, event);
+				} else if (hasEvent(element, 'dblclick')) {
+					executeMouseEvent('dblclick', element, event);
+				}
+			}
+		});
+	}
+	addEventHandler(element, 'keyup', 'data-keyupadded', 'active', function(event) {
+		if (enterPressed(event.keyCode)) {
+			executeMouseEvent('mouseup', element, event);
+		}
+	});
+	addEventHandler(element, 'keydown', 'data-keydownadded', 'active', function(event) {
+		if (enterPressed(event.keyCode)) {
+			executeMouseEvent('mousedown', element, event);
+		}
+	});
+};
+
+fixHoverInElement = function(element) {
+	addEventHandler(element, 'focus', 'data-focusadded', 'hover', function(event) {
+		executeMouseEvent('mouseover', element, event);
+	});
+	addEventHandler(element, 'blur', 'data-bluradded', 'hover', function(event) {
+		executeMouseEvent('mouseout', element, event);
+	});
+};
+
+fixDragInElement = function(element) {
+	if ((!hasEvent(element, 'keydown', 'data-keydownadded', 'drag')) && (!hasEvent(element, 'keyup', 'data-keyupadded', 'drag'))) {
+		addEventHandler(element, 'keydown', 'data-keydownadded', 'drag', function(event) {
+			var grabbedElement, grabbedElements, _i, _len;
+			if ((event.keyCode === ' '.charCodeAt(0)) && (!element.hasAttribute('data-keypressed'))) {
+				grabbedElements = __exports.__aria_grabbed__elements__;
+				for (_i = 0, _len = grabbedElements.length; _i < _len; _i++) {
+					grabbedElement = grabbedElements[_i];
+					grabbedElement.setAttribute('aria-grabbed', 'false');
+					executeDragEvent('dragend', grabbedElement, event);
+				}
+				element.setAttribute('aria-grabbed', 'true');
+				element.setAttribute('data-keypressed', 'true');
+				__exports.__aria_grabbed__elements__ = [element];
+				executeDragEvent('dragstart', element, event);
+				executeDragEvent('drag', element, event);
+				generateDropEffect();
+			}
+		});
+		addEventHandler(element, 'keyup', 'data-keyupadded', 'drag', function(event) {
+			element.removeAttribute('data-keypressed');
+		});
+	}
+};
+
+fixDropInElement = function(element) {
+	__exports.__aria_dropeffect__elements__.push(element);
+	addEventHandler(element, 'focus', 'data-focusadded', 'drop', function(event) {
+		if (!isEmpty(__exports.__aria_grabbed__elements__)) {
+			executeDragEvent('dragenter', element, event);
+			executeDragEvent('dragover', element, event);
+			generateDropEffect();
+		}
+	});
+	addEventHandler(element, 'blur', 'data-bluradded', 'drop', function(event) {
+		if (!isEmpty(__exports.__aria_grabbed__elements__)) {
+			executeDragEvent('dragleave', element, event);
+			generateDropEffect();
+		}
+	});
+	if ((!hasEvent(element, 'keydown', 'data-keydownadded', 'drop')) && (!hasEvent(element, 'keyup', 'data-keyupadded', 'drop'))) {
+		addEventHandler(element, 'keydown', 'data-keydownadded', 'drop', function(event) {
+			var grabbedElement, grabbedElements, _i, _len;
+			if ((enterPressed(event.keyCode)) && (!element.hasAttribute('data-keypressed')) && (!isEmpty(__exports.__aria_grabbed__elements__))) {
+				element.setAttribute('data-keypressed', 'true');
+				if (hasEvent(element, 'drop')) {
+					grabbedElements = __exports.__aria_grabbed__elements__;
+					for (_i = 0, _len = grabbedElements.length; _i < _len; _i++) {
+						grabbedElement = grabbedElements[_i];
+						grabbedElement.setAttribute('aria-grabbed', 'false');
+						executeDragEvent('dragend', grabbedElement, event);
+					}
+					__exports.__aria_grabbed__elements__ = [];
+					clearDropEffect();
+				}
+				executeDragEvent('drop', element, event);
+			}
+		});
+		addEventHandler(element, 'keyup', 'data-keyupadded', 'drop', function(event) {
+			element.removeAttribute('data-keypressed');
+		});
+	}
+};
+
+addEventHandler(document.documentElement, 'keypress', 'data-keypressadded', 'active', function(event) {
+	var grabbedElement, grabbedElements, _i, _len;
+	if (event.keyCode === 27) {
+		grabbedElements = __exports.__aria_grabbed__elements__;
+		for (_i = 0, _len = grabbedElements.length; _i < _len; _i++) {
+			grabbedElement = grabbedElements[_i];
+			grabbedElement.setAttribute('aria-grabbed', 'false');
+			executeDragEvent('dragend', grabbedElement, event);
+		}
+		__exports.__aria_grabbed__elements__ = [];
+		clearDropEffect();
+	}
+});
+
+for (var i = 0, length = activeElements.length; i < length; i++) {
+	fixActiveInElement(document.getElementById(activeElements[i]));
+}
+
+for (var i = 0, length = hoverElements.length; i < length; i++) {
+	fixHoverInElement(document.getElementById(hoverElements[i]));
+}
+
+for (var i = 0, length = dragElements.length; i < length; i++) {
+	fixDragInElement(document.getElementById(dragElements[i]));
+}
+
+for (var i = 0, length = dropElements.length; i < length; i++) {
+	fixDropInElement(document.getElementById(dropElements[i]));
+}

data/lib/js/scriptlist_validation_fields.js

@@ -0,0 +1,13 @@
+var hatemileValidationList = {
+    'required_fields': [],
+    'pattern_fields': [],
+    'fields_with_length': [],
+    'range_fields': [],
+    'week_fields': [],
+    'month_fields': [],
+    'datetime_fields': [],
+    'time_fields': [],
+    'date_fields': [],
+    'email_fields': [],
+    'url_fields': []
+};

data/lib/js/validation.js

@@ -0,0 +1,205 @@
+var DATA_IGNORE = 'data-ignoreaccessibilityfix';
+var DATA_EVENT_CHANGE_ADDED = 'data-changeadded';
+var DATA_INVALID_URL = 'data-invalidurl';
+var DATA_INVALID_EMAIL = 'data-invalidemail';
+var DATA_INVALID_RANGE = 'data-invalidrange';
+var DATA_INVALID_LENGTH = 'data-invalidlength';
+var DATA_INVALID_PATTERN = 'data-invalidpattern';
+var DATA_INVALID_REQUIRED = 'data-invalidrequired';
+var DATA_INVALID_DATE = 'data-invaliddate';
+var DATA_INVALID_TIME = 'data-invalidtime';
+var DATA_INVALID_DATETIME = 'data-invaliddatetime';
+var DATA_INVALID_MONTH = 'data-invalidmonth';
+var DATA_INVALID_WEEK = 'data-invalidweek';
+var VALIDATION_TYPE = 'type';
+var VALIDATION_REQUIRED = 'required';
+var VALIDATION_PATTERN = 'pattern';
+var VALIDATION_LENGTH = 'length';
+
+var isValid = function (field) {
+	if (field.hasAttribute(DATA_INVALID_URL)) {
+		return false;
+	} else if (field.hasAttribute(DATA_INVALID_EMAIL)) {
+		return false;
+	} else if (field.hasAttribute(DATA_INVALID_RANGE)) {
+		return false;
+	} else if (field.hasAttribute(DATA_INVALID_LENGTH)) {
+		return false;
+	} else if (field.hasAttribute(DATA_INVALID_PATTERN)) {
+		return false;
+	} else if (field.hasAttribute(DATA_INVALID_REQUIRED)) {
+		return false;
+	} else if (field.hasAttribute(DATA_INVALID_DATE)) {
+		return false;
+	} else if (field.hasAttribute(DATA_INVALID_TIME)) {
+		return false;
+	} else if (field.hasAttribute(DATA_INVALID_DATETIME)) {
+		return false;
+	} else if (field.hasAttribute(DATA_INVALID_MONTH)) {
+		return false;
+	} else if (field.hasAttribute(DATA_INVALID_WEEK)) {
+		return false;
+	} else {
+		return true;
+	}
+};
+
+var validateNow = function (field, dataInvalid, validateFunction) {
+	if (validateFunction(field)) {
+		if (field.hasAttribute(dataInvalid)) {
+			field.removeAttribute(dataInvalid);
+			if ((field.hasAttribute('aria-invalid')) && (isValid(field))) {
+				field.removeAttribute('aria-invalid');
+			}
+		}
+	} else {
+		field.setAttribute(dataInvalid, 'true');
+		field.setAttribute('aria-invalid', 'true');
+	}
+};
+
+var validate = function (idField, dataInvalid, typeFix, validateFunction) {
+	var field = document.getElementById(idField);
+	validateNow(field, dataInvalid, validateFunction);
+	addEventHandler(field, 'change', DATA_EVENT_CHANGE_ADDED, typeFix, function (event) {
+		return validateNow(field, dataInvalid, validateFunction);
+	});
+};
+
+var isValidRegularExpression = function (value, pattern) {
+	var regularExpression;
+	regularExpression = new RegExp(pattern);
+	return regularExpression.test(value);
+};
+
+var isValidURL = function (field) {
+	return isEmpty(field.value) || isValidRegularExpression(field.value, '([a-zA-Z][a-zA-Z0-9\\+\\.\\-]*):(\\/\\/)?(?:(?:(?:[a-zA-Z0-9_\\.' + '\\-\\+!$&\'\\(\\)*\\+,;=]|%[0-9a-f]{2})+:)*(?:[a-zA-Z0-9_\\.\\-\\+' + '%!$&\'\\(\\)*\\+,;=]|%[0-9a-f]{2})+@)?(?:(?:[a-z0-9\\-\\.]|%' + '[0-9a-f]{2})+|(?:\\[(?:[0-9a-f]{0,4}:)*(?:[0-9a-f]{0,4})\\]))' + '(?::[0-9]+)?(?:[\\/|\\?](?:[a-zA-Z0-9_#!:\\.\\?\\+=&@!$\'~*,;\\/' + '\\(\\)\\[\\]\\-]|%[0-9a-f]{2})*)?');
+};
+
+var isValidEmail = function (field) {
+	var regularExpression;
+	regularExpression = '(?:[a-z0-9!#$%&\'*+\/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&' + '\'*+\/=?^_`{|}~-]+)*|"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21' + '\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*")' + '@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*' + '[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]?|[a-z0-9-]*[a-z0-9]:(?:' + '[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|' + '\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)\\])';
+	if (field.hasAttribute('multiple')) {
+		regularExpression = regularExpression + "( *, *" + regularExpression + ")*";
+	}
+	return isEmpty(field.value) || isValidRegularExpression(field.value, "^(" + regularExpression + ")?$");
+};
+
+var isValidDate = function (field) {
+	return isEmpty(field.value) || isValidRegularExpression(field.value, '^([0-9]{2}((((' + '[02468][048])|([13579][26]))-(02)-((0[1-9])|([12][0-9])))|' + '(([0-9]{2})-((02-((0[1-9])|(1[0-9])|(2[0-8])))|(((0[469])|(11))-' + '((0[1-9])|([12][0-9])|(30)))|(((0[13578])|(10)|(12))-((0[1-9])|' + '([12][0-9])|(3[01])))))))?$');
+};
+
+var isValidTime = function (field) {
+	return isEmpty(field.value) || isValidRegularExpression(field.value, '^((([01][0-9])|' + '(2[0-3])):[0-5][0-9])?$');
+};
+
+var isValidDateTime = function (field) {
+	return isEmpty(field.value) || isValidRegularExpression(field.value, '^([0-9]{2}((((' + '[02468][048])|([13579][26]))-(02)-((0[1-9])|([12][0-9])))|' + '(([0-9]{2})-((02-((0[1-9])|(1[0-9])|(2[0-8])))|(((0[469])|(11))-' + '((0[1-9])|([12][0-9])|(30)))|(((0[13578])|(10)|(12))-((0[1-9])|' + '([12][0-9])|(3[01]))))))T(([01][0-9])|(2[0-3])):[0-5][0-9]((:[0-5]' + '[0-9].[0-9])|(Z))?)?$');
+};
+
+var isValidMonth = function (field) {
+	return isEmpty(field.value) || isValidRegularExpression(field.value, '^([0-9]{4}-' + '((0[1-9])|(1[0-2])))?$');
+};
+
+var isValidWeek = function (field) {
+	return isEmpty(field.value) || isValidRegularExpression(field.value, '^([0-9]{4}-W' + '((0[1-9])|([1-4][0-9])|(5[0-3])))?$');
+};
+
+var isValidRange = function (field) {
+	var maxValue, minValue, value;
+	if (!isEmpty(field.value)) {
+		if (!isValidRegularExpression(field.value, '^[-+]?[0-9]+([.,][0-9]+)?$')) {
+			return false;
+		}
+		value = parseFloat(field.value);
+		if (field.hasAttribute('min') || field.hasAttribute('aria-valuemin')) {
+			if (field.hasAttribute('min')) {
+				minValue = parseFloat(field.getAttribute('min'));
+			} else if (field.hasAttribute('aria-valuemin')) {
+				minValue = parseFloat(field.getAttribute('aria-valuemin'));
+			}
+			if (value < minValue) {
+				return false;
+			}
+		}
+		if (field.hasAttribute('max') || field.hasAttribute('aria-valuemax')) {
+			if (field.hasAttribute('max')) {
+				maxValue = parseFloat(field.getAttribute('max'));
+			} else if (field.hasAttribute('aria-valuemax')) {
+				maxValue = parseFloat(field.getAttribute('aria-valuemax'));
+			}
+			if (value > maxValue) {
+				return false;
+			}
+		}
+	}
+	return true;
+};
+
+var isValidLength = function (field) {
+	if (field.hasAttribute('minlength')) {
+		if (field.value.length < parseInt(field.getAttribute('minlength'))) {
+			return false;
+		}
+	}
+	if (field.hasAttribute('maxlength')) {
+		if (field.value.length > parseInt(field.getAttribute('maxlength'))) {
+			return false;
+		}
+	}
+	return true;
+};
+
+var isValidPattern = function (field) {
+	return isValidRegularExpression(field.value, field.getAttribute('pattern'));
+};
+
+var isValidRequired = function (field) {
+	return !isEmpty(field.value);
+};
+
+window.addEventListener('load', function() {
+	for (var i = 0, length = hatemileValidationList.required_fields.length; i < length; i++) {
+		validate(hatemileValidationList.required_fields[i], DATA_INVALID_REQUIRED, VALIDATION_REQUIRED, isValidRequired);
+	}
+
+	for (var i = 0, length = hatemileValidationList.pattern_fields.length; i < length; i++) {
+		validate(hatemileValidationList.pattern_fields[i], DATA_INVALID_PATTERN, VALIDATION_PATTERN, isValidPattern);
+	}
+
+	for (var i = 0, length = hatemileValidationList.fields_with_length.length; i < length; i++) {
+		validate(hatemileValidationList.fields_with_length[i], DATA_INVALID_LENGTH, VALIDATION_LENGTH, isValidLength);
+	}
+
+	for (var i = 0, length = hatemileValidationList.range_fields.length; i < length; i++) {
+		validate(hatemileValidationList.range_fields[i], DATA_INVALID_RANGE, VALIDATION_TYPE, isValidRange);
+	}
+
+	for (var i = 0, length = hatemileValidationList.week_fields.length; i < length; i++) {
+		validate(hatemileValidationList.week_fields[i], DATA_INVALID_WEEK, VALIDATION_TYPE, isValidWeek);
+	}
+
+	for (var i = 0, length = hatemileValidationList.month_fields.length; i < length; i++) {
+		validate(hatemileValidationList.month_fields[i], DATA_INVALID_MONTH, VALIDATION_TYPE, isValidMonth);
+	}
+
+	for (var i = 0, length = hatemileValidationList.datetime_fields.length; i < length; i++) {
+		validate(hatemileValidationList.datetime_fields[i], DATA_INVALID_DATETIME, VALIDATION_TYPE, isValidDateTime);
+	}
+
+	for (var i = 0, length = hatemileValidationList.time_fields.length; i < length; i++) {
+		validate(hatemileValidationList.time_fields[i], DATA_INVALID_TIME, VALIDATION_TYPE, isValidTime);
+	}
+
+	for (var i = 0, length = hatemileValidationList.date_fields.length; i < length; i++) {
+		validate(hatemileValidationList.date_fields[i], DATA_INVALID_DATE, VALIDATION_TYPE, isValidDate);
+	}
+
+	for (var i = 0, length = hatemileValidationList.email_fields.length; i < length; i++) {
+		validate(hatemileValidationList.email_fields[i], DATA_INVALID_EMAIL, VALIDATION_TYPE, isValidEmail);
+	}
+
+	for (var i = 0, length = hatemileValidationList.url_fields.length; i < length; i++) {
+		validate(hatemileValidationList.url_fields[i], DATA_INVALID_URL, VALIDATION_TYPE, isValidURL);
+	}
+});