kanun 0.1.7 → 1.0.1

package/dist/index.cjs

@@ -26,11 +26,50 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
+let node_async_hooks = require("node:async_hooks");
 let dayjs_plugin_customParseFormat_js = require("dayjs/plugin/customParseFormat.js");
 dayjs_plugin_customParseFormat_js = __toESM(dayjs_plugin_customParseFormat_js);
 let dayjs = require("dayjs");
 dayjs = __toESM(dayjs);
 
+//#region src/Context.ts
+const validatorContextStorage = new node_async_hooks.AsyncLocalStorage();
+/**
+* Get the current validator context. 
+* 
+* @returns 
+*/
+function getValidatorContext() {
+	return validatorContextStorage.getStore() ?? {};
+}
+/**
+* Use a context for the current validator instance and all of its children.
+* 
+* @param context 
+* @returns 
+*/
+function useValidatorContext(context = {}) {
+	const nextContext = {
+		...getValidatorContext(),
+		...context
+	};
+	validatorContextStorage.enterWith(nextContext);
+	return nextContext;
+}
+/**
+* Run a function with a given validator context.
+* 
+* @param context The context to use during the execution of the callback
+* @param callback The function to execute with the given context
+*/
+function runWithValidatorContext(context, callback) {
+	return validatorContextStorage.run({
+		...getValidatorContext(),
+		...context
+	}, callback);
+}
+
+//#endregion
 //#region src/Rules/baseRule.ts
 var BaseRule = class {};
 
@@ -266,6 +305,61 @@ var locales_default = {
 	ar: ar_default
 };
 
+//#endregion
+//#region src/utilities/helpers.ts
+/**
+* Pluralizes a word based on the count.
+* 
+* @param word 
+* @param count 
+* @returns 
+*/
+const plural = (word, count) => {
+	return count === 1 ? word : `${word}s`;
+};
+/**
+* Determine if a value is an object. Arrays and null are not considered objects.
+* 
+* @param value 
+* @returns 
+*/
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Deeply merge two objects. 
+* The source object will overwrite the target object when there is a conflict.
+* Arrays and non-object values will be overwritten, not merged.
+* 
+* @param target 
+* @param source 
+* @returns 
+*/
+function mergeDeep(target, source) {
+	const output = Object.assign({}, target);
+	if (!isObject(target) || !isObject(source)) return output;
+	for (const key in source) if (isObject(source[key])) if (!target[key]) Object.assign(output, { [key]: source[key] });
+	else output[key] = mergeDeep(target[key], source[key]);
+	else Object.assign(output, { [key]: source[key] });
+	return output;
+}
+/**
+* Deeply find a value in an object using a dot-notated path. 
+* Returns undefined if the path does not exist.
+* 
+* @param obj 
+* @param path 
+* @returns 
+*/
+function deepFindMessage(obj, path) {
+	const paths = path.split(".");
+	for (const segment of paths) {
+		if (typeof obj[segment] === "undefined") return;
+		obj = obj[segment];
+	}
+	return obj;
+}
+
 //#endregion
 //#region src/Lang.ts
 var Lang = class {
@@ -286,6 +380,10 @@ var Lang = class {
 	*/
 	static translations = {};
 	/**
+	* Store translations contributed by plugins.
+	*/
+	static translationExtensions = {};
+	/**
 	* Stores the messages that are already loaded
 	*/
 	static messages = {};
@@ -316,6 +414,16 @@ var Lang = class {
 	static setTranslationObject(translations) {
 		this.translations = translations;
 		this.existingLangs = Array.from(new Set([...this.existingLangs, ...Object.keys(translations)]));
+		this.resetLoadedMessages();
+		this.setDefaultLang(this.defaultLang);
+	}
+	/**
+	* Merge additional translations into the global catalog.
+	*/
+	static extendTranslationObject(translations) {
+		this.translationExtensions = mergeDeep(this.translationExtensions, translations);
+		this.existingLangs = Array.from(new Set([...this.existingLangs, ...Object.keys(translations)]));
+		this.resetLoadedMessages();
 		this.setDefaultLang(this.defaultLang);
 	}
 	/**
@@ -336,6 +444,7 @@ var Lang = class {
 		this.fallbackLang = lang;
 		this.fallbackMessages = locales_default.en;
 		if (Object.prototype.hasOwnProperty.call(locales_default, lang)) this.fallbackMessages = mergeDeep(this.fallbackMessages, locales_default[lang]);
+		if (Object.prototype.hasOwnProperty.call(this.translationExtensions, lang)) this.fallbackMessages = mergeDeep(this.fallbackMessages, this.translationExtensions[lang]);
 		if (Object.prototype.hasOwnProperty.call(this.translations, lang)) this.fallbackMessages = mergeDeep(this.fallbackMessages, this.translations[lang]);
 	}
 	/**
@@ -356,8 +465,13 @@ var Lang = class {
 		if (this.messages[lang]) return;
 		if (Object.prototype.hasOwnProperty.call(locales_default, lang)) this.messages[lang] = mergeDeep(this.fallbackMessages, locales_default[lang]);
 		else this.messages[lang] = mergeDeep({}, this.fallbackMessages);
+		if (Object.prototype.hasOwnProperty.call(this.translationExtensions, lang)) this.messages[lang] = mergeDeep(this.messages[lang], this.translationExtensions[lang]);
 		if (Object.prototype.hasOwnProperty.call(this.translations, lang)) this.messages[lang] = mergeDeep(this.messages[lang], this.translations[lang]);
 	}
+	static resetLoadedMessages() {
+		this.messages = {};
+		this.fallbackMessages = locales_default.en;
+	}
 };
 
 //#endregion
@@ -405,7 +519,7 @@ var IRuleContract = class {
 	* Get the translated error message based on the specified path
 	*/
 	trans(path, params = {}) {
-		let message = deepFind(Lang.get(this.lang), path) || "";
+		let message = deepFindMessage(Lang.get(this.lang), path) || "";
 		if (!message) return message;
 		for (const key in params) message = message.replace(`:${key}`, params[key]);
 		return message;
@@ -413,1473 +527,1506 @@ var IRuleContract = class {
 };
 
 //#endregion
-//#region src/utilities/general.ts
-const implicitRues = [
-	"accepted",
-	"accepted_if",
-	"declined",
-	"declined_if",
-	"filled",
-	"present",
-	"required",
-	"required_if",
-	"required_unless",
-	"required_with",
-	"required_with_all",
-	"required_without",
-	"required_without_all"
-];
-/**
-* Get the size of a value based on its type
-*/
-function getSize(value, hasNumericRule = false) {
-	if (typeof value === "number" || isNaN(value) === false && hasNumericRule === true) return Number(value);
-	else if (typeof value === "string" || Array.isArray(value)) return value.length;
-	else if (typeof value === "object" && value !== null) return Object.keys(value).length;
-	return -1;
-}
-/**
-* Check if two values are of the same type
-*/
-function sameType(value, otherValue) {
-	return (Array.isArray(value) ? "array" : value === null ? null : typeof value) === (Array.isArray(otherValue) ? "array" : otherValue === null ? null : typeof otherValue);
-}
-/**
-* Check if Value is an Ineteger
-*/
-function isInteger(value) {
-	return value !== null && isNaN(value) === false && value % 1 === 0;
-}
-/**
-* Check if the value can be considered as rule
-*/
-function isRule(value) {
-	return typeof value === "string" || typeof value === "function" || value instanceof IRuleContract || value instanceof BaseRule;
-}
-/**
-* Check if the array contain any potentiel valid rule
-*/
-function isArrayOfRules(values) {
-	for (let i = 0; i < values.length; i++) if (isRule(values[i])) return true;
-	return false;
-}
-/**
-* Check if the rule is related to size
-*/
-function isSizeRule(rule) {
-	return [
-		"size",
-		"between",
-		"min",
-		"max",
-		"gt",
-		"lt",
-		"gte",
-		"lte"
-	].indexOf(rule) !== -1;
-}
-/**
-* Check if rule implies that the field is required
-*/
-function isImplicitRule(rule) {
-	if (rule instanceof IRuleContract && rule.__isImplicitRule === true) return true;
-	if (typeof rule === "string") return implicitRues.indexOf(rule) !== -1;
-	return false;
-}
-/**
-* Add a new implicit rule
-*/
-function addImplicitRule(rule) {
-	implicitRues.push(rule);
-}
-/**
-* Returns the numeric rules
-*/
-function getNumericRules() {
-	return ["numeric", "integer"];
-}
-/**
-* Check if the rule is numeric
-*/
-function isNumericRule(rule) {
-	return getNumericRules().indexOf(rule) !== -1;
-}
-/**
-* Determine if a comparison passes between the given values.
-*/
-function compare(first, second, operator, strict = false) {
-	switch (operator) {
-		case "<": return first < second;
-		case ">": return first > second;
-		case "<=": return first <= second;
-		case ">=": return first >= second;
-		case "=":
-			if (strict === true) return first === second;
-			return first == second;
-		default: throw "Invalid operator parameter";
-	}
-}
-/**
-* Convert the given values to boolean if they are string "true" / "false".
-*/
-function convertValuesToBoolean(values) {
-	return values.map((value) => {
-		if (value === "true") return true;
-		else if (value === "false") return false;
-		return value;
-	});
-}
-/**
-* Convert the given values to numbers if they are numbers in a string "1", "2"
-*/
-function convertValuesToNumber(values) {
-	return values.map((value) => {
-		if (!isNaN(Number(value))) return Number(value);
-		return value;
-	});
-}
+//#region src/utilities/date.ts
 /**
-* Convert the given values to null if they have null values in a string "null", "NULL"
+* Convert value to date instance
 */
-function convertValuesToNull(values) {
-	return values.map((value) => {
-		if (value.toLowerCase() === "null") return null;
-		return value;
-	});
+function toDate(value) {
+	const date = Date.parse(value);
+	return !isNaN(date) ? new Date(date) : null;
 }
 
 //#endregion
-//#region src/utilities/object.ts
-/**
-* Get value at path of object. If the resolved value is undifined, the returned result will be undefined
-* 
-* @param obj 
-* @param path 
-* @returns 
-*/
-function deepFind(obj, path) {
-	const paths = path.split(".");
-	for (let i = 0; i < paths.length; i++) {
-		if (typeof obj[paths[i]] === "undefined") return;
-		obj = obj[paths[i]];
-	}
-	return obj;
-}
-/**
-* Set value at path of object. 
-* 
-* @param target 
-* @param path 
-* @param value 
-*/
-function deepSet(target, path, value) {
-	const paths = typeof path === "string" ? path.split(".") : path;
-	const segment = paths.shift();
-	if (segment === "*") {
-		target = Array.isArray(target) ? target : [];
-		if (paths.length > 0) target.forEach((inner) => deepSet(inner, [...paths], value));
-		else for (let i = 0; i < target.length; i++) target[i] = value;
-	} else if (paths.length > 0 && typeof segment === "string") {
-		if (typeof target[segment] !== "object" || target[segment] === null) target[segment] = {};
-		deepSet(target[segment], paths, value);
-	} else {
-		if (typeof target !== "object" || target === null) target = {};
-		target[segment] = value;
-	}
-}
-/**
-* Flatten a multi-dimensional associative array with dots.
-* 
-* @param obj 
-* @param ignoreRulesArray 
-* @param withBaseObjectType 
-* @returns 
-*/
-function dotify(obj, ignoreRulesArray = false, withBaseObjectType = false) {
-	const res = {};
-	(function recurse(obj, current = "") {
-		for (const key in obj) {
-			const value = obj[key];
-			const newKey = current ? `${current}.${key}` : key;
-			if (value && typeof value === "object" && !isRule(value) && !(value instanceof Date)) if (ignoreRulesArray === true && Array.isArray(value) && isArrayOfRules(value)) res[newKey] = value;
-			else {
-				if (withBaseObjectType) res[newKey] = Array.isArray(value) ? "array" : "object";
-				recurse(value, newKey);
-			}
-			else res[newKey] = value;
-		}
-	})(obj);
-	return res;
-}
-/**
-* Check if the value is an object
-* 
-* @param value 
-* @returns 
-*/
-function isObject(value) {
-	return value && typeof value === "object" && !Array.isArray(value);
-}
-/**
-* Deeply merge nested objects
-* 
-* @param target 
-* @param source 
-* @returns 
-*/
-function mergeDeep(target, source) {
-	const output = Object.assign({}, target);
-	if (!isObject(target) || !isObject(source)) return output;
-	for (const key in source) if (isObject(source[key])) if (!target[key]) Object.assign(output, { [key]: source[key] });
-	else output[key] = mergeDeep(target[key], source[key]);
-	else Object.assign(output, { [key]: source[key] });
-	return output;
-}
-/**
-* Check if objects are deep equal
-* 
-* @param firstParam 
-* @param secondParam 
-* @returns 
-*/
-function deepEqual(firstParam, secondParam) {
-	const first = dotify(firstParam, false, true);
-	const second = dotify(secondParam, false, true);
-	if (Object.keys(first).length !== Object.keys(second).length) return false;
-	return Object.entries(first).every(([key, value]) => second[key] === value);
-}
+//#region src/validators/replaceAttributes.ts
+const replaceAttributes = {
+	replaceAcceptedIf: function({ data, message, parameters, getDisplayableAttribute }) {
+		const [other] = parameters;
+		const result = deepFind(data, other);
+		const values = {
+			":other": getDisplayableAttribute(other),
+			":value": result
+		};
+		return message.replace(/:other|:value/gi, (matched) => values[matched]);
+	},
+	replaceAfter: function(payload) {
+		return this.replaceBefore(payload);
+	},
+	replaceAfterOrEqual: function(payload) {
+		return this.replaceBefore(payload);
+	},
+	replaceBefore: function({ message, parameters, getDisplayableAttribute }) {
+		if (!toDate(parameters[0])) return message.replace(":date", getDisplayableAttribute(parameters[0]));
+		return message.replace(":date", parameters[0]);
+	},
+	replaceBeforeOrEqual: function(payload) {
+		return this.replaceBefore(payload);
+	},
+	replaceBetween: function({ message, parameters }) {
+		const values = {
+			":min": parameters[0],
+			":max": parameters[1]
+		};
+		return message.replace(/:min|:max/gi, (matched) => values[matched]);
+	},
+	replaceDateEquals: function(payload) {
+		return this.replaceBefore(payload);
+	},
+	replaceDatetime: function({ message, parameters }) {
+		return message.replace(":format", parameters[0]);
+	},
+	replaceDeclinedIf: function({ message, parameters, data, getDisplayableAttribute }) {
+		const [other] = parameters;
+		const result = deepFind(data, other);
+		const values = {
+			":other": getDisplayableAttribute(other),
+			":value": result
+		};
+		return message.replace(/:other|:value/gi, (matched) => values[matched]);
+	},
+	replaceDifferent: function(payload) {
+		return this.replaceSame(payload);
+	},
+	replaceDigits: function({ message, parameters }) {
+		return message.replace(":digits", parameters[0]);
+	},
+	replaceDigitsBetween: function(payload) {
+		return this.replaceBetween(payload);
+	},
+	replaceEndsWith: function({ message, parameters }) {
+		return message.replace(":values", parameters.join(", "));
+	},
+	replaceExists: function({ message, parameters, data }) {
+		return message.replace(":value", data[parameters[1]]);
+	},
+	replaceIn: function({ message, parameters }) {
+		return message.replace(":values", parameters.join(", "));
+	},
+	replaceIncludes: function({ message, parameters }) {
+		return message.replace(":values", parameters.join(", "));
+	},
+	replaceStartsWith: function({ message, parameters }) {
+		return message.replace(":values", parameters.join(", "));
+	},
+	replaceMin: function({ message, parameters }) {
+		return message.replace(":min", parameters[0]);
+	},
+	replaceMax: function({ message, parameters }) {
+		return message.replace(":max", parameters[0]);
+	},
+	replaceNotIncludes: function({ message, parameters }) {
+		return message.replace(":values", parameters.join(", "));
+	},
+	replaceRequiredWith: function({ message, parameters, getDisplayableAttribute }) {
+		return message.replace(":values", parameters.map((attribute) => getDisplayableAttribute(attribute)).join(", "));
+	},
+	replaceRequiredWithAll: function(payload) {
+		return this.replaceRequiredWith(payload);
+	},
+	replaceRequiredWithout: function(payload) {
+		return this.replaceRequiredWith(payload);
+	},
+	replaceRequiredWithoutAll: function(payload) {
+		return this.replaceRequiredWith(payload);
+	},
+	replaceGt: function({ message, parameters, data, hasNumericRule }) {
+		const [value] = parameters;
+		const result = deepFind(data, value);
+		if (typeof result === "undefined") return message.replace(":value", value);
+		return message.replace(":value", getSize(result, hasNumericRule).toString());
+	},
+	replaceLt: function(payload) {
+		return this.replaceGt(payload);
+	},
+	replaceGte: function(payload) {
+		return this.replaceGt(payload);
+	},
+	replaceLte: function(payload) {
+		return this.replaceGt(payload);
+	},
+	replaceRequiredIf: function({ message, parameters, data, getDisplayableAttribute }) {
+		const [other] = parameters;
+		const result = deepFind(data, other);
+		const values = {
+			":other": getDisplayableAttribute(other),
+			":value": result
+		};
+		return message.replace(/:other|:value/gi, (matched) => values[matched]);
+	},
+	replaceRequiredUnless: function({ message, parameters, getDisplayableAttribute }) {
+		const [other] = parameters;
+		const values = {
+			":other": getDisplayableAttribute(other),
+			":values": parameters.slice(1).join(", ")
+		};
+		return message.replace(/:other|:values/gi, (matched) => values[matched]);
+	},
+	replaceSame: function({ message, parameters, getDisplayableAttribute }) {
+		return message.replace(":other", getDisplayableAttribute(parameters[0]));
+	},
+	replaceSize: function({ message, parameters }) {
+		return message.replace(":size", parameters[0]);
+	},
+	replaceUnique: function({ message, parameters, data }) {
+		return message.replace(":value", data[parameters[1]]);
+	}
+};
 
 //#endregion
-//#region src/utilities/formatMessages.ts
-/**
-* Get the message type based on the value. The message type is used essentially for size rules
-*/
-function getMesageType(value, hasNumericRule = false) {
-	if (typeof value === "number" || typeof value === "undefined" || isNaN(value) === false && hasNumericRule === true) return "number";
-	if (Array.isArray(value)) return "array";
-	return typeof value;
-}
-/**
-* Get the custom message for a rule if exists
-*/
-function getCustomMessage(attributes, rule, customMessages, messageType, lang) {
-	const [attribute, primaryAttribute] = attributes;
-	const translatedMessages = dotify(Lang.get(lang)["custom"] || {});
-	const keys = getKeyCombinations(`${attribute}.${rule}`);
-	let allKeys = keys;
-	if (primaryAttribute) {
-		allKeys = [];
-		const primaryAttributeKeys = getKeyCombinations(`${primaryAttribute}.${rule}`);
-		for (let i = 0; i < keys.length; i++) {
-			allKeys.push(keys[i]);
-			if (keys[i] !== primaryAttributeKeys[i]) allKeys.push(primaryAttributeKeys[i]);
-		}
+//#region src/Rules/closureValidationRule.ts
+var ClosureValidationRule = class extends IRuleContract {
+	/**
+	* The callback that validates the attribute
+	*/
+	callback;
+	/**
+	* Indicates if the validation callback failed.
+	*/
+	failed = false;
+	constructor(callback) {
+		super();
+		this.callback = callback;
 	}
-	if (isSizeRule(rule)) {
-		allKeys.pop();
-		allKeys.push(`${rule}.${messageType}`);
-		allKeys.push(rule);
+	/**
+	* Determine if the validation rule passes.
+	*/
+	passes(value, attribute) {
+		this.failed = false;
+		const result = this.callback(value, (message) => {
+			this.failed = true;
+			this.message = message;
+		}, attribute);
+		if (result instanceof Promise) return result.then(() => !this.failed);
+		return !this.failed;
 	}
-	let key = "";
-	let message = "";
-	for (let i = 0; i < allKeys.length; i++) {
-		key = allKeys[i];
-		if (Object.prototype.hasOwnProperty.call(customMessages, key)) return customMessages[key];
-		message = translatedMessages[key];
-		if (typeof message === "string") return message;
+};
+
+//#endregion
+//#region src/validators/validationData.ts
+const validationData = {
+	initializeAndGatherData: function(attribute, masterData) {
+		const data = dotify(this.initializeAttributeOnData(attribute, masterData));
+		return {
+			...data,
+			...this.extractValuesFromWildCards(masterData, data, attribute)
+		};
+	},
+	initializeAttributeOnData: function(attribute, masterData) {
+		const explicitPath = this.getLeadingExplicitAttributePath(attribute);
+		const data = this.extractDataFromPath(explicitPath, JSON.parse(JSON.stringify(masterData)));
+		if (attribute.indexOf("*") === -1 || attribute.indexOf("*") === attribute.length - 1) return data;
+		deepSet(data, attribute, null);
+		return data;
+	},
+	extractValuesFromWildCards(masterData, data, attribute) {
+		const keys = [];
+		const pattern = new RegExp("^" + attribute.replace(/\*/g, "[^\\.]*"));
+		let result = null;
+		for (const key in data) {
+			result = key.match(pattern);
+			if (result) keys.push(result[0]);
+		}
+		data = {};
+		keys.forEach((key) => data[key] = deepFind(masterData, key));
+		return data;
+	},
+	getLeadingExplicitAttributePath: function(attribute) {
+		return attribute.split("*")[0].replace(/\.$/, "");
+	},
+	extractDataFromPath(path, masterData) {
+		const results = {};
+		const value = deepFind(masterData, path);
+		if (value !== void 0) deepSet(results, path, value);
+		return results;
 	}
-	return null;
-}
-/**
-* Get the validation message for an attribute and rule.
-*/
-function getMessage(attributes, rule, value, customMessages, hasNumericRule, lang) {
-	const inlineMessage = getCustomMessage(attributes, rule, customMessages, getMesageType(value, hasNumericRule), lang);
-	if (inlineMessage) return inlineMessage;
-	const validationMessages = Lang.get(lang);
-	if (isSizeRule(rule) === true) return validationMessages[rule][getMesageType(value, hasNumericRule)];
-	return validationMessages[rule] || "";
-}
-/**
-* Convert a string to snake case.
-*/
-function toSnakeCase(string) {
-	return string.split(/ |\B(?=[A-Z])/).map((word) => word.toLowerCase()).join("_");
-}
-/**
-* Get the formatted name of the attribute
-*/
-function getFormattedAttribute(attribute) {
-	return toSnakeCase(getPrimaryKeyFromPath(attribute)).replace(/_/g, " ").trim();
-}
-/**
-* Get the combinations of keys from a main key. For example if the main key is 'user.info.name',
-* the combination will be [user.info.name, info.name, name]
-*/
-function getKeyCombinations(key) {
-	const combinations = [key];
-	const splittedKey = key.split(".");
-	while (splittedKey.length > 1) {
-		splittedKey.shift();
-		combinations.push(splittedKey.join("."));
+};
+
+//#endregion
+//#region src/validators/validationRuleParser.ts
+const validationRuleParser = {
+	explodeRules: function(rules, data = {}) {
+		const implicitAttributes = {};
+		for (const key in rules) if (key.indexOf("*") !== -1) {
+			rules = this.explodeWildCardRules(rules, key, data, implicitAttributes);
+			delete rules[key];
+		} else if (Object.prototype.hasOwnProperty.call(rules, key) && Array.isArray(rules)) rules[Number(key)] = this.explodeExplicitRules(rules[Number(key)]);
+		else if (Object.prototype.hasOwnProperty.call(rules, key) && !Array.isArray(rules)) rules[key] = this.explodeExplicitRules(rules[key]);
+		return {
+			rules,
+			implicitAttributes
+		};
+	},
+	explodeWildCardRules: function(results, attribute, masterData, implicitAttributes) {
+		const pattern = new RegExp("^" + attribute.replace(/\*/g, "[^.]*") + "$");
+		const data = validationData.initializeAndGatherData(attribute, masterData);
+		const rule = results[attribute];
+		for (const key in data) if (key.slice(0, attribute.length) === attribute || key.match(pattern) !== null) {
+			if (Array.isArray(implicitAttributes[attribute])) implicitAttributes[attribute].push(key);
+			else implicitAttributes[attribute] = [key];
+			results = this.mergeRulesForAttribute(results, key, rule);
+		}
+		return results;
+	},
+	mergeRulesForAttribute(results, attribute, rules) {
+		const merge = this.explodeRules([rules]).rules[0];
+		results[attribute] = [...results[attribute] ? this.explodeExplicitRules(results[attribute]) : [], ...merge];
+		return results;
+	},
+	explodeExplicitRules: function(rules) {
+		if (typeof rules === "string") return rules.split("|");
+		if (!Array.isArray(rules)) return [this.prepareRule(rules)];
+		return rules.map((rule) => this.prepareRule(rule));
+	},
+	prepareRule(rule) {
+		if (rule instanceof IRuleContract) return rule;
+		if (typeof rule === "function") return new ClosureValidationRule(rule);
+		return rule.toString();
+	},
+	parse(rule) {
+		if (rule instanceof IRuleContract) return [rule, []];
+		return this.parseStringRule(rule);
+	},
+	parseStringRule: function(rule) {
+		let parameters = [];
+		let parameter;
+		if (rule.indexOf(":") !== -1) {
+			[rule, parameter] = rule.split(/:(.+)/);
+			parameters = parameter.split(",");
+		}
+		return [rule, parameters];
+	},
+	getRule: function(attribute, searchRules, availableRules) {
+		if (!availableRules[attribute]) return [];
+		searchRules = Array.isArray(searchRules) ? searchRules : [searchRules];
+		for (let i = 0; i < availableRules[attribute].length; i++) {
+			const [rule, parameters] = this.parse(availableRules[attribute][i]);
+			if (searchRules.indexOf(rule) !== -1) return [rule, parameters];
+		}
+		return [];
+	},
+	hasRule: function(attribute, searchRules, availableRules) {
+		return this.getRule(attribute, searchRules, availableRules).length > 0;
 	}
-	return combinations;
-}
-/**
-* The purpose of this method if to get the primary key associated with a path
-* For example the primary key for path 'user.info.email' will be 'email'
-*/
-function getPrimaryKeyFromPath(path) {
-	const splittedPath = path.split(".");
-	if (splittedPath.length <= 1) return path;
-	const key = splittedPath.pop();
-	if (isNaN(parseInt(key)) === false) return getPrimaryKeyFromPath(splittedPath.join("."));
-	return key;
-}
+};
 
 //#endregion
-//#region src/validators/errorBag.ts
-var ErrorBag = class ErrorBag {
+//#region src/validators/validateAttributes.ts
+var validateAttributes = class {
 	/**
-	* All of the registered messages.
+	* Stores the data object
 	*/
-	errors = {};
+	data;
 	/**
-	* All Messages
+	* Stores the rules object
 	*/
-	messages = {};
+	rules;
 	/**
-	* Stores the first error message
+	* Stores validator context that plugins can consume.
 	*/
-	firstMessage = "";
+	context;
+	constructor(data = {}, rules = {}, context = {}) {
+		this.data = data;
+		this.rules = rules;
+		this.context = context;
+	}
 	/**
-	* Specify whether error types should be returned or no
+	* Validate that an attribute was "accepted".
+	*
+	* This validation rule implies the attribute is "required".
 	*/
-	withErrorTypes = false;
-	constructor(errors = {}, messages = {}, firstMessage = "", withErrorTypes = false) {
-		this.errors = errors;
-		this.messages = messages;
-		this.firstMessage = firstMessage;
-		this.withErrorTypes = withErrorTypes;
+	validateAccepted(value) {
+		return this.validateRequired(value) && [
+			"yes",
+			"on",
+			"1",
+			1,
+			true,
+			"true"
+		].indexOf(value) !== -1;
 	}
 	/**
-	* Set withErrorTypes attribute to true
+	* Validate that an attribute was "accepted" when another attribute has a given value.
 	*/
-	addErrorTypes() {
-		this.withErrorTypes = true;
-		return this;
+	validateAcceptedIf(value, parameters) {
+		this.requireParameterCount(2, parameters, "accepted_if");
+		const other = deepFind(this.data, parameters[0]);
+		if (!other) return true;
+		if (parameters.slice(1).indexOf(other) !== -1) return this.validateAccepted(value);
+		return true;
 	}
 	/**
-	* Add new recodrs to the errors and messages objects
+	*  Validate the date is after a given date.
 	*/
-	add(key, error) {
-		if (Array.isArray(this.errors[key]) && Array.isArray(this.messages[key])) {
-			this.errors[key].push(error);
-			this.messages[key].push(error.message);
-		} else {
-			this.errors[key] = [error];
-			this.messages[key] = [error.message];
-		}
-		this.firstMessage = this.firstMessage || error.message;
+	validateAfter(value, parameters) {
+		this.requireParameterCount(1, parameters, "after");
+		return this.compareDates(value, parameters[0], ">", "after");
 	}
 	/**
-	* Get the first error related to a specific key
+	* Validate the date is after or equal a given date.
 	*/
-	first(key = null) {
-		if (!key) return this.firstMessage;
-		if (this.has(key)) return this.messages[key][0];
-		return "";
+	validateAfterOrEqual(value, parameters) {
+		this.requireParameterCount(1, parameters, "after_or_equal");
+		return this.compareDates(value, parameters[0], ">=", "after_or_equal");
 	}
 	/**
-	* Get the error messages keys
+	* Validate that an attribute contains only alphabetic characters.
 	*/
-	keys() {
-		return Object.keys(this.messages);
+	validateAlpha(value) {
+		return typeof value === "string" && /^[a-zA-Z]+$/.test(value);
 	}
 	/**
-	* Get all the messages related to a specific key
+	* Validate that an attribute contains only alpha-numeric characters, dashes, and underscores.
 	*/
-	get(key, withErrorTypes = this.withErrorTypes) {
-		if (!this.has(key)) return [];
-		if (withErrorTypes) return this.errors[key];
-		return this.messages[key];
+	validateAlphaDash(value) {
+		if (typeof value != "string" && typeof value != "number") return false;
+		return /^(?=.*[a-zA-Z0-9])[a-zA-Z0-9-_]+$/.test(value.toString());
 	}
 	/**
-	* Check if key exists in messages
+	* Validate that an attribute contains only alpha-numeric characters.
 	*/
-	has(key) {
-		return this.messages[key] && this.messages[key].length > 0 ? true : false;
+	validateAlphaNum(value) {
+		if (typeof value != "string" && typeof value != "number") return false;
+		return /^[a-zA-Z0-9]+$/.test(value.toString());
 	}
 	/**
-	* Get all error messages
+	* Validate that an attribute is an array
 	*/
-	all(allMessages = true, withErrorTypes = this.withErrorTypes) {
-		const messages = withErrorTypes ? { ...this.errors } : { ...this.messages };
-		if (!allMessages) Object.keys(messages).map((attribute) => messages[attribute] = messages[attribute][0]);
-		return messages;
+	validateArray(value) {
+		return Array.isArray(value);
+	}
+	/**
+	* Validate that an attribute is an array and that his values are unique
+	*/
+	validateArrayUnique(value) {
+		if (!Array.isArray(value)) return false;
+		return new Set(value).size === value.length;
 	}
 	/**
-	* Remove error messages
+	* Always returns true - this method will be used in conbination with other rules and will be used to stop validation of first failure
 	*/
-	clear(keys) {
-		if (keys.length === 0) {
-			this.errors = {};
-			this.messages = {};
-			this.firstMessage = "";
-			return this;
-		}
-		keys.forEach((key) => {
-			if (Object.prototype.hasOwnProperty.call(this.messages, key)) {
-				delete this.messages[key];
-				delete this.errors[key];
-			}
-		});
-		this.firstMessage = "";
-		if (this.keys().length > 0) this.firstMessage = this.messages[Object.keys(this.messages)[0]][0];
-		return this;
+	validateBail() {
+		return true;
 	}
 	/**
-	* Clone ErrorBag Instance
+	*  Validate the date is before a given date.
 	*/
-	clone() {
-		return new ErrorBag({ ...this.errors }, { ...this.messages }, this.firstMessage, this.withErrorTypes);
+	validateBefore(value, parameters) {
+		this.requireParameterCount(1, parameters, "before");
+		return this.compareDates(value, parameters[0], "<", "before");
 	}
-};
-
-//#endregion
-//#region src/Rules/password.ts
-var Password$1 = class Password$1 extends IRuleContract {
 	/**
-	* The validator performing the validation.
-	*/
-	validator;
-	/**
-	* The minimum size of the password.
+	* Validate the date is before or equal a given date.
 	*/
-	minLength = 8;
+	validateBeforeOrEqual(value, parameters) {
+		this.requireParameterCount(1, parameters, "before_or_equal");
+		return this.compareDates(value, parameters[0], "<=", "before_or_equal");
+	}
 	/**
-	* The min amount of lower case letters required in the password 
+	* Validate the size of an attribute is between a set of values
 	*/
-	minLowerCase = 0;
+	validateBetween(value, parameters, attribute) {
+		if (typeof value !== "string" && typeof value !== "number" && typeof value !== "object") throw "Validation rule between requires the field under validation to be a number, string, array, or object.";
+		this.requireParameterCount(2, parameters, "between");
+		let [min, max] = parameters;
+		if (isNaN(min) || isNaN(max)) throw "Validation rule between requires both parameters to be numbers.";
+		min = Number(min);
+		max = Number(max);
+		if (min >= max) throw "Validation rule between requires that the first parameter be greater than the second one.";
+		const size = getSize(value, validationRuleParser.hasRule(attribute, getNumericRules(), this.rules));
+		return size >= min && size <= max;
+	}
 	/**
-	* The min amount of uppercase letters required in the password
+	* Validate that an attribute is boolean
 	*/
-	minUpperCase = 0;
+	validateBoolean(value, parameters, attribute) {
+		if (validationRuleParser.hasRule(attribute, "strict", this.rules)) return typeof value === "boolean";
+		return [
+			true,
+			false,
+			0,
+			1,
+			"0",
+			"1"
+		].indexOf(value) !== -1;
+	}
 	/**
-	* The min amount of letters required in the password
+	* Validate that an attribute has matching confirmation.
 	*/
-	minLetters = 0;
+	validateConfirmed(value, parameters, attribute) {
+		return this.validateSame(value, [`${attribute}_confirmation`]) || this.validateSame(value, [`${attribute}Confirmation`]);
+	}
 	/**
-	* The min amount of letters required in the password
+	* Validate that an attribute is a valid date.
 	*/
-	minNumbers = 0;
+	validateDate(value) {
+		return toDate(value) ? true : false;
+	}
 	/**
-	* The min amount of symbols required in the password
+	* Validate that an attribute is equal to another date.
 	*/
-	minSymbols = 0;
+	validateDateEquals(value, paramters) {
+		this.requireParameterCount(1, paramters, "date_equals");
+		return this.compareDates(value, paramters[0], "=", "date_equals");
+	}
 	/**
-	* Additional validation rules that should be merged into the default rules during validation.
+	* Validate that an attribute was "declined".
+	*
+	* This validation rule implies the attribute is "required".
 	*/
-	customRules = [];
+	validateDeclined(value) {
+		return this.validateRequired(value) && [
+			"no",
+			"off",
+			"0",
+			0,
+			false,
+			"false"
+		].indexOf(value) !== -1;
+	}
 	/**
-	* The callback that will generate the "default" version of the password rule.
+	* Validate that an attribute was "declined" when another attribute has a given value.
 	*/
-	static defaultCallback;
+	validateDeclinedIf(value, parameters) {
+		this.requireParameterCount(2, parameters, "declined_if");
+		const other = deepFind(this.data, parameters[0]);
+		if (!other) return true;
+		if (parameters.slice(1).indexOf(other) !== -1) return this.validateDeclined(value);
+		return true;
+	}
 	/**
-	* Create a new instance of the password class
+	* Validate that an attribute is different from another attribute.
 	*/
-	static create() {
-		return new Password$1();
+	validateDifferent(value, parameters) {
+		this.requireParameterCount(1, parameters, "different");
+		const other = deepFind(this.data, parameters[0]);
+		if (!sameType(value, other)) return true;
+		if (value !== null && typeof value === "object") return !deepEqual(value, other);
+		return value !== other;
 	}
 	/**
-	* Set the minimum length of the password
+	*  Validate that an attribute has a given number of digits.
 	*/
-	min(min) {
-		this.minLength = min;
-		return this;
+	validateDigits(value, parameters) {
+		this.requireParameterCount(1, parameters, "digits");
+		if (isInteger(parameters[0]) === false) throw "Validation rule digits requires the parameter to be an integer.";
+		if (parameters[0] <= 0) throw "Validation rule digits requires the parameter to be an integer greater than 0.";
+		if (typeof value !== "string" && typeof value !== "number") return false;
+		value = value.toString();
+		return /^\d+$/.test(value) && value.length === parseInt(parameters[0]);
 	}
 	/**
-	* Set the min amount of letters required in the password
+	* Validate that an attribute is between a given number of digits.
 	*/
-	letters(letters = 1) {
-		this.minLetters = letters;
-		return this;
+	validateDigitsBetween(value, parameters) {
+		this.requireParameterCount(2, parameters, "digits_between");
+		let [min, max] = parameters;
+		if (isInteger(min) === false || isInteger(max) === false) throw "Validation rule digits_between requires both parameters to be integers.";
+		min = parseInt(min);
+		max = parseInt(max);
+		if (min <= 0 || max <= 0) throw "Validation rule digits_between requires the parameters to be an integer greater than 0.";
+		if (min >= max) throw "Validation rule digits_between requires the max param to be greater than the min param.";
+		if (typeof value !== "string" && typeof value !== "number") return false;
+		value = value.toString();
+		const valueLength = value.length;
+		return /^\d+$/.test(value) && valueLength >= min && valueLength <= max;
 	}
 	/**
-	* Set the min amount of upper and lower case letters required in the password
+	* Validate that an attribute is a valid email address.
 	*/
-	mixedCase(upperCase = 1, lowerCase = 1) {
-		this.minUpperCase = upperCase;
-		this.minLowerCase = lowerCase;
-		return this;
+	validateEmail(value) {
+		if (typeof value !== "string") return false;
+		/**
+		* Max allowed length for a top-level-domain is 24 characters.
+		* reference to list of top-level-domains: https://data.iana.org/TLD/tlds-alpha-by-domain.txt
+		*/
+		return value.toLowerCase().match(/^\w+([.-]?\w+)*@\w+([.-]?\w+)*(\.\w{2,24})+$/) !== null;
 	}
 	/**
-	* Set the min amount of numbers required in the password
+	* Validate the attribute ends with a given substring.
 	*/
-	numbers(numbers = 1) {
-		this.minNumbers = numbers;
-		return this;
+	validateEndsWith(value, parameters) {
+		this.requireParameterCount(1, parameters, "ends_with");
+		if (typeof value !== "string") throw "The field under validation must be a string";
+		const valueLength = value.length;
+		for (let i = 0; i < parameters.length; i++) if (typeof parameters[i] === "string" && value.indexOf(parameters[i], valueLength - parameters[i].length) !== -1) return true;
+		return false;
 	}
 	/**
-	* Set the min amount of symbols required in the password
+	* Validate that two attributes match.
 	*/
-	symbols(symbols = 1) {
-		this.minSymbols = symbols;
-		return this;
+	validateSame(value, paramaters) {
+		this.requireParameterCount(1, paramaters, "same");
+		const other = deepFind(this.data, paramaters[0]);
+		if (!sameType(value, other)) return false;
+		if (value !== null && typeof value === "object") return deepEqual(value, other);
+		return value === other;
 	}
 	/**
-	* Determine if the validation rule passes.
+	* Validate the size of an attribute.
 	*/
-	passes(value, attribute) {
-		const validator = new BaseValidator(this.data, { [attribute]: [
-			"string",
-			`min:${this.minLength}`,
-			...this.customRules
-		] }, this.validator.customMessages, this.validator.customAttributes).setLang(this.lang);
-		if (!validator.validate()) {
-			const errors = validator.errors().addErrorTypes().get(attribute);
-			for (const key in errors) this.validator.errors().add(attribute, errors[key]);
-		}
-		if (typeof value !== "string") value = "";
-		let pattern;
-		const formattedAttribute = this.validator.getDisplayableAttribute(attribute);
-		if (this.minLowerCase) {
-			pattern = this.minLowerCase === 1 ? /\p{Ll}/u : new RegExp(`(.*\\p{Ll}){${this.minLowerCase}}.*`, "u");
-			if (!value || pattern.test(value) === false) this.validator.errors().add(attribute, {
-				error_type: "min_lower_case",
-				message: this.trans(`password.${this.minLowerCase === 1 ? "lower_case" : "lower_cases"}`, {
-					attribute: formattedAttribute,
-					amount: this.minLowerCase
-				})
-			});
-		}
-		if (this.minUpperCase) {
-			pattern = this.minUpperCase === 1 ? /\p{Lu}/u : new RegExp(`(.*\\p{Lu}){${this.minUpperCase}}.*`, "u");
-			if (!value || pattern.test(value) === false) this.validator.errors().add(attribute, {
-				error_type: "min_upper_case",
-				message: this.trans(`password.${this.minUpperCase === 1 ? "upper_case" : "upper_cases"}`, {
-					attribute: formattedAttribute,
-					amount: this.minUpperCase
-				})
-			});
-		}
-		if (this.minLetters) {
-			pattern = this.minLetters === 1 ? /\p{L}/u : new RegExp(`(.*\\p{L}){${this.minLetters}}.*`, "u");
-			if (!value || pattern.test(value) === false) this.validator.errors().add(attribute, {
-				error_type: "min_letters",
-				message: this.trans(`password.${this.minLetters === 1 ? "letter" : "letters"}`, {
-					attribute: formattedAttribute,
-					amount: this.minLetters
-				})
-			});
-		}
-		if (this.minNumbers) {
-			pattern = this.minNumbers === 1 ? /\p{N}/u : new RegExp(`(.*\\p{N}){${this.minNumbers}}.*`, "u");
-			if (!value || pattern.test(value) === false) this.validator.errors().add(attribute, {
-				error_type: "min_numbers",
-				message: this.trans(`password.${this.minNumbers === 1 ? "number" : "numbers"}`, {
-					attribute: formattedAttribute,
-					amount: this.minNumbers
-				})
-			});
-		}
-		if (this.minSymbols) {
-			pattern = this.minSymbols === 1 ? /\p{Z}|\p{S}|\p{P}/u : new RegExp(`(.*(\\p{Z}|\\p{S}|\\p{P})){${this.minSymbols}}.*`, "u");
-			if (!value || pattern.test(value) === false) this.validator.errors().add(attribute, {
-				error_type: "min_symbols",
-				message: this.trans(`password.${this.minSymbols === 1 ? "symbol" : "symbols"}`, {
-					attribute: formattedAttribute,
-					amount: this.minSymbols
-				})
-			});
-		}
-		if (this.validator.errors().has(attribute)) return false;
-		return true;
+	validateSize(value, parameters, attribute) {
+		this.requireParameterCount(1, parameters, "size");
+		return getSize(value, validationRuleParser.hasRule(attribute, getNumericRules(), this.rules)) === Number(parameters[0]);
 	}
 	/**
-	* Specify additional validation rules that should be merged with the default rules during validation.
+	* Validate Optinial attributes. Always return true, just lets us put sometimes in rule.
 	*/
-	rules(rules) {
-		this.customRules = rules;
-		return this;
+	validateSometimes() {
+		return true;
 	}
 	/**
-	* Get all the validation error messages related to the password
+	* Validate the attribute starts with a given substring.
 	*/
-	getMessage() {
-		return {};
+	validateStartsWith(value, parameters) {
+		this.requireParameterCount(1, parameters, "starts_with");
+		if (typeof value !== "string") throw "The field under validation must be a string";
+		for (let i = 0; i < parameters.length; i++) if (typeof parameters[i] === "string" && value.substr(0, parameters[i].length) === parameters[i]) return true;
+		return false;
 	}
 	/**
-	* Set the validator instance used to validate the password
+	* Validate that a required attribute exists
 	*/
-	setValidator(validator) {
-		this.validator = validator;
-		return this;
+	validateRequired(value) {
+		if (value === null || typeof value === "undefined") return false;
+		else if (typeof value === "string" && value.trim() === "") return false;
+		else if (Array.isArray(value) && value.length < 1) return false;
+		else if (typeof value === "object" && Object.keys(value).length < 1) return false;
+		return true;
 	}
 	/**
-	* Set the default callback to be used for determining a password's default rules.
+	* Validate that an attribute exists when another atteribute has a given value
 	*/
-	static setDefault(callback = null) {
-		if (callback instanceof Password$1) {
-			this.defaultCallback = callback;
-			return;
-		}
-		if (typeof callback !== "function") throw "The given callback should be callable";
-		this.defaultCallback = callback;
+	validateRequiredIf(value, parameters) {
+		this.requireParameterCount(2, parameters, "required_if");
+		const other = deepFind(this.data, parameters[0]);
+		if (typeof other === "undefined") return true;
+		if (this.parseDependentRuleParameters(other, parameters).indexOf(other) !== -1) return this.validateRequired(value);
+		return true;
 	}
 	/**
-	* Get the default configuration of the password rule.
+	* Validate that an attribute exists when another attribute does not have a given value.
 	*/
-	static default() {
-		const password = typeof this.defaultCallback === "function" ? this.defaultCallback() : this.defaultCallback;
-		return password instanceof IRuleContract ? password : Password$1.create().min(8);
+	validateRequiredUnless(value, parameters) {
+		this.requireParameterCount(2, parameters, "required_unless");
+		let other = deepFind(this.data, parameters[0]);
+		other = typeof other === "undefined" ? null : other;
+		if (this.parseDependentRuleParameters(other, parameters).indexOf(other) === -1) return this.validateRequired(value);
+		return true;
 	}
-};
-
-//#endregion
-//#region src/utilities/build.ts
-function buildValidationMethodName(rule) {
-	if (!rule) return rule;
-	return rule.split("_").map((rule) => `${rule[0].toUpperCase()}${rule.slice(1)}`).join("");
-}
-
-//#endregion
-//#region src/payloads/replaceAttributePayload.ts
-var replaceAttributePayload = class {
 	/**
-	* Stores the data object
+	* Validate that an attribute exists when any other attribute exists.
 	*/
-	data;
+	validateRequiredWith(value, parameters) {
+		if (!this.allFailingRequired(parameters)) return this.validateRequired(value);
+		return true;
+	}
 	/**
-	* The message in which attributes will be replaced
+	* Validate that an attribute exists when all other attributes exist.
 	*/
-	message;
+	validateRequiredWithAll(value, parameters) {
+		if (!this.anyFailingRequired(parameters)) return this.validateRequired(value);
+		return true;
+	}
 	/**
-	* Parameters that will be used to replace the attributes
+	* Validate that an attribute exists when another attribute does not.
 	*/
-	parameters;
+	validateRequiredWithout(value, parameters) {
+		if (this.anyFailingRequired(parameters)) return this.validateRequired(value);
+		return true;
+	}
 	/**
-	* Flag that identifies wether the numeric rule exists or not
+	* Validate that an attribute exists when all other attributes do not.
 	*/
-	hasNumericRule;
+	validateRequiredWithoutAll(value, parameters) {
+		if (this.allFailingRequired(parameters)) return this.validateRequired(value);
+		return true;
+	}
 	/**
-	* The function that will be used to format attributes
+	* Determine if any of the given attributes fail the required test.
 	*/
-	getDisplayableAttribute;
-	constructor(data, message, parameters, hasNumericRule, getDisplayableAttribute) {
-		this.data = data;
-		this.message = message;
-		this.parameters = parameters;
-		this.hasNumericRule = hasNumericRule;
-		this.getDisplayableAttribute = getDisplayableAttribute;
-	}
-};
-
-//#endregion
-//#region src/utilities/date.ts
-/**
-* Convert value to date instance
-*/
-function toDate(value) {
-	const date = Date.parse(value);
-	return !isNaN(date) ? new Date(date) : null;
-}
-
-//#endregion
-//#region src/validators/replaceAttributes.ts
-const replaceAttributes = {
-	replaceAcceptedIf: function({ data, message, parameters, getDisplayableAttribute }) {
-		const [other] = parameters;
-		const result = deepFind(data, other);
-		const values = {
-			":other": getDisplayableAttribute(other),
-			":value": result
-		};
-		return message.replace(/:other|:value/gi, (matched) => values[matched]);
-	},
-	replaceAfter: function(payload) {
-		return this.replaceBefore(payload);
-	},
-	replaceAfterOrEqual: function(payload) {
-		return this.replaceBefore(payload);
-	},
-	replaceBefore: function({ message, parameters, getDisplayableAttribute }) {
-		if (!toDate(parameters[0])) return message.replace(":date", getDisplayableAttribute(parameters[0]));
-		return message.replace(":date", parameters[0]);
-	},
-	replaceBeforeOrEqual: function(payload) {
-		return this.replaceBefore(payload);
-	},
-	replaceBetween: function({ message, parameters }) {
-		const values = {
-			":min": parameters[0],
-			":max": parameters[1]
-		};
-		return message.replace(/:min|:max/gi, (matched) => values[matched]);
-	},
-	replaceDateEquals: function(payload) {
-		return this.replaceBefore(payload);
-	},
-	replaceDatetime: function({ message, parameters }) {
-		return message.replace(":format", parameters[0]);
-	},
-	replaceDeclinedIf: function({ message, parameters, data, getDisplayableAttribute }) {
-		const [other] = parameters;
-		const result = deepFind(data, other);
-		const values = {
-			":other": getDisplayableAttribute(other),
-			":value": result
-		};
-		return message.replace(/:other|:value/gi, (matched) => values[matched]);
-	},
-	replaceDifferent: function(payload) {
-		return this.replaceSame(payload);
-	},
-	replaceDigits: function({ message, parameters }) {
-		return message.replace(":digits", parameters[0]);
-	},
-	replaceDigitsBetween: function(payload) {
-		return this.replaceBetween(payload);
-	},
-	replaceEndsWith: function({ message, parameters }) {
-		return message.replace(":values", parameters.join(", "));
-	},
-	replaceExists: function({ message, parameters, data }) {
-		return message.replace(":value", data[parameters[1]]);
-	},
-	replaceIn: function({ message, parameters }) {
-		return message.replace(":values", parameters.join(", "));
-	},
-	replaceIncludes: function({ message, parameters }) {
-		return message.replace(":values", parameters.join(", "));
-	},
-	replaceStartsWith: function({ message, parameters }) {
-		return message.replace(":values", parameters.join(", "));
-	},
-	replaceMin: function({ message, parameters }) {
-		return message.replace(":min", parameters[0]);
-	},
-	replaceMax: function({ message, parameters }) {
-		return message.replace(":max", parameters[0]);
-	},
-	replaceNotIncludes: function({ message, parameters }) {
-		return message.replace(":values", parameters.join(", "));
-	},
-	replaceRequiredWith: function({ message, parameters, getDisplayableAttribute }) {
-		return message.replace(":values", parameters.map((attribute) => getDisplayableAttribute(attribute)).join(", "));
-	},
-	replaceRequiredWithAll: function(payload) {
-		return this.replaceRequiredWith(payload);
-	},
-	replaceRequiredWithout: function(payload) {
-		return this.replaceRequiredWith(payload);
-	},
-	replaceRequiredWithoutAll: function(payload) {
-		return this.replaceRequiredWith(payload);
-	},
-	replaceGt: function({ message, parameters, data, hasNumericRule }) {
-		const [value] = parameters;
-		const result = deepFind(data, value);
-		if (typeof result === "undefined") return message.replace(":value", value);
-		return message.replace(":value", getSize(result, hasNumericRule).toString());
-	},
-	replaceLt: function(payload) {
-		return this.replaceGt(payload);
-	},
-	replaceGte: function(payload) {
-		return this.replaceGt(payload);
-	},
-	replaceLte: function(payload) {
-		return this.replaceGt(payload);
-	},
-	replaceRequiredIf: function({ message, parameters, data, getDisplayableAttribute }) {
-		const [other] = parameters;
-		const result = deepFind(data, other);
-		const values = {
-			":other": getDisplayableAttribute(other),
-			":value": result
-		};
-		return message.replace(/:other|:value/gi, (matched) => values[matched]);
-	},
-	replaceRequiredUnless: function({ message, parameters, getDisplayableAttribute }) {
-		const [other] = parameters;
-		const values = {
-			":other": getDisplayableAttribute(other),
-			":values": parameters.slice(1).join(", ")
-		};
-		return message.replace(/:other|:values/gi, (matched) => values[matched]);
-	},
-	replaceSame: function({ message, parameters, getDisplayableAttribute }) {
-		return message.replace(":other", getDisplayableAttribute(parameters[0]));
-	},
-	replaceSize: function({ message, parameters }) {
-		return message.replace(":size", parameters[0]);
-	},
-	replaceUnique: function({ message, parameters, data }) {
-		return message.replace(":value", data[parameters[1]]);
-	}
-};
-
-//#endregion
-//#region src/Rules/closureValidationRule.ts
-var ClosureValidationRule = class extends IRuleContract {
+	anyFailingRequired(attributes) {
+		for (let i = 0; i < attributes.length; i++) if (!this.validateRequired(deepFind(this.data, attributes[i]))) return true;
+		return false;
+	}
 	/**
-	* The callback that validates the attribute
+	* Determine if all of the given attributes fail the required test.
 	*/
-	callback;
+	allFailingRequired(attributes) {
+		for (let i = 0; i < attributes.length; i++) if (this.validateRequired(deepFind(this.data, attributes[i]))) return false;
+		return true;
+	}
 	/**
-	* Indicates if the validation callback failed.
+	* Validate that an attribute is a string.
 	*/
-	failed = false;
-	constructor(callback) {
-		super();
-		this.callback = callback;
+	validateString(value) {
+		return typeof value === "string";
 	}
 	/**
-	* Determine if the validation rule passes.
+	* Validate the size of an attribute is less than a maximum value.
 	*/
-	passes(value, attribute) {
-		this.failed = false;
-		const result = this.callback(value, (message) => {
-			this.failed = true;
-			this.message = message;
-		}, attribute);
-		if (result instanceof Promise) return result.then(() => !this.failed);
-		return !this.failed;
+	validateMax(value, parameters, attribute) {
+		this.requireParameterCount(1, parameters, "max");
+		if (isNaN(parameters[0])) throw "Validation rule max requires parameter to be a number.";
+		return getSize(value, validationRuleParser.hasRule(attribute, getNumericRules(), this.rules)) <= Number(parameters[0]);
 	}
-};
-
-//#endregion
-//#region src/validators/validationData.ts
-const validationData = {
-	initializeAndGatherData: function(attribute, masterData) {
-		const data = dotify(this.initializeAttributeOnData(attribute, masterData));
-		return {
-			...data,
-			...this.extractValuesFromWildCards(masterData, data, attribute)
-		};
-	},
-	initializeAttributeOnData: function(attribute, masterData) {
-		const explicitPath = this.getLeadingExplicitAttributePath(attribute);
-		const data = this.extractDataFromPath(explicitPath, JSON.parse(JSON.stringify(masterData)));
-		if (attribute.indexOf("*") === -1 || attribute.indexOf("*") === attribute.length - 1) return data;
-		deepSet(data, attribute, null);
-		return data;
-	},
-	extractValuesFromWildCards(masterData, data, attribute) {
-		const keys = [];
-		const pattern = new RegExp("^" + attribute.replace(/\*/g, "[^\\.]*"));
-		let result = null;
-		for (const key in data) {
-			result = key.match(pattern);
-			if (result) keys.push(result[0]);
-		}
-		data = {};
-		keys.forEach((key) => data[key] = deepFind(masterData, key));
-		return data;
-	},
-	getLeadingExplicitAttributePath: function(attribute) {
-		return attribute.split("*")[0].replace(/\.$/, "");
-	},
-	extractDataFromPath(path, masterData) {
-		const results = {};
-		const value = deepFind(masterData, path);
-		if (value !== void 0) deepSet(results, path, value);
-		return results;
+	/**
+	* Validate the size of an attribute is greater than a minimum value.
+	*/
+	validateMin(value, parameters, attribute) {
+		this.requireParameterCount(1, parameters, "min");
+		if (isNaN(parameters[0])) throw "Validation rule min requires parameter to be a number.";
+		return getSize(value, validationRuleParser.hasRule(attribute, getNumericRules(), this.rules)) >= Number(parameters[0]);
 	}
-};
-
-//#endregion
-//#region src/validators/validationRuleParser.ts
-const validationRuleParser = {
-	explodeRules: function(rules, data = {}) {
-		const implicitAttributes = {};
-		for (const key in rules) if (key.indexOf("*") !== -1) {
-			rules = this.explodeWildCardRules(rules, key, data, implicitAttributes);
-			delete rules[key];
-		} else if (Object.prototype.hasOwnProperty.call(rules, key) && Array.isArray(rules)) rules[Number(key)] = this.explodeExplicitRules(rules[Number(key)]);
-		else if (Object.prototype.hasOwnProperty.call(rules, key) && !Array.isArray(rules)) rules[key] = this.explodeExplicitRules(rules[key]);
-		return {
-			rules,
-			implicitAttributes
-		};
-	},
-	explodeWildCardRules: function(results, attribute, masterData, implicitAttributes) {
-		const pattern = new RegExp("^" + attribute.replace(/\*/g, "[^.]*") + "$");
-		const data = validationData.initializeAndGatherData(attribute, masterData);
-		const rule = results[attribute];
-		for (const key in data) if (key.slice(0, attribute.length) === attribute || key.match(pattern) !== null) {
-			if (Array.isArray(implicitAttributes[attribute])) implicitAttributes[attribute].push(key);
-			else implicitAttributes[attribute] = [key];
-			results = this.mergeRulesForAttribute(results, key, rule);
-		}
-		return results;
-	},
-	mergeRulesForAttribute(results, attribute, rules) {
-		const merge = this.explodeRules([rules]).rules[0];
-		results[attribute] = [...results[attribute] ? this.explodeExplicitRules(results[attribute]) : [], ...merge];
-		return results;
-	},
-	explodeExplicitRules: function(rules) {
-		if (typeof rules === "string") return rules.split("|");
-		if (!Array.isArray(rules)) return [this.prepareRule(rules)];
-		return rules.map((rule) => this.prepareRule(rule));
-	},
-	prepareRule(rule) {
-		if (rule instanceof IRuleContract) return rule;
-		if (typeof rule === "function") return new ClosureValidationRule(rule);
-		return rule.toString();
-	},
-	parse(rule) {
-		if (rule instanceof IRuleContract) return [rule, []];
-		return this.parseStringRule(rule);
-	},
-	parseStringRule: function(rule) {
-		let parameters = [];
-		let parameter;
-		if (rule.indexOf(":") !== -1) {
-			[rule, parameter] = rule.split(/:(.+)/);
-			parameters = parameter.split(",");
-		}
-		return [rule, parameters];
-	},
-	getRule: function(attribute, searchRules, availableRules) {
-		if (!availableRules[attribute]) return [];
-		searchRules = Array.isArray(searchRules) ? searchRules : [searchRules];
-		for (let i = 0; i < availableRules[attribute].length; i++) {
-			const [rule, parameters] = this.parse(availableRules[attribute][i]);
-			if (searchRules.indexOf(rule) !== -1) return [rule, parameters];
-		}
-		return [];
-	},
-	hasRule: function(attribute, searchRules, availableRules) {
-		return this.getRule(attribute, searchRules, availableRules).length > 0;
+	/**
+	* Validate that an attribute is numeric.
+	*/
+	validateNumeric(value, parameters, attribute) {
+		if (validationRuleParser.hasRule(attribute, "strict", this.rules) && typeof value !== "number") return false;
+		return value !== null && isNaN(value) === false;
 	}
-};
-
-//#endregion
-//#region src/validators/validateAttributes.ts
-var validateAttributes = class {
 	/**
-	* Stores the data object
+	* Validate that an attribute is an object
 	*/
-	data;
+	validateObject(value) {
+		return isObject(value);
+	}
 	/**
-	* Stores the rules object
+	* Validate that an attribute exists even if not filled.
 	*/
-	rules;
-	constructor(data = {}, rules = {}) {
-		this.data = data;
-		this.rules = rules;
+	validatePresent(value, parameters, attribute) {
+		return typeof deepFind(this.data, attribute) !== "undefined";
 	}
 	/**
-	* Validate that an attribute was "accepted".
-	*
-	* This validation rule implies the attribute is "required".
+	* Validate that an attribute is an integer.
 	*/
-	validateAccepted(value) {
-		return this.validateRequired(value) && [
-			"yes",
-			"on",
-			"1",
-			1,
-			true,
-			"true"
-		].indexOf(value) !== -1;
+	validateInteger(value, parameters, attribute) {
+		if (validationRuleParser.hasRule(attribute, "strict", this.rules) && typeof value !== "number") return false;
+		return isInteger(value);
 	}
 	/**
-	* Validate that an attribute was "accepted" when another attribute has a given value.
+	* Validate that the attribute is a valid JSON string
 	*/
-	validateAcceptedIf(value, parameters) {
-		this.requireParameterCount(2, parameters, "accepted_if");
-		const other = deepFind(this.data, parameters[0]);
-		if (!other) return true;
-		if (parameters.slice(1).indexOf(other) !== -1) return this.validateAccepted(value);
+	validateJson(value) {
+		if (!value || typeof value !== "string") return false;
+		try {
+			JSON.parse(value);
+		} catch {
+			return false;
+		}
 		return true;
 	}
 	/**
-	*  Validate the date is after a given date.
+	* Validate that an attribute is greater than another attribute.
 	*/
-	validateAfter(value, parameters) {
-		this.requireParameterCount(1, parameters, "after");
-		return this.compareDates(value, parameters[0], ">", "after");
+	validateGt(value, parameters, attribute) {
+		this.requireParameterCount(1, parameters, "gt");
+		if (typeof value !== "number" && typeof value !== "string" && typeof value !== "object") throw "The field under validation must be a number, string, array or object";
+		const compartedToValue = deepFind(this.data, parameters[0]) || parameters[0];
+		if (!Array.isArray(compartedToValue) && isNaN(compartedToValue) === false) return getSize(value, validationRuleParser.hasRule(attribute, getNumericRules(), this.rules)) > compartedToValue;
+		if (sameType(value, compartedToValue) === false) throw "The fields under validation must be of the same type";
+		return getSize(value) > getSize(compartedToValue);
 	}
 	/**
-	* Validate the date is after or equal a given date.
+	* Validate that an attribute is greater than or equal  another attribute.
 	*/
-	validateAfterOrEqual(value, parameters) {
-		this.requireParameterCount(1, parameters, "after_or_equal");
-		return this.compareDates(value, parameters[0], ">=", "after_or_equal");
+	validateGte(value, parameters, attribute) {
+		this.requireParameterCount(1, parameters, "gte");
+		if (typeof value !== "number" && typeof value !== "string" && typeof value !== "object") throw "The field under validation must be a number, string, array or object";
+		const compartedToValue = deepFind(this.data, parameters[0]) || parameters[0];
+		if (!Array.isArray(compartedToValue) && isNaN(compartedToValue) === false) return getSize(value, validationRuleParser.hasRule(attribute, getNumericRules(), this.rules)) >= compartedToValue;
+		if (sameType(value, compartedToValue) === false) throw "The fields under validation must be of the same type";
+		return getSize(value) >= getSize(compartedToValue);
 	}
 	/**
-	* Validate that an attribute contains only alphabetic characters.
+	* Validate that an attribute is less than another attribute.
 	*/
-	validateAlpha(value) {
-		return typeof value === "string" && /^[a-zA-Z]+$/.test(value);
+	validateLt(value, parameters, attribute) {
+		this.requireParameterCount(1, parameters, "lt");
+		if (typeof value !== "number" && typeof value !== "string" && typeof value !== "object") throw "The field under validation must be a number, string, array or object";
+		const compartedToValue = deepFind(this.data, parameters[0]) || parameters[0];
+		if (!Array.isArray(compartedToValue) && isNaN(compartedToValue) === false) return getSize(value, validationRuleParser.hasRule(attribute, getNumericRules(), this.rules)) < compartedToValue;
+		if (sameType(value, compartedToValue) === false) throw "The fields under validation must be of the same type";
+		return getSize(value) < getSize(compartedToValue);
+	}
+	/**
+	* Validate that an attribute is less than or equal another attribute.
+	*/
+	validateLte(value, parameters, attribute) {
+		this.requireParameterCount(1, parameters, "lte");
+		if (typeof value !== "number" && typeof value !== "string" && typeof value !== "object") throw "The field under validation must be a number, string, array or object";
+		const compartedToValue = deepFind(this.data, parameters[0]) || parameters[0];
+		if (!Array.isArray(compartedToValue) && isNaN(compartedToValue) === false) return getSize(value, validationRuleParser.hasRule(attribute, getNumericRules(), this.rules)) <= compartedToValue;
+		if (sameType(value, compartedToValue) === false) throw "The fields under validation must be of the same type";
+		return getSize(value) <= getSize(compartedToValue);
+	}
+	/**
+	* Validate an attribute is contained within a list of values.
+	*/
+	validateIn(value, parameters) {
+		this.requireParameterCount(1, parameters, "in");
+		if (Array.isArray(value)) {
+			for (let index = 0; index < value.length; index++) if (typeof value[index] !== "number" && typeof value[index] !== "string") return false;
+			return value.filter((element) => parameters.indexOf(element.toString()) === -1).length === 0;
+		}
+		if (typeof value !== "number" && typeof value !== "string") return false;
+		return parameters.indexOf(value.toString()) !== -1;
 	}
 	/**
-	* Validate that an attribute contains only alpha-numeric characters, dashes, and underscores.
+	* "Indicate" validation should pass if value is null
+	*
+	* Always returns true, just lets us put "nullable" in rules.
 	*/
-	validateAlphaDash(value) {
-		if (typeof value != "string" && typeof value != "number") return false;
-		return /^(?=.*[a-zA-Z0-9])[a-zA-Z0-9-_]+$/.test(value.toString());
+	validateNullable() {
+		return true;
 	}
 	/**
-	* Validate that an attribute contains only alpha-numeric characters.
+	* Validate an attribute is not contained within a list of values.
 	*/
-	validateAlphaNum(value) {
-		if (typeof value != "string" && typeof value != "number") return false;
-		return /^[a-zA-Z0-9]+$/.test(value.toString());
+	validateNotIn(value, parameters) {
+		this.requireParameterCount(1, parameters, "not_in");
+		const valuesToCheck = [];
+		if (Array.isArray(value)) {
+			for (let index = 0; index < value.length; index++) if (typeof value[index] === "number" || typeof value[index] === "string") valuesToCheck.push(value[index]);
+			if (valuesToCheck.length === 0) return true;
+			return valuesToCheck.filter((element) => parameters.indexOf(element.toString()) !== -1).length === 0;
+		}
+		if (typeof value !== "number" && typeof value !== "string") return true;
+		return parameters.indexOf(value.toString()) === -1;
 	}
 	/**
-	* Validate that an attribute is an array
+	* Always returns true - this method will be used in conbination with other rules
 	*/
-	validateArray(value) {
-		return Array.isArray(value);
+	validateStrict() {
+		return true;
 	}
 	/**
-	* Validate that an attribute is an array and that his values are unique
+	* Validate that an attribute is a valid URL.
 	*/
-	validateArrayUnique(value) {
-		if (!Array.isArray(value)) return false;
-		return new Set(value).size === value.length;
+	validateUrl(value) {
+		if (typeof value !== "string") return false;
+		return new RegExp("^(https?:\\/\\/)?((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|localhost|((\\d{1,3}\\.){3}\\d{1,3}))(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*(\\?[;&a-z\\d%_.~+=-]*)?(\\#[-a-z\\d_]*)?$", "i").test(value);
 	}
 	/**
-	* Always returns true - this method will be used in conbination with other rules and will be used to stop validation of first failure
+	*  Determine if a comparison passes between the given values.
 	*/
-	validateBail() {
-		return true;
+	compareDates(value, parameter, operator, rule) {
+		value = toDate(value);
+		if (!value) throw `Validation rule ${rule} requires the field under valation to be a date.`;
+		const compartedToValue = toDate(deepFind(this.data, parameter) || parameter);
+		if (!compartedToValue) throw `Validation rule ${rule} requires the parameter to be a date.`;
+		return compare(value.getTime(), compartedToValue.getTime(), operator);
 	}
 	/**
-	*  Validate the date is before a given date.
+	* Require a certain number of parameters to be present
 	*/
-	validateBefore(value, parameters) {
-		this.requireParameterCount(1, parameters, "before");
-		return this.compareDates(value, parameters[0], "<", "before");
+	requireParameterCount(count, parameters, rule) {
+		if (parameters.length < count) throw `Validation rule ${rule} requires at least ${count} parameters.`;
 	}
 	/**
-	* Validate the date is before or equal a given date.
+	* Prepare the values for validation
 	*/
-	validateBeforeOrEqual(value, parameters) {
-		this.requireParameterCount(1, parameters, "before_or_equal");
-		return this.compareDates(value, parameters[0], "<=", "before_or_equal");
+	parseDependentRuleParameters(other, parameters) {
+		let values = parameters.slice(1);
+		if (other === null) values = convertValuesToNull(values);
+		if (typeof other === "number") values = convertValuesToNumber(values);
+		if (typeof other === "boolean") values = convertValuesToBoolean(values);
+		return values;
 	}
-	/**
-	* Validate the size of an attribute is between a set of values
-	*/
-	validateBetween(value, parameters, attribute) {
-		if (typeof value !== "string" && typeof value !== "number" && typeof value !== "object") throw "Validation rule between requires the field under validation to be a number, string, array, or object.";
-		this.requireParameterCount(2, parameters, "between");
-		let [min, max] = parameters;
-		if (isNaN(min) || isNaN(max)) throw "Validation rule between requires both parameters to be numbers.";
-		min = Number(min);
-		max = Number(max);
-		if (min >= max) throw "Validation rule between requires that the first parameter be greater than the second one.";
-		const size = getSize(value, validationRuleParser.hasRule(attribute, getNumericRules(), this.rules));
-		return size >= min && size <= max;
+};
+
+//#endregion
+//#region src/Rules/registerRule.ts
+function register(rule, validate, replaceMessage) {
+	const method = buildValidationMethodName(rule);
+	if (new validateAttributes()[`validate${method}`]) return false;
+	validateAttributes.prototype[`validate${method}`] = validate;
+	if (typeof replaceMessage === "function") replaceAttributes[`replace${method}`] = ({ message, parameters, data, getDisplayableAttribute }) => replaceMessage(message, parameters, data, getDisplayableAttribute);
+	return true;
+}
+function registerImplicit(rule, validate, replaceMessage) {
+	if (register(rule, validate, replaceMessage) === true) addImplicitRule(rule);
+}
+
+//#endregion
+//#region src/Plugin.ts
+const valueInspectors = [];
+const api = {
+	registerRule: register,
+	registerImplicitRule: registerImplicit,
+	registerValueInspector,
+	extendTranslations: (translations) => {
+		Lang.extendTranslationObject(translations);
+	}
+};
+function definePlugin(plugin) {
+	return plugin;
+}
+function usePlugin(plugin) {
+	plugin.install(api);
+}
+function registerValueInspector(inspector) {
+	const existing = valueInspectors.findIndex((candidate) => candidate.type === inspector.type);
+	if (existing >= 0) {
+		valueInspectors.splice(existing, 1, inspector);
+		return;
+	}
+	valueInspectors.push(inspector);
+}
+function getValidationValueInspector(value) {
+	return valueInspectors.find((inspector) => inspector.matches(value));
+}
+function getValidationMessageType(value, hasNumericRule = false) {
+	if (typeof value === "number" || typeof value === "undefined" || isNaN(value) === false && hasNumericRule === true) return "number";
+	const inspector = getValidationValueInspector(value);
+	if (inspector) return inspector.type;
+	if (Array.isArray(value)) return "array";
+	return typeof value;
+}
+function getValidationSize(value, hasNumericRule = false) {
+	if (typeof value === "number" || isNaN(value) === false && hasNumericRule === true) return Number(value);
+	const inspector = getValidationValueInspector(value);
+	if (inspector?.size) return inspector.size(value);
+	if (typeof value === "string" || Array.isArray(value)) return value.length;
+	if (typeof value === "object" && value !== null) return Object.keys(value).length;
+	return -1;
+}
+
+//#endregion
+//#region src/utilities/general.ts
+const implicitRues = [
+	"accepted",
+	"accepted_if",
+	"declined",
+	"declined_if",
+	"filled",
+	"present",
+	"required",
+	"required_if",
+	"required_unless",
+	"required_with",
+	"required_with_all",
+	"required_without",
+	"required_without_all"
+];
+/**
+* Get the size of a value based on its type
+*/
+function getSize(value, hasNumericRule = false) {
+	return getValidationSize(value, hasNumericRule);
+}
+/**
+* Check if two values are of the same type
+*/
+function sameType(value, otherValue) {
+	return (Array.isArray(value) ? "array" : value === null ? null : typeof value) === (Array.isArray(otherValue) ? "array" : otherValue === null ? null : typeof otherValue);
+}
+/**
+* Check if Value is an Ineteger
+*/
+function isInteger(value) {
+	return value !== null && isNaN(value) === false && value % 1 === 0;
+}
+/**
+* Check if the value can be considered as rule
+*/
+function isRule(value) {
+	return typeof value === "string" || typeof value === "function" || value instanceof IRuleContract || value instanceof BaseRule;
+}
+/**
+* Check if the array contain any potentiel valid rule
+*/
+function isArrayOfRules(values) {
+	for (let i = 0; i < values.length; i++) if (isRule(values[i])) return true;
+	return false;
+}
+/**
+* Check if the rule is related to size
+*/
+function isSizeRule(rule) {
+	return [
+		"size",
+		"between",
+		"min",
+		"max",
+		"gt",
+		"lt",
+		"gte",
+		"lte"
+	].indexOf(rule) !== -1;
+}
+/**
+* Check if rule implies that the field is required
+*/
+function isImplicitRule(rule) {
+	if (rule instanceof IRuleContract && rule.__isImplicitRule === true) return true;
+	if (typeof rule === "string") return implicitRues.indexOf(rule) !== -1;
+	return false;
+}
+/**
+* Add a new implicit rule
+*/
+function addImplicitRule(rule) {
+	implicitRues.push(rule);
+}
+/**
+* Returns the numeric rules
+*/
+function getNumericRules() {
+	return ["numeric", "integer"];
+}
+/**
+* Check if the rule is numeric
+*/
+function isNumericRule(rule) {
+	return getNumericRules().indexOf(rule) !== -1;
+}
+/**
+* Determine if a comparison passes between the given values.
+*/
+function compare(first, second, operator, strict = false) {
+	switch (operator) {
+		case "<": return first < second;
+		case ">": return first > second;
+		case "<=": return first <= second;
+		case ">=": return first >= second;
+		case "=":
+			if (strict === true) return first === second;
+			return first == second;
+		default: throw "Invalid operator parameter";
+	}
+}
+/**
+* Convert the given values to boolean if they are string "true" / "false".
+*/
+function convertValuesToBoolean(values) {
+	return values.map((value) => {
+		if (value === "true") return true;
+		else if (value === "false") return false;
+		return value;
+	});
+}
+/**
+* Convert the given values to numbers if they are numbers in a string "1", "2"
+*/
+function convertValuesToNumber(values) {
+	return values.map((value) => {
+		if (!isNaN(Number(value))) return Number(value);
+		return value;
+	});
+}
+/**
+* Convert the given values to null if they have null values in a string "null", "NULL"
+*/
+function convertValuesToNull(values) {
+	return values.map((value) => {
+		if (value.toLowerCase() === "null") return null;
+		return value;
+	});
+}
+
+//#endregion
+//#region src/utilities/object.ts
+/**
+* Get value at path of object. If the resolved value is undifined, the returned result will be undefined
+* 
+* @param obj 
+* @param path 
+* @returns 
+*/
+function deepFind(obj, path) {
+	const paths = path.split(".");
+	for (let i = 0; i < paths.length; i++) {
+		if (typeof obj[paths[i]] === "undefined") return;
+		obj = obj[paths[i]];
 	}
-	/**
-	* Validate that an attribute is boolean
-	*/
-	validateBoolean(value, parameters, attribute) {
-		if (validationRuleParser.hasRule(attribute, "strict", this.rules)) return typeof value === "boolean";
-		return [
-			true,
-			false,
-			0,
-			1,
-			"0",
-			"1"
-		].indexOf(value) !== -1;
+	return obj;
+}
+/**
+* Set value at path of object. 
+* 
+* @param target 
+* @param path 
+* @param value 
+*/
+function deepSet(target, path, value) {
+	const paths = typeof path === "string" ? path.split(".") : path;
+	const segment = paths.shift();
+	if (segment === "*") {
+		target = Array.isArray(target) ? target : [];
+		if (paths.length > 0) target.forEach((inner) => deepSet(inner, [...paths], value));
+		else for (let i = 0; i < target.length; i++) target[i] = value;
+	} else if (paths.length > 0 && typeof segment === "string") {
+		if (typeof target[segment] !== "object" || target[segment] === null) target[segment] = {};
+		deepSet(target[segment], paths, value);
+	} else {
+		if (typeof target !== "object" || target === null) target = {};
+		target[segment] = value;
 	}
-	/**
-	* Validate that an attribute has matching confirmation.
-	*/
-	validateConfirmed(value, parameters, attribute) {
-		return this.validateSame(value, [`${attribute}_confirmation`]) || this.validateSame(value, [`${attribute}Confirmation`]);
+}
+/**
+* Flatten a multi-dimensional associative array with dots.
+* 
+* @param obj 
+* @param ignoreRulesArray 
+* @param withBaseObjectType 
+* @returns 
+*/
+function dotify(obj, ignoreRulesArray = false, withBaseObjectType = false) {
+	const res = {};
+	(function recurse(obj, current = "") {
+		for (const key in obj) {
+			const value = obj[key];
+			const newKey = current ? `${current}.${key}` : key;
+			if (value && typeof value === "object" && !isRule(value) && !(value instanceof Date)) if (ignoreRulesArray === true && Array.isArray(value) && isArrayOfRules(value)) res[newKey] = value;
+			else {
+				if (withBaseObjectType) res[newKey] = Array.isArray(value) ? "array" : "object";
+				recurse(value, newKey);
+			}
+			else res[newKey] = value;
+		}
+	})(obj);
+	return res;
+}
+/**
+* Check if objects are deep equal
+* 
+* @param firstParam 
+* @param secondParam 
+* @returns 
+*/
+function deepEqual(firstParam, secondParam) {
+	const first = dotify(firstParam, false, true);
+	const second = dotify(secondParam, false, true);
+	if (Object.keys(first).length !== Object.keys(second).length) return false;
+	return Object.entries(first).every(([key, value]) => second[key] === value);
+}
+
+//#endregion
+//#region src/utilities/formatMessages.ts
+/**
+* Get the message type based on the value. The message type is used essentially for size rules
+*/
+function getMesageType(value, hasNumericRule = false) {
+	return getValidationMessageType(value, hasNumericRule);
+}
+/**
+* Get the custom message for a rule if exists
+*/
+function getCustomMessage(attributes, rule, customMessages, messageType, lang) {
+	const [attribute, primaryAttribute] = attributes;
+	const translatedMessages = dotify(Lang.get(lang)["custom"] || {});
+	const keys = getKeyCombinations(`${attribute}.${rule}`);
+	let allKeys = keys;
+	if (primaryAttribute) {
+		allKeys = [];
+		const primaryAttributeKeys = getKeyCombinations(`${primaryAttribute}.${rule}`);
+		for (let i = 0; i < keys.length; i++) {
+			allKeys.push(keys[i]);
+			if (keys[i] !== primaryAttributeKeys[i]) allKeys.push(primaryAttributeKeys[i]);
+		}
 	}
-	/**
-	* Validate that an attribute is a valid date.
-	*/
-	validateDate(value) {
-		return toDate(value) ? true : false;
+	if (isSizeRule(rule)) {
+		allKeys.pop();
+		allKeys.push(`${rule}.${messageType}`);
+		allKeys.push(rule);
 	}
-	/**
-	* Validate that an attribute is equal to another date.
-	*/
-	validateDateEquals(value, paramters) {
-		this.requireParameterCount(1, paramters, "date_equals");
-		return this.compareDates(value, paramters[0], "=", "date_equals");
+	let key = "";
+	let message = "";
+	for (let i = 0; i < allKeys.length; i++) {
+		key = allKeys[i];
+		if (Object.prototype.hasOwnProperty.call(customMessages, key)) return customMessages[key];
+		message = translatedMessages[key];
+		if (typeof message === "string") return message;
+	}
+	return null;
+}
+/**
+* Get the validation message for an attribute and rule.
+*/
+function getMessage(attributes, rule, value, customMessages, hasNumericRule, lang) {
+	const inlineMessage = getCustomMessage(attributes, rule, customMessages, getMesageType(value, hasNumericRule), lang);
+	if (inlineMessage) return inlineMessage;
+	const validationMessages = Lang.get(lang);
+	if (isSizeRule(rule) === true) return validationMessages[rule][getMesageType(value, hasNumericRule)];
+	return validationMessages[rule] || "";
+}
+/**
+* Convert a string to snake case.
+*/
+function toSnakeCase(string) {
+	return string.split(/ |\B(?=[A-Z])/).map((word) => word.toLowerCase()).join("_");
+}
+/**
+* Get the formatted name of the attribute
+*/
+function getFormattedAttribute(attribute) {
+	return toSnakeCase(getPrimaryKeyFromPath(attribute)).replace(/_/g, " ").trim();
+}
+/**
+* Get the combinations of keys from a main key. For example if the main key is 'user.info.name',
+* the combination will be [user.info.name, info.name, name]
+*/
+function getKeyCombinations(key) {
+	const combinations = [key];
+	const splittedKey = key.split(".");
+	while (splittedKey.length > 1) {
+		splittedKey.shift();
+		combinations.push(splittedKey.join("."));
 	}
+	return combinations;
+}
+/**
+* The purpose of this method if to get the primary key associated with a path
+* For example the primary key for path 'user.info.email' will be 'email'
+*/
+function getPrimaryKeyFromPath(path) {
+	const splittedPath = path.split(".");
+	if (splittedPath.length <= 1) return path;
+	const key = splittedPath.pop();
+	if (isNaN(parseInt(key)) === false) return getPrimaryKeyFromPath(splittedPath.join("."));
+	return key;
+}
+
+//#endregion
+//#region src/validators/errorBag.ts
+var ErrorBag = class ErrorBag {
 	/**
-	* Validate that an attribute was "declined".
-	*
-	* This validation rule implies the attribute is "required".
+	* All of the registered messages.
 	*/
-	validateDeclined(value) {
-		return this.validateRequired(value) && [
-			"no",
-			"off",
-			"0",
-			0,
-			false,
-			"false"
-		].indexOf(value) !== -1;
-	}
+	errors = {};
 	/**
-	* Validate that an attribute was "declined" when another attribute has a given value.
+	* All Messages
 	*/
-	validateDeclinedIf(value, parameters) {
-		this.requireParameterCount(2, parameters, "declined_if");
-		const other = deepFind(this.data, parameters[0]);
-		if (!other) return true;
-		if (parameters.slice(1).indexOf(other) !== -1) return this.validateDeclined(value);
-		return true;
-	}
+	messages = {};
 	/**
-	* Validate that an attribute is different from another attribute.
+	* Stores the first error message
 	*/
-	validateDifferent(value, parameters) {
-		this.requireParameterCount(1, parameters, "different");
-		const other = deepFind(this.data, parameters[0]);
-		if (!sameType(value, other)) return true;
-		if (value !== null && typeof value === "object") return !deepEqual(value, other);
-		return value !== other;
-	}
+	firstMessage = "";
 	/**
-	*  Validate that an attribute has a given number of digits.
+	* Specify whether error types should be returned or no
 	*/
-	validateDigits(value, parameters) {
-		this.requireParameterCount(1, parameters, "digits");
-		if (isInteger(parameters[0]) === false) throw "Validation rule digits requires the parameter to be an integer.";
-		if (parameters[0] <= 0) throw "Validation rule digits requires the parameter to be an integer greater than 0.";
-		if (typeof value !== "string" && typeof value !== "number") return false;
-		value = value.toString();
-		return /^\d+$/.test(value) && value.length === parseInt(parameters[0]);
+	withErrorTypes = false;
+	constructor(errors = {}, messages = {}, firstMessage = "", withErrorTypes = false) {
+		this.errors = errors;
+		this.messages = messages;
+		this.firstMessage = firstMessage;
+		this.withErrorTypes = withErrorTypes;
 	}
 	/**
-	* Validate that an attribute is between a given number of digits.
+	* Set withErrorTypes attribute to true
 	*/
-	validateDigitsBetween(value, parameters) {
-		this.requireParameterCount(2, parameters, "digits_between");
-		let [min, max] = parameters;
-		if (isInteger(min) === false || isInteger(max) === false) throw "Validation rule digits_between requires both parameters to be integers.";
-		min = parseInt(min);
-		max = parseInt(max);
-		if (min <= 0 || max <= 0) throw "Validation rule digits_between requires the parameters to be an integer greater than 0.";
-		if (min >= max) throw "Validation rule digits_between requires the max param to be greater than the min param.";
-		if (typeof value !== "string" && typeof value !== "number") return false;
-		value = value.toString();
-		const valueLength = value.length;
-		return /^\d+$/.test(value) && valueLength >= min && valueLength <= max;
+	addErrorTypes() {
+		this.withErrorTypes = true;
+		return this;
 	}
 	/**
-	* Validate that an attribute is a valid email address.
+	* Add new recodrs to the errors and messages objects
 	*/
-	validateEmail(value) {
-		if (typeof value !== "string") return false;
-		/**
-		* Max allowed length for a top-level-domain is 24 characters.
-		* reference to list of top-level-domains: https://data.iana.org/TLD/tlds-alpha-by-domain.txt
-		*/
-		return value.toLowerCase().match(/^\w+([.-]?\w+)*@\w+([.-]?\w+)*(\.\w{2,24})+$/) !== null;
+	add(key, error) {
+		if (Array.isArray(this.errors[key]) && Array.isArray(this.messages[key])) {
+			this.errors[key].push(error);
+			this.messages[key].push(error.message);
+		} else {
+			this.errors[key] = [error];
+			this.messages[key] = [error.message];
+		}
+		this.firstMessage = this.firstMessage || error.message;
 	}
 	/**
-	* Validate the attribute ends with a given substring.
+	* Get the first error related to a specific key
 	*/
-	validateEndsWith(value, parameters) {
-		this.requireParameterCount(1, parameters, "ends_with");
-		if (typeof value !== "string") throw "The field under validation must be a string";
-		const valueLength = value.length;
-		for (let i = 0; i < parameters.length; i++) if (typeof parameters[i] === "string" && value.indexOf(parameters[i], valueLength - parameters[i].length) !== -1) return true;
-		return false;
+	first(key = null) {
+		if (!key) return this.firstMessage;
+		if (this.has(key)) return this.messages[key][0];
+		return "";
 	}
 	/**
-	* Validate that two attributes match.
+	* Get the error messages keys
 	*/
-	validateSame(value, paramaters) {
-		this.requireParameterCount(1, paramaters, "same");
-		const other = deepFind(this.data, paramaters[0]);
-		if (!sameType(value, other)) return false;
-		if (value !== null && typeof value === "object") return deepEqual(value, other);
-		return value === other;
+	keys() {
+		return Object.keys(this.messages);
 	}
 	/**
-	* Validate the size of an attribute.
+	* Get all the messages related to a specific key
 	*/
-	validateSize(value, parameters, attribute) {
-		this.requireParameterCount(1, parameters, "size");
-		return getSize(value, validationRuleParser.hasRule(attribute, getNumericRules(), this.rules)) === Number(parameters[0]);
+	get(key, withErrorTypes = this.withErrorTypes) {
+		if (!this.has(key)) return [];
+		if (withErrorTypes) return this.errors[key];
+		return this.messages[key];
 	}
 	/**
-	* Validate Optinial attributes. Always return true, just lets us put sometimes in rule.
+	* Check if key exists in messages
 	*/
-	validateSometimes() {
-		return true;
+	has(key) {
+		return this.messages[key] && this.messages[key].length > 0 ? true : false;
 	}
 	/**
-	* Validate the attribute starts with a given substring.
+	* Get all error messages
 	*/
-	validateStartsWith(value, parameters) {
-		this.requireParameterCount(1, parameters, "starts_with");
-		if (typeof value !== "string") throw "The field under validation must be a string";
-		for (let i = 0; i < parameters.length; i++) if (typeof parameters[i] === "string" && value.substr(0, parameters[i].length) === parameters[i]) return true;
-		return false;
+	all(allMessages = true, withErrorTypes = this.withErrorTypes) {
+		const messages = withErrorTypes ? { ...this.errors } : { ...this.messages };
+		if (!allMessages) Object.keys(messages).map((attribute) => messages[attribute] = messages[attribute][0]);
+		return messages;
 	}
 	/**
-	* Validate that a required attribute exists
+	* Remove error messages
 	*/
-	validateRequired(value) {
-		if (value === null || typeof value === "undefined") return false;
-		else if (typeof value === "string" && value.trim() === "") return false;
-		else if (Array.isArray(value) && value.length < 1) return false;
-		else if (typeof value === "object" && Object.keys(value).length < 1) return false;
-		return true;
+	clear(keys) {
+		if (keys.length === 0) {
+			this.errors = {};
+			this.messages = {};
+			this.firstMessage = "";
+			return this;
+		}
+		keys.forEach((key) => {
+			if (Object.prototype.hasOwnProperty.call(this.messages, key)) {
+				delete this.messages[key];
+				delete this.errors[key];
+			}
+		});
+		this.firstMessage = "";
+		if (this.keys().length > 0) this.firstMessage = this.messages[Object.keys(this.messages)[0]][0];
+		return this;
 	}
 	/**
-	* Validate that an attribute exists when another atteribute has a given value
+	* Clone ErrorBag Instance
 	*/
-	validateRequiredIf(value, parameters) {
-		this.requireParameterCount(2, parameters, "required_if");
-		const other = deepFind(this.data, parameters[0]);
-		if (typeof other === "undefined") return true;
-		if (this.parseDependentRuleParameters(other, parameters).indexOf(other) !== -1) return this.validateRequired(value);
-		return true;
+	clone() {
+		return new ErrorBag({ ...this.errors }, { ...this.messages }, this.firstMessage, this.withErrorTypes);
 	}
+};
+
+//#endregion
+//#region src/Rules/password.ts
+var Password$1 = class Password$1 extends IRuleContract {
 	/**
-	* Validate that an attribute exists when another attribute does not have a given value.
+	* The validator performing the validation.
 	*/
-	validateRequiredUnless(value, parameters) {
-		this.requireParameterCount(2, parameters, "required_unless");
-		let other = deepFind(this.data, parameters[0]);
-		other = typeof other === "undefined" ? null : other;
-		if (this.parseDependentRuleParameters(other, parameters).indexOf(other) === -1) return this.validateRequired(value);
-		return true;
-	}
+	validator;
 	/**
-	* Validate that an attribute exists when any other attribute exists.
+	* The minimum size of the password.
 	*/
-	validateRequiredWith(value, parameters) {
-		if (!this.allFailingRequired(parameters)) return this.validateRequired(value);
-		return true;
-	}
+	minLength = 8;
 	/**
-	* Validate that an attribute exists when all other attributes exist.
+	* The min amount of lower case letters required in the password 
 	*/
-	validateRequiredWithAll(value, parameters) {
-		if (!this.anyFailingRequired(parameters)) return this.validateRequired(value);
-		return true;
-	}
+	minLowerCase = 0;
 	/**
-	* Validate that an attribute exists when another attribute does not.
+	* The min amount of uppercase letters required in the password
 	*/
-	validateRequiredWithout(value, parameters) {
-		if (this.anyFailingRequired(parameters)) return this.validateRequired(value);
-		return true;
-	}
+	minUpperCase = 0;
 	/**
-	* Validate that an attribute exists when all other attributes do not.
+	* The min amount of letters required in the password
 	*/
-	validateRequiredWithoutAll(value, parameters) {
-		if (this.allFailingRequired(parameters)) return this.validateRequired(value);
-		return true;
-	}
+	minLetters = 0;
 	/**
-	* Determine if any of the given attributes fail the required test.
+	* The min amount of letters required in the password
 	*/
-	anyFailingRequired(attributes) {
-		for (let i = 0; i < attributes.length; i++) if (!this.validateRequired(deepFind(this.data, attributes[i]))) return true;
-		return false;
-	}
+	minNumbers = 0;
 	/**
-	* Determine if all of the given attributes fail the required test.
+	* The min amount of symbols required in the password
 	*/
-	allFailingRequired(attributes) {
-		for (let i = 0; i < attributes.length; i++) if (this.validateRequired(deepFind(this.data, attributes[i]))) return false;
-		return true;
-	}
+	minSymbols = 0;
 	/**
-	* Validate that an attribute is a string.
+	* Additional validation rules that should be merged into the default rules during validation.
 	*/
-	validateString(value) {
-		return typeof value === "string";
-	}
+	customRules = [];
 	/**
-	* Validate the size of an attribute is less than a maximum value.
+	* The callback that will generate the "default" version of the password rule.
 	*/
-	validateMax(value, parameters, attribute) {
-		this.requireParameterCount(1, parameters, "max");
-		if (isNaN(parameters[0])) throw "Validation rule max requires parameter to be a number.";
-		return getSize(value, validationRuleParser.hasRule(attribute, getNumericRules(), this.rules)) <= Number(parameters[0]);
+	static defaultCallback;
+	/**
+	* Create a new instance of the password class
+	*/
+	static create() {
+		return new Password$1();
 	}
 	/**
-	* Validate the size of an attribute is greater than a minimum value.
+	* Set the minimum length of the password
 	*/
-	validateMin(value, parameters, attribute) {
-		this.requireParameterCount(1, parameters, "min");
-		if (isNaN(parameters[0])) throw "Validation rule min requires parameter to be a number.";
-		return getSize(value, validationRuleParser.hasRule(attribute, getNumericRules(), this.rules)) >= Number(parameters[0]);
+	min(min) {
+		this.minLength = min;
+		return this;
 	}
 	/**
-	* Validate that an attribute is numeric.
+	* Set the min amount of letters required in the password
 	*/
-	validateNumeric(value, parameters, attribute) {
-		if (validationRuleParser.hasRule(attribute, "strict", this.rules) && typeof value !== "number") return false;
-		return value !== null && isNaN(value) === false;
+	letters(letters = 1) {
+		this.minLetters = letters;
+		return this;
 	}
 	/**
-	* Validate that an attribute is an object
+	* Set the min amount of upper and lower case letters required in the password
 	*/
-	validateObject(value) {
-		return isObject(value);
+	mixedCase(upperCase = 1, lowerCase = 1) {
+		this.minUpperCase = upperCase;
+		this.minLowerCase = lowerCase;
+		return this;
 	}
 	/**
-	* Validate that an attribute exists even if not filled.
+	* Set the min amount of numbers required in the password
 	*/
-	validatePresent(value, parameters, attribute) {
-		return typeof deepFind(this.data, attribute) !== "undefined";
+	numbers(numbers = 1) {
+		this.minNumbers = numbers;
+		return this;
 	}
 	/**
-	* Validate that an attribute is an integer.
+	* Set the min amount of symbols required in the password
 	*/
-	validateInteger(value, parameters, attribute) {
-		if (validationRuleParser.hasRule(attribute, "strict", this.rules) && typeof value !== "number") return false;
-		return isInteger(value);
+	symbols(symbols = 1) {
+		this.minSymbols = symbols;
+		return this;
 	}
 	/**
-	* Validate that the attribute is a valid JSON string
+	* Determine if the validation rule passes.
 	*/
-	validateJson(value) {
-		if (!value || typeof value !== "string") return false;
-		try {
-			JSON.parse(value);
-		} catch {
-			return false;
+	passes(value, attribute) {
+		const validator = new BaseValidator(this.data, { [attribute]: [
+			"string",
+			`min:${this.minLength}`,
+			...this.customRules
+		] }, this.validator.customMessages, this.validator.customAttributes).setLang(this.lang);
+		if (!validator.validate()) {
+			const errors = validator.errors().addErrorTypes().get(attribute);
+			for (const key in errors) this.validator.errors().add(attribute, errors[key]);
+		}
+		if (typeof value !== "string") value = "";
+		let pattern;
+		const formattedAttribute = this.validator.getDisplayableAttribute(attribute);
+		if (this.minLowerCase) {
+			pattern = this.minLowerCase === 1 ? /\p{Ll}/u : new RegExp(`(.*\\p{Ll}){${this.minLowerCase}}.*`, "u");
+			if (!value || pattern.test(value) === false) this.validator.errors().add(attribute, {
+				error_type: "min_lower_case",
+				message: this.trans(`password.${this.minLowerCase === 1 ? "lower_case" : "lower_cases"}`, {
+					attribute: formattedAttribute,
+					amount: this.minLowerCase
+				})
+			});
+		}
+		if (this.minUpperCase) {
+			pattern = this.minUpperCase === 1 ? /\p{Lu}/u : new RegExp(`(.*\\p{Lu}){${this.minUpperCase}}.*`, "u");
+			if (!value || pattern.test(value) === false) this.validator.errors().add(attribute, {
+				error_type: "min_upper_case",
+				message: this.trans(`password.${this.minUpperCase === 1 ? "upper_case" : "upper_cases"}`, {
+					attribute: formattedAttribute,
+					amount: this.minUpperCase
+				})
+			});
+		}
+		if (this.minLetters) {
+			pattern = this.minLetters === 1 ? /\p{L}/u : new RegExp(`(.*\\p{L}){${this.minLetters}}.*`, "u");
+			if (!value || pattern.test(value) === false) this.validator.errors().add(attribute, {
+				error_type: "min_letters",
+				message: this.trans(`password.${this.minLetters === 1 ? "letter" : "letters"}`, {
+					attribute: formattedAttribute,
+					amount: this.minLetters
+				})
+			});
+		}
+		if (this.minNumbers) {
+			pattern = this.minNumbers === 1 ? /\p{N}/u : new RegExp(`(.*\\p{N}){${this.minNumbers}}.*`, "u");
+			if (!value || pattern.test(value) === false) this.validator.errors().add(attribute, {
+				error_type: "min_numbers",
+				message: this.trans(`password.${this.minNumbers === 1 ? "number" : "numbers"}`, {
+					attribute: formattedAttribute,
+					amount: this.minNumbers
+				})
+			});
+		}
+		if (this.minSymbols) {
+			pattern = this.minSymbols === 1 ? /\p{Z}|\p{S}|\p{P}/u : new RegExp(`(.*(\\p{Z}|\\p{S}|\\p{P})){${this.minSymbols}}.*`, "u");
+			if (!value || pattern.test(value) === false) this.validator.errors().add(attribute, {
+				error_type: "min_symbols",
+				message: this.trans(`password.${this.minSymbols === 1 ? "symbol" : "symbols"}`, {
+					attribute: formattedAttribute,
+					amount: this.minSymbols
+				})
+			});
 		}
+		if (this.validator.errors().has(attribute)) return false;
 		return true;
 	}
 	/**
-	* Validate that an attribute is greater than another attribute.
-	*/
-	validateGt(value, parameters, attribute) {
-		this.requireParameterCount(1, parameters, "gt");
-		if (typeof value !== "number" && typeof value !== "string" && typeof value !== "object") throw "The field under validation must be a number, string, array or object";
-		const compartedToValue = deepFind(this.data, parameters[0]) || parameters[0];
-		if (!Array.isArray(compartedToValue) && isNaN(compartedToValue) === false) return getSize(value, validationRuleParser.hasRule(attribute, getNumericRules(), this.rules)) > compartedToValue;
-		if (sameType(value, compartedToValue) === false) throw "The fields under validation must be of the same type";
-		return getSize(value) > getSize(compartedToValue);
-	}
-	/**
-	* Validate that an attribute is greater than or equal  another attribute.
+	* Specify additional validation rules that should be merged with the default rules during validation.
 	*/
-	validateGte(value, parameters, attribute) {
-		this.requireParameterCount(1, parameters, "gte");
-		if (typeof value !== "number" && typeof value !== "string" && typeof value !== "object") throw "The field under validation must be a number, string, array or object";
-		const compartedToValue = deepFind(this.data, parameters[0]) || parameters[0];
-		if (!Array.isArray(compartedToValue) && isNaN(compartedToValue) === false) return getSize(value, validationRuleParser.hasRule(attribute, getNumericRules(), this.rules)) >= compartedToValue;
-		if (sameType(value, compartedToValue) === false) throw "The fields under validation must be of the same type";
-		return getSize(value) >= getSize(compartedToValue);
+	rules(rules) {
+		this.customRules = rules;
+		return this;
 	}
 	/**
-	* Validate that an attribute is less than another attribute.
+	* Get all the validation error messages related to the password
 	*/
-	validateLt(value, parameters, attribute) {
-		this.requireParameterCount(1, parameters, "lt");
-		if (typeof value !== "number" && typeof value !== "string" && typeof value !== "object") throw "The field under validation must be a number, string, array or object";
-		const compartedToValue = deepFind(this.data, parameters[0]) || parameters[0];
-		if (!Array.isArray(compartedToValue) && isNaN(compartedToValue) === false) return getSize(value, validationRuleParser.hasRule(attribute, getNumericRules(), this.rules)) < compartedToValue;
-		if (sameType(value, compartedToValue) === false) throw "The fields under validation must be of the same type";
-		return getSize(value) < getSize(compartedToValue);
+	getMessage() {
+		return {};
 	}
 	/**
-	* Validate that an attribute is less than or equal another attribute.
+	* Set the validator instance used to validate the password
 	*/
-	validateLte(value, parameters, attribute) {
-		this.requireParameterCount(1, parameters, "lte");
-		if (typeof value !== "number" && typeof value !== "string" && typeof value !== "object") throw "The field under validation must be a number, string, array or object";
-		const compartedToValue = deepFind(this.data, parameters[0]) || parameters[0];
-		if (!Array.isArray(compartedToValue) && isNaN(compartedToValue) === false) return getSize(value, validationRuleParser.hasRule(attribute, getNumericRules(), this.rules)) <= compartedToValue;
-		if (sameType(value, compartedToValue) === false) throw "The fields under validation must be of the same type";
-		return getSize(value) <= getSize(compartedToValue);
+	setValidator(validator) {
+		this.validator = validator;
+		return this;
 	}
 	/**
-	* Validate an attribute is contained within a list of values.
+	* Set the default callback to be used for determining a password's default rules.
 	*/
-	validateIn(value, parameters) {
-		this.requireParameterCount(1, parameters, "in");
-		if (Array.isArray(value)) {
-			for (let index = 0; index < value.length; index++) if (typeof value[index] !== "number" && typeof value[index] !== "string") return false;
-			return value.filter((element) => parameters.indexOf(element.toString()) === -1).length === 0;
+	static setDefault(callback = null) {
+		if (callback instanceof Password$1) {
+			this.defaultCallback = callback;
+			return;
 		}
-		if (typeof value !== "number" && typeof value !== "string") return false;
-		return parameters.indexOf(value.toString()) !== -1;
-	}
-	/**
-	* "Indicate" validation should pass if value is null
-	*
-	* Always returns true, just lets us put "nullable" in rules.
-	*/
-	validateNullable() {
-		return true;
+		if (typeof callback !== "function") throw "The given callback should be callable";
+		this.defaultCallback = callback;
 	}
 	/**
-	* Validate an attribute is not contained within a list of values.
+	* Get the default configuration of the password rule.
 	*/
-	validateNotIn(value, parameters) {
-		this.requireParameterCount(1, parameters, "not_in");
-		const valuesToCheck = [];
-		if (Array.isArray(value)) {
-			for (let index = 0; index < value.length; index++) if (typeof value[index] === "number" || typeof value[index] === "string") valuesToCheck.push(value[index]);
-			if (valuesToCheck.length === 0) return true;
-			return valuesToCheck.filter((element) => parameters.indexOf(element.toString()) !== -1).length === 0;
-		}
-		if (typeof value !== "number" && typeof value !== "string") return true;
-		return parameters.indexOf(value.toString()) === -1;
+	static default() {
+		const password = typeof this.defaultCallback === "function" ? this.defaultCallback() : this.defaultCallback;
+		return password instanceof IRuleContract ? password : Password$1.create().min(8);
 	}
+};
+
+//#endregion
+//#region src/utilities/build.ts
+function buildValidationMethodName(rule) {
+	if (!rule) return rule;
+	return rule.split("_").map((rule) => `${rule[0].toUpperCase()}${rule.slice(1)}`).join("");
+}
+
+//#endregion
+//#region src/payloads/replaceAttributePayload.ts
+var replaceAttributePayload = class {
 	/**
-	* Always returns true - this method will be used in conbination with other rules
+	* Stores the data object
 	*/
-	validateStrict() {
-		return true;
-	}
+	data;
 	/**
-	* Validate that an attribute is a valid URL.
+	* The message in which attributes will be replaced
 	*/
-	validateUrl(value) {
-		if (typeof value !== "string") return false;
-		return new RegExp("^(https?:\\/\\/)?((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|localhost|((\\d{1,3}\\.){3}\\d{1,3}))(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*(\\?[;&a-z\\d%_.~+=-]*)?(\\#[-a-z\\d_]*)?$", "i").test(value);
-	}
+	message;
 	/**
-	*  Determine if a comparison passes between the given values.
+	* Parameters that will be used to replace the attributes
 	*/
-	compareDates(value, parameter, operator, rule) {
-		value = toDate(value);
-		if (!value) throw `Validation rule ${rule} requires the field under valation to be a date.`;
-		const compartedToValue = toDate(deepFind(this.data, parameter) || parameter);
-		if (!compartedToValue) throw `Validation rule ${rule} requires the parameter to be a date.`;
-		return compare(value.getTime(), compartedToValue.getTime(), operator);
-	}
+	parameters;
 	/**
-	* Require a certain number of parameters to be present
+	* Flag that identifies wether the numeric rule exists or not
 	*/
-	requireParameterCount(count, parameters, rule) {
-		if (parameters.length < count) throw `Validation rule ${rule} requires at least ${count} parameters.`;
-	}
+	hasNumericRule;
 	/**
-	* Prepare the values for validation
+	* The function that will be used to format attributes
 	*/
-	parseDependentRuleParameters(other, parameters) {
-		let values = parameters.slice(1);
-		if (other === null) values = convertValuesToNull(values);
-		if (typeof other === "number") values = convertValuesToNumber(values);
-		if (typeof other === "boolean") values = convertValuesToBoolean(values);
-		return values;
+	getDisplayableAttribute;
+	constructor(data, message, parameters, hasNumericRule, getDisplayableAttribute) {
+		this.data = data;
+		this.message = message;
+		this.parameters = parameters;
+		this.hasNumericRule = hasNumericRule;
+		this.getDisplayableAttribute = getDisplayableAttribute;
 	}
 };
 
 //#endregion
 //#region src/BaseValidator.ts
-var BaseValidator = class {
+var BaseValidator = class BaseValidator {
 	/**
 	* The lang used to return error messages
 	*/
@@ -1920,6 +2067,10 @@ var BaseValidator = class {
 	* Object of custom attribute name;
 	*/
 	customAttributes;
+	/**
+	* Arbitrary per-validator context for plugins.
+	*/
+	context = {};
 	constructor(data, rules, customMessages = {}, customAttributes = {}) {
 		this.data = data;
 		this.customMessages = dotify(customMessages);
@@ -1929,6 +2080,18 @@ var BaseValidator = class {
 		this.addRules(rules);
 		this.messages = new ErrorBag();
 	}
+	static use(plugin) {
+		usePlugin(plugin);
+		return this;
+	}
+	static useContext(context = {}) {
+		useValidatorContext(context);
+		return this;
+	}
+	use(plugin) {
+		BaseValidator.use(plugin);
+		return this;
+	}
 	setData(data) {
 		this.data = data;
 		this.addRules(this.initalRules);
@@ -1943,24 +2106,78 @@ var BaseValidator = class {
 		this.lang = lang;
 		return this;
 	}
+	/**
+	* Set the validator's context.
+	*/
+	withContext(context = {}) {
+		this.context = context;
+		return this;
+	}
+	/**
+	* Get the validator's context. 
+	* This is useful for custom rules that need access to additional data or services.
+	* 
+	* @returns The current context object
+	*/
+	getContext() {
+		return {
+			...getValidatorContext(),
+			...this.context
+		};
+	}
+	/**
+	* Get the current language used by the validator. 
+	* 
+	* @returns 
+	*/
 	getLang() {
 		return this.lang;
 	}
+	/**
+	* Set custom error messages for the validator. 
+	* 
+	* @param customMessages 
+	* @returns 
+	*/
 	setCustomMessages(customMessages = {}) {
 		this.customMessages = dotify(customMessages);
 		return this;
 	}
+	/**
+	* Set custom attribute names for the validator.
+	* 
+	* @param customAttributes 
+	* @returns 
+	*/
 	setCustomAttributes(customAttributes = {}) {
 		this.customAttributes = dotify(customAttributes);
 		return this;
 	}
+	/**
+	* Set whether the validator should stop validating after the first failure.
+	* 
+	* @param stopOnFirstFailure 
+	* @returns 
+	*/
 	stopOnFirstFailure(stopOnFirstFailure = true) {
 		this.stopOnFirstFailureFlag = stopOnFirstFailure;
 		return this;
 	}
+	/**
+	* Get the error messages related to the validation.
+	* 
+	* @returns 
+	*/
 	errors() {
 		return this.messages;
 	}
+	/**
+	* Clear the error messages for the given keys. 
+	* If no keys are provided, all error messages will be cleared.
+	* 
+	* @param keys  The keys of the error messages to clear
+	* @returns     The updated ErrorBag instance
+	*/
 	clearErrors(keys = []) {
 		this.messages = this.messages.clear(keys).clone();
 		return this.messages;
@@ -1985,7 +2202,7 @@ var BaseValidator = class {
 	*/
 	validate(key = "", value = void 0) {
 		if (!isObject(this.data)) throw "The data attribute must be an object";
-		this.validateAttributes = new validateAttributes(this.data, this.rules);
+		this.validateAttributes = new validateAttributes(this.data, this.rules, this.getContext());
 		if (!key) {
 			this.runAllValidations();
 			return this.messages.keys().length === 0;
@@ -1999,7 +2216,7 @@ var BaseValidator = class {
 	*/
 	async validateAsync(key = "", value = void 0) {
 		if (!isObject(this.data)) throw "The data attribute must be an object";
-		this.validateAttributes = new validateAttributes(this.data, this.rules);
+		this.validateAttributes = new validateAttributes(this.data, this.rules, this.getContext());
 		if (!key) {
 			await this.runAllValidationsAsync();
 			return this.messages.keys().length === 0;
@@ -2010,6 +2227,9 @@ var BaseValidator = class {
 	}
 	/**
 	* Get the displayable name of the attribute.
+	* 
+	* @param attribute 
+	* @returns 
 	*/
 	getDisplayableAttribute(attribute) {
 		const primaryAttribute = this.getPrimaryAttribute(attribute);
@@ -2066,7 +2286,7 @@ var BaseValidator = class {
 	*/
 	runAllValidations() {
 		this.messages = new ErrorBag();
-		this.validateAttributes = new validateAttributes(this.data, this.rules);
+		this.validateAttributes = new validateAttributes(this.data, this.rules, this.getContext());
 		for (const property in this.rules) if (this.runValidation(property) === false) break;
 	}
 	/**
@@ -2074,7 +2294,7 @@ var BaseValidator = class {
 	*/
 	async runAllValidationsAsync() {
 		this.messages = new ErrorBag();
-		this.validateAttributes = new validateAttributes(this.data, this.rules);
+		this.validateAttributes = new validateAttributes(this.data, this.rules, this.getContext());
 		for (const property in this.rules) if (await this.runValidationAsync(property) === false) break;
 	}
 	/**
@@ -2256,19 +2476,6 @@ var BaseValidator = class {
 //#region src/Contracts/IDatabaseDriver.ts
 var IDatabaseDriver = class {};
 
-//#endregion
-//#region src/Rules/registerRule.ts
-function register(rule, validate, replaceMessage) {
-	const method = buildValidationMethodName(rule);
-	if (new validateAttributes()[`validate${method}`]) return false;
-	validateAttributes.prototype[`validate${method}`] = validate;
-	if (typeof replaceMessage === "function") replaceAttributes[`replace${method}`] = ({ message, parameters, data, getDisplayableAttribute }) => replaceMessage(message, parameters, data, getDisplayableAttribute);
-	return true;
-}
-function registerImplicit(rule, validate, replaceMessage) {
-	if (register(rule, validate, replaceMessage) === true) addImplicitRule(rule);
-}
-
 //#endregion
 //#region src/Rules/in.ts
 var In = class extends BaseRule {
@@ -2559,19 +2766,6 @@ var ExtendedRules = class extends ValidationRule {
 	validate() {}
 };
 
-//#endregion
-//#region src/utilities/helpers.ts
-/**
-* Pluralizes a word based on the count.
-* 
-* @param word 
-* @param count 
-* @returns 
-*/
-const plural = (word, count) => {
-	return count === 1 ? word : `${word}s`;
-};
-
 //#endregion
 //#region src/utilities/MessageBag.ts
 var MessageBag = class {
@@ -2802,6 +2996,7 @@ var Validator = class Validator {
 	errorBagName = "default";
 	registeredCustomRules = [new ExtendedRules()];
 	shouldStopOnFirstFailure = false;
+	context = {};
 	constructor(data, rules, messages = {}) {
 		register("telephone", function(value) {
 			return /^\d{3}-\d{3}-\d{4}$/.test(value);
@@ -2823,6 +3018,38 @@ var Validator = class Validator {
 		return Validator;
 	}
 	/**
+	* Set the validator's context.
+	* 
+	* @param context 
+	* @returns 
+	*/
+	static useContext(context = {}) {
+		useValidatorContext(context);
+		return this;
+	}
+	/**
+	* Register a plugin with the validator. 
+	* Plugins can add rules, messages, and even override existing rules and messages.
+	* 
+	* @param plugin The plugin to register
+	* @returns The Validator class for chaining
+	*/
+	static use(plugin) {
+		usePlugin(plugin);
+		return this;
+	}
+	/**
+	* Register a plugin with the validator. 
+	* Plugins can add rules, messages, and even override existing rules and messages.
+	* 
+	* @param plugin The plugin to register
+	* @returns The Validator instance for chaining
+	*/
+	use(plugin) {
+		Validator.use(plugin);
+		return this;
+	}
+	/**
 	* Run the validator and store results.
 	*/
 	async passes() {
@@ -2863,12 +3090,39 @@ var Validator = class Validator {
 		return this;
 	}
 	/**
+	* Set the validator's context. 
+	* This is useful for custom rules that need access to additional data or services.
+	* 
+	* @param context 
+	* @returns 
+	*/
+	withContext(context = {}) {
+		this.context = context;
+		return this;
+	}
+	/**
+	* Get the validator's context. 
+	* This is useful for custom rules that need access to additional data or services.
+	* 
+	* @returns The current context object
+	*/
+	getContext() {
+		return {
+			...getValidatorContext(),
+			...this.context
+		};
+	}
+	/**
 	* Get the data that passed validation.
 	*/
 	validatedData() {
 		const validKeys = Object.keys(this.rules);
 		const clean = {};
-		for (const key of validKeys) if (this.data[key] !== void 0) clean[key] = this.data[key];
+		for (const key of validKeys) {
+			const value = deepFind(this.data, key);
+			const resolvedValue = typeof value !== "undefined" ? value : deepFind(this.getContext().requestFiles ?? {}, key);
+			if (typeof resolvedValue !== "undefined") deepSet(clean, key, resolvedValue);
+		}
 		return clean;
 	}
 	/**
@@ -2984,7 +3238,7 @@ var Validator = class Validator {
 		return this;
 	}
 	async execute() {
-		const instance = make().setData(this.data).setRules(this.rules).setCustomMessages(this.#messages).stopOnFirstFailure(this.shouldStopOnFirstFailure);
+		const instance = make().setData(this.data).setRules(this.rules).setCustomMessages(this.#messages).withContext(this.getContext()).stopOnFirstFailure(this.shouldStopOnFirstFailure);
 		this.passing = await instance.validateAsync();
 		this.executed = true;
 		this.instance = instance;
@@ -2999,6 +3253,7 @@ var ValidationException = class ValidationException extends Error {
 	validator;
 	response;
 	status = 422;
+	statusCode = 422;
 	errorBag = "default";
 	redirectTo;
 	name = "ValidationException";
@@ -3101,13 +3356,19 @@ exports.convertValuesToNull = convertValuesToNull;
 exports.convertValuesToNumber = convertValuesToNumber;
 exports.deepEqual = deepEqual;
 exports.deepFind = deepFind;
+exports.deepFindMessage = deepFindMessage;
 exports.deepSet = deepSet;
+exports.definePlugin = definePlugin;
 exports.dotify = dotify;
 exports.getFormattedAttribute = getFormattedAttribute;
 exports.getKeyCombinations = getKeyCombinations;
 exports.getMessage = getMessage;
 exports.getNumericRules = getNumericRules;
 exports.getSize = getSize;
+exports.getValidationMessageType = getValidationMessageType;
+exports.getValidationSize = getValidationSize;
+exports.getValidationValueInspector = getValidationValueInspector;
+exports.getValidatorContext = getValidatorContext;
 exports.isArrayOfRules = isArrayOfRules;
 exports.isImplicitRule = isImplicitRule;
 exports.isInteger = isInteger;
@@ -3122,9 +3383,13 @@ exports.plural = plural;
 exports.regex = regex;
 exports.register = register;
 exports.registerImplicit = registerImplicit;
+exports.registerValueInspector = registerValueInspector;
 exports.requiredIf = requiredIf;
 exports.ruleIn = ruleIn;
 exports.ruleNotIn = ruleNotIn;
+exports.runWithValidatorContext = runWithValidatorContext;
 exports.sameType = sameType;
 exports.toDate = toDate;
-exports.toSnakeCase = toSnakeCase;
+exports.toSnakeCase = toSnakeCase;
+exports.usePlugin = usePlugin;
+exports.useValidatorContext = useValidatorContext;